HID: make debugging output runtime-configurable

There have been many reports recently about broken HID devices, the
diagnosis of which required users to recompile their kernels in order
to be able to provide debugging output needed for coding a quirk for
a particular device.

This patch makes CONFIG_HID_DEBUG default y if !EMBEDDED and makes it
possible to control debugging output produced by HID code by supplying
'debug=1' module parameter.

Signed-off-by: Jiri Kosina <jkosina@suse.cz>

diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 8fbe9fdac128ea232099499729f80693b3aa0acf..5b004b2b1a4e01082a63b0bf3dd036f7c39c5982 100644 (file)
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -24,6 +24,7 @@ config HID
 
 config HID_DEBUG
        bool "HID debugging support"
+       default y if !EMBEDDED
        depends on HID
        ---help---
        This option lets the HID layer output diagnostics about its internal

diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 6ec04e79f6856c0340f20a31f0b08bb9b6afeeb6..317cf8a7b63c11ed03e76772c8c8710a3ec5505c 100644 (file)
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -40,6 +40,13 @@
 #define DRIVER_DESC "HID core driver"
 #define DRIVER_LICENSE "GPL"
 
+#ifdef CONFIG_HID_DEBUG
+int hid_debug = 0;
+module_param_named(debug, hid_debug, bool, 0600);
+MODULE_PARM_DESC(debug, "Turn HID debugging mode on and off");
+EXPORT_SYMBOL_GPL(hid_debug);
+#endif
+
 /*
  * Register a new report for a device.
  */
