ACPI: remove unused acpi_bus_scan_fixed() argument

[safe/jmp/linux-2.6] / drivers / hid / hid-core.c

diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 6164ed3..be34d32 100644 (file)
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -44,12 +44,10 @@
 #define DRIVER_DESC "HID core driver"
 #define DRIVER_LICENSE "GPL"
 
-#ifdef CONFIG_HID_DEBUG
 int hid_debug = 0;
 module_param_named(debug, hid_debug, int, 0600);
-MODULE_PARM_DESC(debug, "HID debugging (0=off, 1=probing info, 2=continuous data dumping)");
+MODULE_PARM_DESC(debug, "toggle HID debugging messages");
 EXPORT_SYMBOL_GPL(hid_debug);
-#endif
 
 /*
  * Register a new report for a device.
@@ -861,7 +859,7 @@ static void hid_process_event(struct hid_device *hid, struct hid_field *field,
        struct hid_driver *hdrv = hid->driver;
        int ret;
 
-       hid_dump_input(usage, value);
+       hid_dump_input(hid, usage, value);
 
        if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {
                ret = hdrv->event(hid, field, usage, value);
@@ -983,11 +981,10 @@ int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
 {
        unsigned size = field->report_size;
 
-       hid_dump_input(field->usage + offset, value);
+       hid_dump_input(field->report->device, field->usage + offset, value);
 
        if (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) {
@@ -1078,6 +1075,7 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i
        struct hid_report_enum *report_enum;
        struct hid_driver *hdrv;
        struct hid_report *report;
+       char *buf;
        unsigned int i;
        int ret;
 
@@ -1091,18 +1089,37 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i
                return -1;
        }
 
-       dbg_hid("report (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
+       buf = kmalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC);
+
+       if (!buf) {
+               report = hid_get_report(report_enum, data);
+               goto nomem;
+       }
+
+       snprintf(buf, HID_DEBUG_BUFSIZE - 1,
+                       "\nreport (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
+       hid_debug_event(hid, buf);
 
        report = hid_get_report(report_enum, data);
-       if (!report)
+       if (!report) {
+               kfree(buf);
                return -1;
+       }
 
        /* dump the report */
-       dbg_hid("report %d (size %u) = ", report->id, size);
-       for (i = 0; i < size; i++)
-               dbg_hid_line(" %02x", data[i]);
-       dbg_hid_line("\n");
+       snprintf(buf, HID_DEBUG_BUFSIZE - 1,
+                       "report %d (size %u) = ", report->id, size);
+       hid_debug_event(hid, buf);
+       for (i = 0; i < size; i++) {
+               snprintf(buf, HID_DEBUG_BUFSIZE - 1,
+                               " %02x", data[i]);
+               hid_debug_event(hid, buf);
+       }
+       hid_debug_event(hid, "\n");
+
+       kfree(buf);
 
+nomem:
        if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
                ret = hdrv->raw_event(hid, report, data, size);
                if (ret != 0)
@@ -1220,6 +1237,17 @@ int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
 }
 EXPORT_SYMBOL_GPL(hid_connect);
 
+void hid_disconnect(struct hid_device *hdev)
+{
+       if (hdev->claimed & HID_CLAIMED_INPUT)
+               hidinput_disconnect(hdev);
+       if (hdev->claimed & HID_CLAIMED_HIDDEV)
+               hdev->hiddev_disconnect(hdev);
+       if (hdev->claimed & HID_CLAIMED_HIDRAW)
+               hidraw_disconnect(hdev);
+}
+EXPORT_SYMBOL_GPL(hid_disconnect);
+
 /* a list of devices for which there is a specialized driver on HID bus */
 static const struct hid_device_id hid_blacklist[] = {
        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) },
@@ -1323,7 +1351,6 @@ static const struct hid_device_id hid_blacklist[] = {
        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
 
-       { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, 0x030c) },
        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },
        { }
 };
@@ -1626,12 +1653,8 @@ static const struct hid_device_id hid_ignore_list[] = {
        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0002) },
        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0003) },
        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0004) },
+       { HID_USB_DEVICE(USB_VENDOR_ID_PHILIPS, USB_DEVICE_ID_PHILIPS_IEEE802154_DONGLE) },
        { HID_USB_DEVICE(USB_VENDOR_ID_POWERCOM, USB_DEVICE_ID_POWERCOM_UPS) },
-       { HID_USB_DEVICE(USB_VENDOR_ID_SOUNDGRAPH, USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD) },
-       { HID_USB_DEVICE(USB_VENDOR_ID_SOUNDGRAPH, USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD2) },
-       { HID_USB_DEVICE(USB_VENDOR_ID_SOUNDGRAPH, USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD3) },
-       { HID_USB_DEVICE(USB_VENDOR_ID_SOUNDGRAPH, USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD4) },
-       { HID_USB_DEVICE(USB_VENDOR_ID_SOUNDGRAPH, USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD5) },
        { HID_USB_DEVICE(USB_VENDOR_ID_TENX, USB_DEVICE_ID_TENX_IBUDDY1) },
        { HID_USB_DEVICE(USB_VENDOR_ID_TENX, USB_DEVICE_ID_TENX_IBUDDY2) },
        { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO) },
@@ -1698,6 +1721,11 @@ static bool hid_ignore(struct hid_device *hdev)
                                hdev->product <= USB_DEVICE_ID_LOGITECH_HARMONY_LAST)
                        return true;
                break;
+       case USB_VENDOR_ID_SOUNDGRAPH:
+               if (hdev->product >= USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST &&
+                   hdev->product <= USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST)
+                       return true;
+               break;
        }
 
        if (hdev->type == HID_TYPE_USBMOUSE &&
@@ -1729,6 +1757,8 @@ int hid_add_device(struct hid_device *hdev)
        if (!ret)
                hdev->status |= HID_STAT_ADDED;
 
+       hid_debug_register(hdev, dev_name(&hdev->dev));
+
        return ret;
 }
 EXPORT_SYMBOL_GPL(hid_add_device);
@@ -1765,6 +1795,9 @@ struct hid_device *hid_allocate_device(void)
        for (i = 0; i < HID_REPORT_TYPES; i++)
                INIT_LIST_HEAD(&hdev->report_enum[i].report_list);
 
+       init_waitqueue_head(&hdev->debug_wait);
+       INIT_LIST_HEAD(&hdev->debug_list);
+
        return hdev;
 err:
        put_device(&hdev->dev);
@@ -1776,6 +1809,7 @@ static void hid_remove_device(struct hid_device *hdev)
 {
        if (hdev->status & HID_STAT_ADDED) {
                device_del(&hdev->dev);
+               hid_debug_unregister(hdev);
                hdev->status &= ~HID_STAT_ADDED;
        }
 }
@@ -1851,6 +1885,10 @@ static int __init hid_init(void)
 {
        int ret;
 
+       if (hid_debug)
+               printk(KERN_WARNING "HID: hid_debug is now used solely for parser and driver debugging.\n"
+                               "HID: debugfs is now used for inspecting the device (report descriptor, reports)\n");
+
        ret = bus_register(&hid_bus_type);
        if (ret) {
                printk(KERN_ERR "HID: can't register hid bus\n");
@@ -1861,6 +1899,8 @@ static int __init hid_init(void)
        if (ret)
                goto err_bus;
 
+       hid_debug_init();
+
        return 0;
 err_bus:
        bus_unregister(&hid_bus_type);
@@ -1870,6 +1910,7 @@ err:
 
 static void __exit hid_exit(void)
 {
+       hid_debug_exit();
        hidraw_exit();
        bus_unregister(&hid_bus_type);
 }