@@ -78,7 +85,7 @@ static struct hid_field *hid_register_field(struct hid_report *report, unsigned
        struct hid_field *field;
 
        if (report->maxfield == HID_MAX_FIELDS) {
-               dbg("too many fields in report");
+               dbg_hid("too many fields in report\n");
                return NULL;
        }
 
@@ -106,7 +113,7 @@ static int open_collection(struct hid_parser *parser, unsigned type)
        usage = parser->local.usage[0];
 
        if (parser->collection_stack_ptr == HID_COLLECTION_STACK_SIZE) {
-               dbg("collection stack overflow");
+               dbg_hid("collection stack overflow\n");
                return -1;
        }
 
@@ -114,7 +121,7 @@ static int open_collection(struct hid_parser *parser, unsigned type)
                collection = kmalloc(sizeof(struct hid_collection) *
                                parser->device->collection_size * 2, GFP_KERNEL);
                if (collection == NULL) {
-                       dbg("failed to reallocate collection array");
+                       dbg_hid("failed to reallocate collection array\n");
                        return -1;
                }
                memcpy(collection, parser->device->collection,
@@ -150,7 +157,7 @@ static int open_collection(struct hid_parser *parser, unsigned type)
 static int close_collection(struct hid_parser *parser)
 {
        if (!parser->collection_stack_ptr) {
-               dbg("collection stack underflow");
+               dbg_hid("collection stack underflow\n");
                return -1;
        }
        parser->collection_stack_ptr--;
@@ -178,7 +185,7 @@ static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
 static int hid_add_usage(struct hid_parser *parser, unsigned usage)
 {
        if (parser->local.usage_index >= HID_MAX_USAGES) {
-               dbg("usage index exceeded");
+               dbg_hid("usage index exceeded\n");
                return -1;
        }
        parser->local.usage[parser->local.usage_index] = usage;
@@ -202,12 +209,12 @@ static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsign
        int i;
 
        if (!(report = hid_register_report(parser->device, report_type, parser->global.report_id))) {
-               dbg("hid_register_report failed");
+               dbg_hid("hid_register_report failed\n");
                return -1;
        }
 
        if (parser->global.logical_maximum < parser->global.logical_minimum) {
-               dbg("logical range invalid %d %d", parser->global.logical_minimum, parser->global.logical_maximum);
+               dbg_hid("logical range invalid %d %d\n", parser->global.logical_minimum, parser->global.logical_maximum);
                return -1;
        }
 
@@ -287,7 +294,7 @@ static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
                case HID_GLOBAL_ITEM_TAG_PUSH:
 
                        if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
-                               dbg("global enviroment stack overflow");
+                               dbg_hid("global enviroment stack overflow\n");
                                return -1;
                        }
 
@@ -298,7 +305,7 @@ static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
                case HID_GLOBAL_ITEM_TAG_POP:
 
                        if (!parser->global_stack_ptr) {
-                               dbg("global enviroment stack underflow");
+                               dbg_hid("global enviroment stack underflow\n");
                                return -1;
                        }
 
@@ -342,27 +349,27 @@ static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
 
                case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
                        if ((parser->global.report_size = item_udata(item)) > 32) {
-                               dbg("invalid report_size %d", parser->global.report_size);
+                               dbg_hid("invalid report_size %d\n", parser->global.report_size);
                                return -1;
                        }
                        return 0;
 
                case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
                        if ((parser->global.report_count = item_udata(item)) > HID_MAX_USAGES) {
-                               dbg("invalid report_count %d", parser->global.report_count);
+                               dbg_hid("invalid report_count %d\n", parser->global.report_count);
                                return -1;
                        }
                        return 0;
 
                case HID_GLOBAL_ITEM_TAG_REPORT_ID:
                        if ((parser->global.report_id = item_udata(item)) == 0) {
-                               dbg("report_id 0 is invalid");
+                               dbg_hid("report_id 0 is invalid\n");
                                return -1;
                        }
                        return 0;
 
                default:
-                       dbg("unknown global tag 0x%x", item->tag);
+                       dbg_hid("unknown global tag 0x%x\n", item->tag);
                        return -1;
        }
 }
@@ -377,7 +384,7 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
        unsigned n;
 
        if (item->size == 0) {
-               dbg("item data expected for local item");
+               dbg_hid("item data expected for local item\n");
                return -1;
        }
 
@@ -395,14 +402,14 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
                                 * items and the first delimiter set.
                                 */
                                if (parser->local.delimiter_depth != 0) {
-                                       dbg("nested delimiters");
+                                       dbg_hid("nested delimiters\n");
                                        return -1;
                                }
                                parser->local.delimiter_depth++;
                                parser->local.delimiter_branch++;
                        } else {
                                if (parser->local.delimiter_depth < 1) {
-                                       dbg("bogus close delimiter");
+                                       dbg_hid("bogus close delimiter\n");
                                        return -1;
                                }
                                parser->local.delimiter_depth--;
@@ -412,7 +419,7 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
                case HID_LOCAL_ITEM_TAG_USAGE:
 
                        if (parser->local.delimiter_branch > 1) {
-                               dbg("alternative usage ignored");
+                               dbg_hid("alternative usage ignored\n");
                                return 0;
                        }
 
@@ -424,7 +431,7 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
                case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
 
                        if (parser->local.delimiter_branch > 1) {
-                               dbg("alternative usage ignored");
+                               dbg_hid("alternative usage ignored\n");
                                return 0;
                        }
 
@@ -437,7 +444,7 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
                case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
 
                        if (parser->local.delimiter_branch > 1) {
-                               dbg("alternative usage ignored");
+                               dbg_hid("alternative usage ignored\n");
                                return 0;
                        }
 
@@ -446,14 +453,14 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
 
                        for (n = parser->local.usage_minimum; n <= data; n++)
                                if (hid_add_usage(parser, n)) {
-                                       dbg("hid_add_usage failed\n");
+                                       dbg_hid("hid_add_usage failed\n");
                                        return -1;
                                }
                        return 0;
 
                default:
 
-                       dbg("unknown local item tag 0x%x", item->tag);
+                       dbg_hid("unknown local item tag 0x%x\n", item->tag);
                        return 0;
        }
        return 0;
@@ -487,7 +494,7 @@ static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
                        ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
                        break;
                default:
-                       dbg("unknown main item tag 0x%x", item->tag);
+                       dbg_hid("unknown main item tag 0x%x\n", item->tag);
                        ret = 0;
        }
 
@@ -502,7 +509,7 @@ static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
 
 static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item)
 {
-       dbg("reserved item type, tag 0x%x", item->tag);
+       dbg_hid("reserved item type, tag 0x%x\n", item->tag);
        return 0;
 }
 
@@ -667,14 +674,14 @@ struct hid_device *hid_parse_report(__u8 *start, unsigned size)
        while ((start = fetch_item(start, end, &item)) != NULL) {
 
                if (item.format != HID_ITEM_FORMAT_SHORT) {
-                       dbg("unexpected long global item");
+                       dbg_hid("unexpected long global item\n");
                        hid_free_device(device);
                        vfree(parser);
                        return NULL;
                }
 
                if (dispatch_type[item.type](parser, &item)) {
-                       dbg("item %u %u %u %u parsing failed\n",
+                       dbg_hid("item %u %u %u %u parsing failed\n",
                                item.format, (unsigned)item.size, (unsigned)item.type, (unsigned)item.tag);
                        hid_free_device(device);
                        vfree(parser);
@@ -683,13 +690,13 @@ struct hid_device *hid_parse_report(__u8 *start, unsigned size)
 
                if (start == end) {
                        if (parser->collection_stack_ptr) {
-                               dbg("unbalanced collection at end of report description");
+                               dbg_hid("unbalanced collection at end of report description\n");
                                hid_free_device(device);
                                vfree(parser);
                                return NULL;
                        }
                        if (parser->local.delimiter_depth) {
-                               dbg("unbalanced delimiter at end of report description");
+                               dbg_hid("unbalanced delimiter at end of report description\n");
                                hid_free_device(device);
                                vfree(parser);
                                return NULL;
@@ -699,7 +706,7 @@ struct hid_device *hid_parse_report(__u8 *start, unsigned size)
                }
        }
 
-       dbg("item fetching failed at offset %d\n", (int)(end - start));
+       dbg_hid("item fetching failed at offset %d\n", (int)(end - start));
        hid_free_device(device);
        vfree(parser);
        return NULL;
@@ -915,13 +922,13 @@ int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
        hid_dump_input(field->usage + offset, value);
 
        if (offset >= field->report_count) {
-               dbg("offset (%d) exceeds report_count (%d)", offset, field->report_count);
+               dbg_hid("offset (%d) exceeds report_count (%d)\n", offset, field->report_count);
                hid_dump_field(field, 8);
                return -1;
        }
        if (field->logical_minimum < 0) {
                if (value != snto32(s32ton(value, size), size)) {
-                       dbg("value %d is out of range", value);
+                       dbg_hid("value %d is out of range\n", value);
                        return -1;
                }
        }
@@ -934,19 +941,17 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i
 {
        struct hid_report_enum *report_enum = hid->report_enum + type;
        struct hid_report *report;
-       int n, rsize;
+       int n, rsize, i;
 
        if (!hid)
                return -ENODEV;
 
        if (!size) {
-               dbg("empty report");
+               dbg_hid("empty report\n");
                return -1;
        }
 
-#ifdef CONFIG_HID_DEBUG
-       printk(KERN_DEBUG __FILE__ ": report (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
-#endif
+       dbg_hid("report (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
 
        n = 0;                          /* Normally report number is 0 */
        if (report_enum->numbered) {    /* Device uses numbered reports, data[0] is report number */
@@ -954,25 +959,21 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i
                size--;
        }
 
-#ifdef CONFIG_HID_DEBUG
-       {
-               int i;
-               printk(KERN_DEBUG __FILE__ ": report %d (size %u) = ", n, size);
-               for (i = 0; i < size; i++)
-                       printk(" %02x", data[i]);
-               printk("\n");
-       }
-#endif
+       /* dump the report descriptor */
+       dbg_hid("report %d (size %u) = ", n, size);
+       for (i = 0; i < size; i++)
+               dbg_hid_line(" %02x", data[i]);
+       dbg_hid_line("\n");
 
        if (!(report = report_enum->report_id_hash[n])) {
-               dbg("undefined report_id %d received", n);
+               dbg_hid("undefined report_id %d received\n", n);
                return -1;
        }
 
        rsize = ((report->size - 1) >> 3) + 1;
 
        if (size < rsize) {
-               dbg("report %d is too short, (%d < %d)", report->id, size, rsize);
+               dbg_hid("report %d is too short, (%d < %d)\n", report->id, size, rsize);
                memset(data + size, 0, rsize - size);
        }
 

diff --git a/drivers/hid/hid-debug.c b/drivers/hid/hid-debug.c
index 83c4126b37c333f59b575a40dce9f6fd1d2b675b..a13757b7898028986f98739eecfb3649be96bdfd 100644 (file)
--- a/drivers/hid/hid-debug.c
+++ b/drivers/hid/hid-debug.c
@@ -347,6 +347,9 @@ static void resolv_usage_page(unsigned page) {
 void hid_resolv_usage(unsigned usage) {
        const struct hid_usage_entry *p;
 
+       if (!hid_debug)
+               return;
+
        resolv_usage_page(usage >> 16);
        printk(".");
        for (p = hid_usage_table; p->description; p++)
@@ -369,6 +372,9 @@ __inline__ static void tab(int n) {
 void hid_dump_field(struct hid_field *field, int n) {
        int j;
 
+       if (!hid_debug)
+               return;
+
        if (field->physical) {
                tab(n);
                printk("Physical(");
@@ -466,6 +472,9 @@ void hid_dump_device(struct hid_device *device) {
        unsigned i,k;
        static char *table[] = {"INPUT", "OUTPUT", "FEATURE"};
 
+       if (!hid_debug)
+               return;
+
        for (i = 0; i < HID_REPORT_TYPES; i++) {
                report_enum = device->report_enum + i;
                list = report_enum->report_list.next;
@@ -489,6 +498,9 @@ void hid_dump_device(struct hid_device *device) {
 EXPORT_SYMBOL_GPL(hid_dump_device);
 
 void hid_dump_input(struct hid_usage *usage, __s32 value) {
+       if (!hid_debug)
+               return;
+
        printk("hid-debug: input ");
        hid_resolv_usage(usage->hid);
        printk(" = %d\n", value);
@@ -758,6 +770,9 @@ static char **names[EV_MAX + 1] = {
 
 void hid_resolv_event(__u8 type, __u16 code) {
 
+       if (!hid_debug)
+               return;
+
        printk("%s.%s", events[type] ? events[type] : "?",
                names[type] ? (names[type][code] ? names[type][code] : "?") : "?");
 }

diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index 7f817897b178063059be2cfde16e19caa8b6d3df..38595d3935cee15111104e5fb507a31d4c024a3c 100644 (file)
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -308,9 +308,7 @@ static int hidinput_setkeycode(struct input_dev *dev, int scancode,
                
                clear_bit(old_keycode, dev->keybit);
                set_bit(usage->code, dev->keybit);
-#ifdef CONFIG_HID_DEBUG
-               printk (KERN_DEBUG "Assigned keycode %d to HID usage code %x\n", keycode, scancode);
-#endif
+               dbg_hid(KERN_DEBUG "Assigned keycode %d to HID usage code %x\n", keycode, scancode);
                /* Set the keybit for the old keycode if the old keycode is used
                 * by another key */
                if (hidinput_find_key (hid, 0, old_keycode))
@@ -333,11 +331,9 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
 
        field->hidinput = hidinput;
 
-#ifdef CONFIG_HID_DEBUG
-       printk(KERN_DEBUG "Mapping: ");
+       dbg_hid("Mapping: ");
        hid_resolv_usage(usage->hid);
-       printk(" ---> ");
-#endif
+       dbg_hid_line(" ---> ");
 
        if (field->flags & HID_MAIN_ITEM_CONSTANT)
                goto ignore;
@@ -819,15 +815,13 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
        }
 
        hid_resolv_event(usage->type, usage->code);
-#ifdef CONFIG_HID_DEBUG
-       printk("\n");
-#endif
+
+       dbg_hid_line("\n");
+
        return;
 
 ignore:
-#ifdef CONFIG_HID_DEBUG
-       printk("IGNORED\n");
-#endif
+       dbg_hid_line("IGNORED\n");
        return;
 }
 
@@ -896,12 +890,12 @@ void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct
        }
 
        if (usage->hid == (HID_UP_PID | 0x83UL)) { /* Simultaneous Effects Max */
-               dbg("Maximum Effects - %d",value);
+               dbg_hid("Maximum Effects - %d\n",value);
                return;
        }
 
        if (usage->hid == (HID_UP_PID | 0x7fUL)) {
-               dbg("PID Pool Report\n");
+               dbg_hid("PID Pool Report\n");
                return;
        }
 
@@ -994,7 +988,7 @@ int hidinput_connect(struct hid_device *hid)
                                if (!hidinput || !input_dev) {
                                        kfree(hidinput);
                                        input_free_device(input_dev);
-                                       err("Out of memory during hid input probe");
+                                       err_hid("Out of memory during hid input probe");
                                        return -1;
                                }
 

diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index d91b9dac6dff67843b2a8faeff47a9807f6eac45..1eb2c64bc44adebc6425f14f7e1840617e892bd0 100644 (file)
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -127,7 +127,7 @@ static void hid_reset(struct work_struct *work)
                        hid_io_error(hid);
                break;
        default:
-               err("can't reset device, %s-%s/input%d, status %d",
+               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);
@@ -220,7 +220,7 @@ static void hid_irq_in(struct urb *urb)
        if (status) {
                clear_bit(HID_IN_RUNNING, &usbhid->iofl);
                if (status != -EPERM) {
-                       err("can't resubmit intr, %s-%s/input%d, status %d",
+                       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);
@@ -240,10 +240,10 @@ static int hid_submit_out(struct hid_device *hid)
        usbhid->urbout->transfer_buffer_length = ((report->size - 1) >> 3) + 1 + (report->id > 0);
        usbhid->urbout->dev = hid_to_usb_dev(hid);
 
-       dbg("submitting out urb");
+       dbg_hid("submitting out urb\n");
 
        if (usb_submit_urb(usbhid->urbout, GFP_ATOMIC)) {
-               err("usb_submit_urb(out) failed");
+               err_hid("usb_submit_urb(out) failed");
                return -1;
        }
 
@@ -287,12 +287,12 @@ static int hid_submit_ctrl(struct hid_device *hid)
        usbhid->cr->wIndex = cpu_to_le16(usbhid->ifnum);
        usbhid->cr->wLength = cpu_to_le16(len);
 
-       dbg("submitting ctrl urb: %s wValue=0x%04x wIndex=0x%04x wLength=%u",
+       dbg_hid("submitting ctrl urb: %s wValue=0x%04x wIndex=0x%04x wLength=%u\n",
                usbhid->cr->bRequest == HID_REQ_SET_REPORT ? "Set_Report" : "Get_Report",
                usbhid->cr->wValue, usbhid->cr->wIndex, usbhid->cr->wLength);
 
        if (usb_submit_urb(usbhid->urbctrl, GFP_ATOMIC)) {
-               err("usb_submit_urb(ctrl) failed");
+               err_hid("usb_submit_urb(ctrl) failed");
                return -1;
        }
 
@@ -474,7 +474,7 @@ int usbhid_wait_io(struct hid_device *hid)
        if (!wait_event_timeout(hid->wait, (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl) &&
                                        !test_bit(HID_OUT_RUNNING, &usbhid->iofl)),
                                        10*HZ)) {
-               dbg("timeout waiting for ctrl or out queue to clear");
+               dbg_hid("timeout waiting for ctrl or out queue to clear\n");
                return -1;
        }
 
@@ -667,7 +667,7 @@ static void hid_fixup_sony_ps3_controller(struct usb_device *dev, int ifnum)
                                 USB_CTRL_GET_TIMEOUT);
 
        if (result < 0)
-               err("%s failed: %d\n", __func__, result);
+               err_hid("%s failed: %d\n", __func__, result);
 
        kfree(buf);
 }
@@ -746,7 +746,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
        if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) &&
            (!interface->desc.bNumEndpoints ||
             usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) {
-               dbg("class descriptor not present\n");
+               dbg_hid("class descriptor not present\n");
                return NULL;
        }
 
@@ -755,19 +755,19 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                        rsize = le16_to_cpu(hdesc->desc[n].wDescriptorLength);
 
        if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {
-               dbg("weird size of report descriptor (%u)", rsize);
+               dbg_hid("weird size of report descriptor (%u)\n", rsize);
                return NULL;
        }
 
        if (!(rdesc = kmalloc(rsize, GFP_KERNEL))) {
-               dbg("couldn't allocate rdesc memory");
+               dbg_hid("couldn't allocate rdesc memory\n");
                return NULL;
        }
 
        hid_set_idle(dev, interface->desc.bInterfaceNumber, 0, 0);
 
        if ((n = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber, HID_DT_REPORT, rdesc, rsize)) < 0) {
-               dbg("reading report descriptor failed");
+               dbg_hid("reading report descriptor failed\n");
                kfree(rdesc);
                return NULL;
        }
@@ -781,15 +781,13 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
        if (quirks & HID_QUIRK_SWAPPED_MIN_MAX)
                hid_fixup_cypress_descriptor(rdesc, rsize);
 
-#ifdef CONFIG_HID_DEBUG
-       printk(KERN_DEBUG __FILE__ ": report descriptor (size %u, read %d) = ", rsize, n);
+       dbg_hid("report descriptor (size %u, read %d) = ", rsize, n);
        for (n = 0; n < rsize; n++)
-               printk(" %02x", (unsigned char) rdesc[n]);
-       printk("\n");
-#endif
+               dbg_hid_line(" %02x", (unsigned char) rdesc[n]);
+       dbg_hid_line("\n");
 
        if (!(hid = hid_parse_report(rdesc, n))) {
-               dbg("parsing report descriptor failed");
+               dbg_hid("parsing report descriptor failed\n");
                kfree(rdesc);
                return NULL;
        }
@@ -861,7 +859,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
        }
 
        if (!usbhid->urbin) {
-               err("couldn't find an input interrupt endpoint");
+               err_hid("couldn't find an input interrupt endpoint");
                goto fail;
        }
 
@@ -978,7 +976,7 @@ static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id)
        int i;
        char *c;
 
-       dbg("HID probe called for ifnum %d",
+       dbg_hid("HID probe called for ifnum %d\n",
                        intf->altsetting->desc.bInterfaceNumber);
 
        if (!(hid = usb_hid_configure(intf)))

diff --git a/drivers/hid/usbhid/hid-lgff.c b/drivers/hid/usbhid/hid-lgff.c
index c5cd4107d6aff59f833c4ec9bc79b956522fd135..4b7ab6a46d93b9d2e539820382a33b8edd76ee71 100644 (file)
--- a/drivers/hid/usbhid/hid-lgff.c
+++ b/drivers/hid/usbhid/hid-lgff.c
@@ -78,7 +78,7 @@ static int hid_lgff_play(struct input_dev *dev, void *data, struct ff_effect *ef
                report->field[0]->value[1] = 0x08;
                report->field[0]->value[2] = x;
                report->field[0]->value[3] = y;
-               dbg("(x, y)=(%04x, %04x)", x, y);
+               dbg_hid("(x, y)=(%04x, %04x)\n", x, y);
                usbhid_submit_report(hid, report, USB_DIR_OUT);
                break;
 
@@ -93,7 +93,7 @@ static int hid_lgff_play(struct input_dev *dev, void *data, struct ff_effect *ef
                report->field[0]->value[1] = 0x00;
                report->field[0]->value[2] = left;
                report->field[0]->value[3] = right;
-               dbg("(left, right)=(%04x, %04x)", left, right);
+               dbg_hid("(left, right)=(%04x, %04x)\n", left, right);
                usbhid_submit_report(hid, report, USB_DIR_OUT);
                break;
        }
@@ -113,20 +113,20 @@ int hid_lgff_init(struct hid_device* hid)
 
        /* Find the report to use */
        if (list_empty(report_list)) {
-               err("No output report found");
+               err_hid("No output report found");
                return -1;
        }
 
        /* Check that the report looks ok */
        report = list_entry(report_list->next, struct hid_report, list);
        if (!report) {
-               err("NULL output report");
+               err_hid("NULL output report");
                return -1;
        }
 
        field = report->field[0];
        if (!field) {
-               err("NULL field");
+               err_hid("NULL field");
                return -1;
        }
 

diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index f6c4145dc20253a885ead58fabd0665c8497f273..a418ebfe39b8c86e9426562a0a0ba02797cd61ff 100644 (file)
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -493,7 +493,7 @@ static struct hid_blacklist *usbhid_exists_dquirk(const u16 idVendor,
        }
 
        if (bl_entry != NULL)
-               dbg("Found dynamic quirk 0x%x for USB HID vendor 0x%hx prod 0x%hx\n",
+               dbg_hid("Found dynamic quirk 0x%x for USB HID vendor 0x%hx prod 0x%hx\n",
                                bl_entry->quirks, bl_entry->idVendor,
                                bl_entry->idProduct);
 
@@ -521,13 +521,13 @@ int usbhid_modify_dquirk(const u16 idVendor, const u16 idProduct,
        int list_edited = 0;
 
        if (!idVendor) {
-               dbg("Cannot add a quirk with idVendor = 0");
+               dbg_hid("Cannot add a quirk with idVendor = 0\n");
                return -EINVAL;
        }
 
        q_new = kmalloc(sizeof(struct quirks_list_struct), GFP_KERNEL);
        if (!q_new) {
-               dbg("Could not allocate quirks_list_struct");
+               dbg_hid("Could not allocate quirks_list_struct\n");
                return -ENOMEM;
        }
 
@@ -643,7 +643,7 @@ static const struct hid_blacklist *usbhid_exists_squirk(const u16 idVendor,
                        bl_entry = &hid_blacklist[n];
 
        if (bl_entry != NULL)
-               dbg("Found squirk 0x%x for USB HID vendor 0x%hx prod 0x%hx\n",
+               dbg_hid("Found squirk 0x%x for USB HID vendor 0x%hx prod 0x%hx\n",
                                bl_entry->quirks, bl_entry->idVendor, 
                                bl_entry->idProduct);
        return bl_entry;

diff --git a/drivers/hid/usbhid/hid-tmff.c b/drivers/hid/usbhid/hid-tmff.c
index ab5ba6ef891cb756fd531119baeabef7211c6dcd..555bb48b4295d0d7ea167702ea125bcb4cbd1088 100644 (file)
--- a/drivers/hid/usbhid/hid-tmff.c
+++ b/drivers/hid/usbhid/hid-tmff.c
@@ -70,7 +70,7 @@ static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *ef
 
        tmff->rumble->value[0] = left;
        tmff->rumble->value[1] = right;
-       dbg("(left,right)=(%08x, %08x)", left, right);
+       dbg_hid("(left,right)=(%08x, %08x)\n", left, right);
        usbhid_submit_report(hid, tmff->report, USB_DIR_OUT);
 
        return 0;

diff --git a/drivers/hid/usbhid/hid-zpff.c b/drivers/hid/usbhid/hid-zpff.c
index a7fbffcdaf363e4398155b774da7bf32156b9db3..5a688274f6a3331d2264d10de5fff780de473b9c 100644 (file)
--- a/drivers/hid/usbhid/hid-zpff.c
+++ b/drivers/hid/usbhid/hid-zpff.c
@@ -21,10 +21,6 @@
  */
 
 
-/* #define DEBUG */
-
-#define debug(format, arg...) pr_debug("hid-zpff: " format "\n" , ## arg)
-
 #include <linux/input.h>
 #include <linux/usb.h>
 #include <linux/hid.h>
@@ -49,14 +45,14 @@ static int hid_zpff_play(struct input_dev *dev, void *data,
 
        left = effect->u.rumble.strong_magnitude;
        right = effect->u.rumble.weak_magnitude;
-       debug("called with 0x%04x 0x%04x", left, right);
+       dbg_hid("called with 0x%04x 0x%04x\n", left, right);
 
        left = left * 0x7f / 0xffff;
        right = right * 0x7f / 0xffff;
 
        zpff->report->field[2]->value[0] = left;
        zpff->report->field[3]->value[0] = right;
-       debug("running with 0x%02x 0x%02x", left, right);
+       dbg_hid("running with 0x%02x 0x%02x\n", left, right);
        usbhid_submit_report(hid, zpff->report, USB_DIR_OUT);
 
        return 0;

diff --git a/drivers/hid/usbhid/hiddev.c b/drivers/hid/usbhid/hiddev.c
index 488d61bdbf2c1960d4d84e4cd3347f56916fcd1d..e793127f971eae29903298b7cb6d3ec64a156325 100644 (file)
--- a/drivers/hid/usbhid/hiddev.c
+++ b/drivers/hid/usbhid/hiddev.c
@@ -779,7 +779,7 @@ int hiddev_connect(struct hid_device *hid)
 
        retval = usb_register_dev(usbhid->intf, &hiddev_class);
        if (retval) {
-               err("Not able to get a minor for this device.");
+               err_hid("Not able to get a minor for this device.");
                kfree(hiddev);
                return -1;
        }

diff --git a/drivers/hid/usbhid/usbkbd.c b/drivers/hid/usbhid/usbkbd.c
index 1309787807130cfa2e2121ae856ccde721da92ff..b76b02f7b52de04a11e17d2a17e0e80b850d9922 100644 (file)
--- a/drivers/hid/usbhid/usbkbd.c
+++ b/drivers/hid/usbhid/usbkbd.c
@@ -125,7 +125,7 @@ static void usb_kbd_irq(struct urb *urb)
 resubmit:
        i = usb_submit_urb (urb, GFP_ATOMIC);
        if (i)
-               err ("can't resubmit intr, %s-%s/input0, status %d",
+               err_hid ("can't resubmit intr, %s-%s/input0, status %d",
                                kbd->usbdev->bus->bus_name,
                                kbd->usbdev->devpath, i);
 }
@@ -151,7 +151,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("usb_submit_urb(leds) failed");
+               err_hid("usb_submit_urb(leds) failed");
 
        return 0;
 }
@@ -169,7 +169,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("usb_submit_urb(leds) failed");
+               err_hid("usb_submit_urb(leds) failed");
 }
 
 static int usb_kbd_open(struct input_dev *dev)

diff --git a/include/linux/hid.h b/include/linux/hid.h
index 827ee748fd4c88b76a65a6992c6cd20161b9e9a3..eb53d9a9ae54aec8a2af0051a5735aca4c76cbbd 100644 (file)
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -488,6 +488,11 @@ struct hid_descriptor {
 #define IS_INPUT_APPLICATION(a) (((a >= 0x00010000) && (a <= 0x00010008)) || (a == 0x00010080) || (a == 0x000c0001))
 
 /* HID core API */
+
+#ifdef CONFIG_HID_DEBUG
+extern int hid_debug;
+#endif
+
 extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
 extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report);
 extern int hidinput_connect(struct hid_device *);
@@ -523,14 +528,19 @@ static inline int hid_pidff_init(struct hid_device *hid) { return -ENODEV; }
 #else
 static inline int hid_ff_init(struct hid_device *hid) { return -1; }
 #endif
-#ifdef DEBUG
-#define dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , \
-               __FILE__ , ## arg)
+
+#ifdef CONFIG_HID_DEBUG
+#define dbg_hid(format, arg...) if (hid_debug) \
+                               printk(KERN_DEBUG "%s: " format ,\
+                               __FILE__ , ## arg)
+#define dbg_hid_line(format, arg...) if (hid_debug) \
+                               printk(format, ## arg)
 #else
-#define dbg(format, arg...) do {} while (0)
+#define dbg_hid(format, arg...) do {} while (0)
+#define dbg_hid_line dbg_hid
 #endif
 
-#define err(format, arg...) printk(KERN_ERR "%s: " format "\n" , \
+#define err_hid(format, arg...) printk(KERN_ERR "%s: " format "\n" , \
                __FILE__ , ## arg)
 #endif