commit 8606ab6d30dbaaafff985bd462bf33c36997eae9

+39 -31

drivers/hid/Kconfig

··· 85 85 config HID_A4TECH 86 86 tristate "A4 tech" if EMBEDDED 87 87 depends on USB_HID 88 - default y 88 + default !EMBEDDED 89 89 ---help--- 90 90 Support for A4 tech X5 and WOP-35 / Trust 450L mice. 91 91 92 92 config HID_APPLE 93 93 tristate "Apple" if EMBEDDED 94 94 depends on (USB_HID || BT_HIDP) 95 - default y 95 + default !EMBEDDED 96 96 ---help--- 97 97 Support for some Apple devices which less or more break 98 98 HID specification. ··· 103 103 config HID_BELKIN 104 104 tristate "Belkin" if EMBEDDED 105 105 depends on USB_HID 106 - default y 106 + default !EMBEDDED 107 107 ---help--- 108 108 Support for Belkin Flip KVM and Wireless keyboard. 109 - 110 - config HID_BRIGHT 111 - tristate "Bright" if EMBEDDED 112 - depends on USB_HID 113 - default y 114 - ---help--- 115 - Support for Bright ABNT-2 keyboard. 116 109 117 110 config HID_CHERRY 118 111 tristate "Cherry" if EMBEDDED 119 112 depends on USB_HID 120 - default y 113 + default !EMBEDDED 121 114 ---help--- 122 115 Support for Cherry Cymotion keyboard. 123 116 124 117 config HID_CHICONY 125 118 tristate "Chicony" if EMBEDDED 126 119 depends on USB_HID 127 - default y 120 + default !EMBEDDED 128 121 ---help--- 129 122 Support for Chicony Tactical pad. 130 123 131 124 config HID_CYPRESS 132 125 tristate "Cypress" if EMBEDDED 133 126 depends on USB_HID 134 - default y 127 + default !EMBEDDED 135 128 ---help--- 136 129 Support for cypress mouse and barcode readers. 137 - 138 - config HID_DELL 139 - tristate "Dell" if EMBEDDED 140 - depends on USB_HID 141 - default y 142 - ---help--- 143 - Support for quirky Dell HID hardware that require 144 - special LED handling (W7658 and SK8115 models) 145 130 146 131 config HID_EZKEY 147 132 tristate "Ezkey" if EMBEDDED 148 133 depends on USB_HID 149 - default y 134 + default !EMBEDDED 150 135 ---help--- 151 136 Support for Ezkey BTC 8193 keyboard. 152 137 153 138 config HID_GYRATION 154 139 tristate "Gyration" if EMBEDDED 155 140 depends on USB_HID 156 - default y 141 + default !EMBEDDED 157 142 ---help--- 158 143 Support for Gyration remote control. 159 144 160 145 config HID_LOGITECH 161 146 tristate "Logitech" if EMBEDDED 162 147 depends on USB_HID 163 - default y 148 + default !EMBEDDED 164 149 ---help--- 165 150 Support for Logitech devices that are not fully compliant with HID standard. 166 151 ··· 176 191 config HID_MICROSOFT 177 192 tristate "Microsoft" if EMBEDDED 178 193 depends on USB_HID 179 - default y 194 + default !EMBEDDED 180 195 ---help--- 181 196 Support for Microsoft devices that are not fully compliant with HID standard. 182 197 183 198 config HID_MONTEREY 184 199 tristate "Monterey" if EMBEDDED 185 200 depends on USB_HID 186 - default y 201 + default !EMBEDDED 187 202 ---help--- 188 203 Support for Monterey Genius KB29E. 204 + 205 + config HID_NTRIG 206 + tristate "NTrig" if EMBEDDED 207 + depends on USB_HID 208 + default !EMBEDDED 209 + ---help--- 210 + Support for N-Trig touch screen. 189 211 190 212 config HID_PANTHERLORD 191 213 tristate "Pantherlord devices support" if EMBEDDED 192 214 depends on USB_HID 193 - default y 215 + default !EMBEDDED 194 216 ---help--- 195 217 Support for PantherLord/GreenAsia based device support. 196 218 ··· 212 220 config HID_PETALYNX 213 221 tristate "Petalynx" if EMBEDDED 214 222 depends on USB_HID 215 - default y 223 + default !EMBEDDED 216 224 ---help--- 217 225 Support for Petalynx Maxter remote control. 218 226 219 227 config HID_SAMSUNG 220 228 tristate "Samsung" if EMBEDDED 221 229 depends on USB_HID 222 - default y 230 + default !EMBEDDED 223 231 ---help--- 224 232 Support for Samsung InfraRed remote control. 225 233 226 234 config HID_SONY 227 235 tristate "Sony" if EMBEDDED 228 236 depends on USB_HID 229 - default y 237 + default !EMBEDDED 230 238 ---help--- 231 239 Support for Sony PS3 controller. 232 240 233 241 config HID_SUNPLUS 234 242 tristate "Sunplus" if EMBEDDED 235 243 depends on USB_HID 236 - default y 244 + default !EMBEDDED 237 245 ---help--- 238 246 Support for Sunplus wireless desktop. 247 + 248 + config GREENASIA_FF 249 + tristate "GreenAsia (Product ID 0x12) force feedback support" 250 + depends on USB_HID 251 + select INPUT_FF_MEMLESS 252 + ---help--- 253 + Say Y here if you have a GreenAsia (Product ID 0x12) based game controller 254 + (like MANTA Warior MM816 and SpeedLink Strike2 SL-6635) or adapter 255 + and want to enable force feedback support for it. 256 + 257 + config HID_TOPSEED 258 + tristate "TopSeed Cyberlink remote control support" if EMBEDDED 259 + depends on USB_HID 260 + default !EMBEDDED 261 + ---help--- 262 + Say Y if you have a TopSeed Cyberlink remote control. 239 263 240 264 config THRUSTMASTER_FF 241 265 tristate "ThrustMaster devices support"

+3 -2

drivers/hid/Makefile

··· 23 23 obj-$(CONFIG_HID_A4TECH) += hid-a4tech.o 24 24 obj-$(CONFIG_HID_APPLE) += hid-apple.o 25 25 obj-$(CONFIG_HID_BELKIN) += hid-belkin.o 26 - obj-$(CONFIG_HID_BRIGHT) += hid-bright.o 27 26 obj-$(CONFIG_HID_CHERRY) += hid-cherry.o 28 27 obj-$(CONFIG_HID_CHICONY) += hid-chicony.o 29 28 obj-$(CONFIG_HID_CYPRESS) += hid-cypress.o 30 - obj-$(CONFIG_HID_DELL) += hid-dell.o 31 29 obj-$(CONFIG_HID_EZKEY) += hid-ezkey.o 32 30 obj-$(CONFIG_HID_GYRATION) += hid-gyration.o 33 31 obj-$(CONFIG_HID_LOGITECH) += hid-logitech.o 34 32 obj-$(CONFIG_HID_MICROSOFT) += hid-microsoft.o 35 33 obj-$(CONFIG_HID_MONTEREY) += hid-monterey.o 34 + obj-$(CONFIG_HID_NTRIG) += hid-ntrig.o 36 35 obj-$(CONFIG_HID_PANTHERLORD) += hid-pl.o 37 36 obj-$(CONFIG_HID_PETALYNX) += hid-petalynx.o 38 37 obj-$(CONFIG_HID_SAMSUNG) += hid-samsung.o 39 38 obj-$(CONFIG_HID_SONY) += hid-sony.o 40 39 obj-$(CONFIG_HID_SUNPLUS) += hid-sunplus.o 40 + obj-$(CONFIG_GREENASIA_FF) += hid-gaff.o 41 41 obj-$(CONFIG_THRUSTMASTER_FF) += hid-tmff.o 42 + obj-$(CONFIG_HID_TOPSEED) += hid-topseed.o 42 43 obj-$(CONFIG_ZEROPLUS_FF) += hid-zpff.o 43 44 44 45 obj-$(CONFIG_USB_HID) += usbhid/

-71

drivers/hid/hid-bright.c

··· 1 - /* 2 - * HID driver for some bright "special" devices 3 - * 4 - * Copyright (c) 2008 Mauro Carvalho Chehab <mchehab@redhat.com> 5 - * 6 - * Based on hid-dell driver 7 - */ 8 - 9 - /* 10 - * This program is free software; you can redistribute it and/or modify it 11 - * under the terms of the GNU General Public License as published by the Free 12 - * Software Foundation; either version 2 of the License, or (at your option) 13 - * any later version. 14 - */ 15 - 16 - #include <linux/device.h> 17 - #include <linux/hid.h> 18 - #include <linux/module.h> 19 - 20 - #include "hid-ids.h" 21 - 22 - static int bright_probe(struct hid_device *hdev, const struct hid_device_id *id) 23 - { 24 - int ret; 25 - 26 - ret = hid_parse(hdev); 27 - if (ret) { 28 - dev_err(&hdev->dev, "parse failed\n"); 29 - goto err_free; 30 - } 31 - 32 - ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 33 - if (ret) { 34 - dev_err(&hdev->dev, "hw start failed\n"); 35 - goto err_free; 36 - } 37 - 38 - usbhid_set_leds(hdev); 39 - 40 - return 0; 41 - err_free: 42 - return ret; 43 - } 44 - 45 - static const struct hid_device_id bright_devices[] = { 46 - { HID_USB_DEVICE(USB_VENDOR_ID_BRIGHT, USB_DEVICE_ID_BRIGHT_ABNT2) }, 47 - { } 48 - }; 49 - MODULE_DEVICE_TABLE(hid, bright_devices); 50 - 51 - static struct hid_driver bright_driver = { 52 - .name = "bright", 53 - .id_table = bright_devices, 54 - .probe = bright_probe, 55 - }; 56 - 57 - static int bright_init(void) 58 - { 59 - return hid_register_driver(&bright_driver); 60 - } 61 - 62 - static void bright_exit(void) 63 - { 64 - hid_unregister_driver(&bright_driver); 65 - } 66 - 67 - module_init(bright_init); 68 - module_exit(bright_exit); 69 - MODULE_LICENSE("GPL"); 70 - 71 - HID_COMPAT_LOAD_DRIVER(bright);

+109 -11

drivers/hid/hid-core.c

··· 1256 1256 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) }, 1257 1257 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) }, 1258 1258 { HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) }, 1259 - { HID_USB_DEVICE(USB_VENDOR_ID_BRIGHT, USB_DEVICE_ID_BRIGHT_ABNT2) }, 1260 1259 { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) }, 1261 1260 { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) }, 1262 1261 { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1) }, 1263 1262 { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) }, 1264 1263 { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) }, 1265 - { HID_USB_DEVICE(USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_W7658) }, 1266 - { HID_USB_DEVICE(USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_SK8115) }, 1267 1264 { HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) }, 1268 - { HID_USB_DEVICE(USB_VENDOR_ID_GENERIC_13BA, USB_DEVICE_ID_GENERIC_13BA_KBD_MOUSE) }, 1269 1265 { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) }, 1270 1266 { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) }, 1271 1267 { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) }, 1268 + { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012) }, 1272 1269 { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) }, 1273 1270 { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) }, 1274 1271 { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) }, ··· 1276 1279 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP) }, 1277 1280 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE) }, 1278 1281 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI) }, 1279 - { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_KBD) }, 1280 1282 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD) }, 1281 1283 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500) }, 1282 1284 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D) }, ··· 1293 1297 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB) }, 1294 1298 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) }, 1295 1299 { HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) }, 1300 + { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) }, 1296 1301 { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) }, 1297 1302 { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) }, 1298 1303 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) }, 1299 1304 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) }, 1300 1305 { HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) }, 1306 + { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) }, 1301 1307 1302 1308 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, 0x030c) }, 1303 1309 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) }, 1304 1310 { } 1305 1311 }; 1306 1312 1313 + struct hid_dynid { 1314 + struct list_head list; 1315 + struct hid_device_id id; 1316 + }; 1317 + 1318 + /** 1319 + * store_new_id - add a new HID device ID to this driver and re-probe devices 1320 + * @driver: target device driver 1321 + * @buf: buffer for scanning device ID data 1322 + * @count: input size 1323 + * 1324 + * Adds a new dynamic hid device ID to this driver, 1325 + * and causes the driver to probe for all devices again. 1326 + */ 1327 + static ssize_t store_new_id(struct device_driver *drv, const char *buf, 1328 + size_t count) 1329 + { 1330 + struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver); 1331 + struct hid_dynid *dynid; 1332 + __u32 bus, vendor, product; 1333 + unsigned long driver_data = 0; 1334 + int ret; 1335 + 1336 + ret = sscanf(buf, "%x %x %x %lx", 1337 + &bus, &vendor, &product, &driver_data); 1338 + if (ret < 3) 1339 + return -EINVAL; 1340 + 1341 + dynid = kzalloc(sizeof(*dynid), GFP_KERNEL); 1342 + if (!dynid) 1343 + return -ENOMEM; 1344 + 1345 + dynid->id.bus = bus; 1346 + dynid->id.vendor = vendor; 1347 + dynid->id.product = product; 1348 + dynid->id.driver_data = driver_data; 1349 + 1350 + spin_lock(&hdrv->dyn_lock); 1351 + list_add_tail(&dynid->list, &hdrv->dyn_list); 1352 + spin_unlock(&hdrv->dyn_lock); 1353 + 1354 + ret = 0; 1355 + if (get_driver(&hdrv->driver)) { 1356 + ret = driver_attach(&hdrv->driver); 1357 + put_driver(&hdrv->driver); 1358 + } 1359 + 1360 + return ret ? : count; 1361 + } 1362 + static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id); 1363 + 1364 + static void hid_free_dynids(struct hid_driver *hdrv) 1365 + { 1366 + struct hid_dynid *dynid, *n; 1367 + 1368 + spin_lock(&hdrv->dyn_lock); 1369 + list_for_each_entry_safe(dynid, n, &hdrv->dyn_list, list) { 1370 + list_del(&dynid->list); 1371 + kfree(dynid); 1372 + } 1373 + spin_unlock(&hdrv->dyn_lock); 1374 + } 1375 + 1376 + static const struct hid_device_id *hid_match_device(struct hid_device *hdev, 1377 + struct hid_driver *hdrv) 1378 + { 1379 + struct hid_dynid *dynid; 1380 + 1381 + spin_lock(&hdrv->dyn_lock); 1382 + list_for_each_entry(dynid, &hdrv->dyn_list, list) { 1383 + if (hid_match_one_id(hdev, &dynid->id)) { 1384 + spin_unlock(&hdrv->dyn_lock); 1385 + return &dynid->id; 1386 + } 1387 + } 1388 + spin_unlock(&hdrv->dyn_lock); 1389 + 1390 + return hid_match_id(hdev, hdrv->id_table); 1391 + } 1392 + 1307 1393 static int hid_bus_match(struct device *dev, struct device_driver *drv) 1308 1394 { 1309 1395 struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver); 1310 1396 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 1311 1397 1312 - if (!hid_match_id(hdev, hdrv->id_table)) 1398 + if (!hid_match_device(hdev, hdrv)) 1313 1399 return 0; 1314 1400 1315 1401 /* generic wants all non-blacklisted */ ··· 1410 1332 int ret = 0; 1411 1333 1412 1334 if (!hdev->driver) { 1413 - id = hid_match_id(hdev, hdrv->id_table); 1335 + id = hid_match_device(hdev, hdrv); 1414 1336 if (id == NULL) 1415 1337 return -ENODEV; 1416 1338 ··· 1498 1420 { HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM109) }, 1499 1421 { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_HIDCOM) }, 1500 1422 { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_ULTRAMOUSE) }, 1423 + { HID_USB_DEVICE(USB_VENDOR_ID_DEALEXTREAME, USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701) }, 1501 1424 { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) }, 1502 1425 { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) }, 1503 1426 { HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) }, ··· 1656 1577 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) }, 1657 1578 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) }, 1658 1579 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) }, 1580 + { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI) }, 1581 + { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) }, 1582 + { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) }, 1659 1583 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) }, 1660 1584 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) }, 1661 1585 { } ··· 1700 1618 if (hid_ignore(hdev)) 1701 1619 return -ENODEV; 1702 1620 1703 - /* XXX hack, any other cleaner solution < 20 bus_id bytes? */ 1704 - sprintf(hdev->dev.bus_id, "%04X:%04X:%04X.%04X", hdev->bus, 1705 - hdev->vendor, hdev->product, atomic_inc_return(&id)); 1621 + /* XXX hack, any other cleaner solution after the driver core 1622 + * is converted to allow more than 20 bytes as the device name? */ 1623 + dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus, 1624 + hdev->vendor, hdev->product, atomic_inc_return(&id)); 1706 1625 1707 1626 ret = device_add(&hdev->dev); 1708 1627 if (!ret) ··· 1778 1695 int __hid_register_driver(struct hid_driver *hdrv, struct module *owner, 1779 1696 const char *mod_name) 1780 1697 { 1698 + int ret; 1699 + 1781 1700 hdrv->driver.name = hdrv->name; 1782 1701 hdrv->driver.bus = &hid_bus_type; 1783 1702 hdrv->driver.owner = owner; 1784 1703 hdrv->driver.mod_name = mod_name; 1785 1704 1786 - return driver_register(&hdrv->driver); 1705 + INIT_LIST_HEAD(&hdrv->dyn_list); 1706 + spin_lock_init(&hdrv->dyn_lock); 1707 + 1708 + ret = driver_register(&hdrv->driver); 1709 + if (ret) 1710 + return ret; 1711 + 1712 + ret = driver_create_file(&hdrv->driver, &driver_attr_new_id); 1713 + if (ret) 1714 + driver_unregister(&hdrv->driver); 1715 + 1716 + return ret; 1787 1717 } 1788 1718 EXPORT_SYMBOL_GPL(__hid_register_driver); 1789 1719 1790 1720 void hid_unregister_driver(struct hid_driver *hdrv) 1791 1721 { 1722 + driver_remove_file(&hdrv->driver, &driver_attr_new_id); 1792 1723 driver_unregister(&hdrv->driver); 1724 + hid_free_dynids(hdrv); 1793 1725 } 1794 1726 EXPORT_SYMBOL_GPL(hid_unregister_driver); 1795 1727

-76

drivers/hid/hid-dell.c

··· 1 - /* 2 - * HID driver for some dell "special" devices 3 - * 4 - * Copyright (c) 1999 Andreas Gal 5 - * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz> 6 - * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc 7 - * Copyright (c) 2006-2007 Jiri Kosina 8 - * Copyright (c) 2007 Paul Walmsley 9 - * Copyright (c) 2008 Jiri Slaby 10 - */ 11 - 12 - /* 13 - * This program is free software; you can redistribute it and/or modify it 14 - * under the terms of the GNU General Public License as published by the Free 15 - * Software Foundation; either version 2 of the License, or (at your option) 16 - * any later version. 17 - */ 18 - 19 - #include <linux/device.h> 20 - #include <linux/hid.h> 21 - #include <linux/module.h> 22 - 23 - #include "hid-ids.h" 24 - 25 - static int dell_probe(struct hid_device *hdev, const struct hid_device_id *id) 26 - { 27 - int ret; 28 - 29 - ret = hid_parse(hdev); 30 - if (ret) { 31 - dev_err(&hdev->dev, "parse failed\n"); 32 - goto err_free; 33 - } 34 - 35 - ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 36 - if (ret) { 37 - dev_err(&hdev->dev, "hw start failed\n"); 38 - goto err_free; 39 - } 40 - 41 - usbhid_set_leds(hdev); 42 - 43 - return 0; 44 - err_free: 45 - return ret; 46 - } 47 - 48 - static const struct hid_device_id dell_devices[] = { 49 - { HID_USB_DEVICE(USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_W7658) }, 50 - { HID_USB_DEVICE(USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_SK8115) }, 51 - { HID_USB_DEVICE(USB_VENDOR_ID_GENERIC_13BA, USB_DEVICE_ID_GENERIC_13BA_KBD_MOUSE) }, 52 - { } 53 - }; 54 - MODULE_DEVICE_TABLE(hid, dell_devices); 55 - 56 - static struct hid_driver dell_driver = { 57 - .name = "dell", 58 - .id_table = dell_devices, 59 - .probe = dell_probe, 60 - }; 61 - 62 - static int dell_init(void) 63 - { 64 - return hid_register_driver(&dell_driver); 65 - } 66 - 67 - static void dell_exit(void) 68 - { 69 - hid_unregister_driver(&dell_driver); 70 - } 71 - 72 - module_init(dell_init); 73 - module_exit(dell_exit); 74 - MODULE_LICENSE("GPL"); 75 - 76 - HID_COMPAT_LOAD_DRIVER(dell);

+6

drivers/hid/hid-dummy.c

··· 43 43 #ifdef CONFIG_HID_MONTEREY_MODULE 44 44 HID_COMPAT_CALL_DRIVER(monterey); 45 45 #endif 46 + #ifdef CONFIG_HID_NTRIG_MODULE 47 + HID_COMPAT_CALL_DRIVER(ntrig); 48 + #endif 46 49 #ifdef CONFIG_HID_PANTHERLORD_MODULE 47 50 HID_COMPAT_CALL_DRIVER(pantherlord); 48 51 #endif ··· 60 57 #endif 61 58 #ifdef CONFIG_HID_SUNPLUS_MODULE 62 59 HID_COMPAT_CALL_DRIVER(sunplus); 60 + #endif 61 + #ifdef CONFIG_GREENASIA_FF_MODULE 62 + HID_COMPAT_CALL_DRIVER(greenasia); 63 63 #endif 64 64 #ifdef CONFIG_THRUSTMASTER_FF_MODULE 65 65 HID_COMPAT_CALL_DRIVER(thrustmaster);

+185

drivers/hid/hid-gaff.c

··· 1 + /* 2 + * Force feedback support for GreenAsia (Product ID 0x12) based devices 3 + * 4 + * The devices are distributed under various names and the same USB device ID 5 + * can be used in many game controllers. 6 + * 7 + * 8 + * 0e8f:0012 "GreenAsia Inc. USB Joystick " 9 + * - tested with MANTA Warior MM816 and SpeedLink Strike2 SL-6635. 10 + * 11 + * Copyright (c) 2008 Lukasz Lubojanski <lukasz@lubojanski.info> 12 + */ 13 + 14 + /* 15 + * This program is free software; you can redistribute it and/or modify 16 + * it under the terms of the GNU General Public License as published by 17 + * the Free Software Foundation; either version 2 of the License, or 18 + * (at your option) any later version. 19 + * 20 + * This program is distributed in the hope that it will be useful, 21 + * but WITHOUT ANY WARRANTY; without even the implied warranty of 22 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 23 + * GNU General Public License for more details. 24 + * 25 + * You should have received a copy of the GNU General Public License 26 + * along with this program; if not, write to the Free Software 27 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 28 + */ 29 + 30 + #include <linux/input.h> 31 + #include <linux/usb.h> 32 + #include <linux/hid.h> 33 + #include "hid-ids.h" 34 + #include "usbhid/usbhid.h" 35 + 36 + struct gaff_device { 37 + struct hid_report *report; 38 + }; 39 + 40 + static int hid_gaff_play(struct input_dev *dev, void *data, 41 + struct ff_effect *effect) 42 + { 43 + struct hid_device *hid = input_get_drvdata(dev); 44 + struct gaff_device *gaff = data; 45 + int left, right; 46 + 47 + left = effect->u.rumble.strong_magnitude; 48 + right = effect->u.rumble.weak_magnitude; 49 + 50 + dbg_hid("called with 0x%04x 0x%04x", left, right); 51 + 52 + left = left * 0xfe / 0xffff; 53 + right = right * 0xfe / 0xffff; 54 + 55 + gaff->report->field[0]->value[0] = 0x51; 56 + gaff->report->field[0]->value[1] = 0x0; 57 + gaff->report->field[0]->value[2] = right; 58 + gaff->report->field[0]->value[3] = 0; 59 + gaff->report->field[0]->value[4] = left; 60 + gaff->report->field[0]->value[5] = 0; 61 + dbg_hid("running with 0x%02x 0x%02x", left, right); 62 + usbhid_submit_report(hid, gaff->report, USB_DIR_OUT); 63 + 64 + gaff->report->field[0]->value[0] = 0xfa; 65 + gaff->report->field[0]->value[1] = 0xfe; 66 + gaff->report->field[0]->value[2] = 0x0; 67 + gaff->report->field[0]->value[4] = 0x0; 68 + 69 + usbhid_submit_report(hid, gaff->report, USB_DIR_OUT); 70 + 71 + return 0; 72 + } 73 + 74 + static int gaff_init(struct hid_device *hid) 75 + { 76 + struct gaff_device *gaff; 77 + struct hid_report *report; 78 + struct hid_input *hidinput = list_entry(hid->inputs.next, 79 + struct hid_input, list); 80 + struct list_head *report_list = 81 + &hid->report_enum[HID_OUTPUT_REPORT].report_list; 82 + struct list_head *report_ptr = report_list; 83 + struct input_dev *dev = hidinput->input; 84 + int error; 85 + 86 + if (list_empty(report_list)) { 87 + dev_err(&hid->dev, "no output reports found\n"); 88 + return -ENODEV; 89 + } 90 + 91 + report_ptr = report_ptr->next; 92 + 93 + report = list_entry(report_ptr, struct hid_report, list); 94 + if (report->maxfield < 1) { 95 + dev_err(&hid->dev, "no fields in the report\n"); 96 + return -ENODEV; 97 + } 98 + 99 + if (report->field[0]->report_count < 6) { 100 + dev_err(&hid->dev, "not enough values in the field\n"); 101 + return -ENODEV; 102 + } 103 + 104 + gaff = kzalloc(sizeof(struct gaff_device), GFP_KERNEL); 105 + if (!gaff) 106 + return -ENOMEM; 107 + 108 + set_bit(FF_RUMBLE, dev->ffbit); 109 + 110 + error = input_ff_create_memless(dev, gaff, hid_gaff_play); 111 + if (error) { 112 + kfree(gaff); 113 + return error; 114 + } 115 + 116 + gaff->report = report; 117 + gaff->report->field[0]->value[0] = 0x51; 118 + gaff->report->field[0]->value[1] = 0x00; 119 + gaff->report->field[0]->value[2] = 0x00; 120 + gaff->report->field[0]->value[3] = 0x00; 121 + usbhid_submit_report(hid, gaff->report, USB_DIR_OUT); 122 + 123 + gaff->report->field[0]->value[0] = 0xfa; 124 + gaff->report->field[0]->value[1] = 0xfe; 125 + 126 + usbhid_submit_report(hid, gaff->report, USB_DIR_OUT); 127 + 128 + dev_info(&hid->dev, "Force Feedback for GreenAsia 0x12" 129 + " devices by Lukasz Lubojanski <lukasz@lubojanski.info>\n"); 130 + 131 + return 0; 132 + } 133 + 134 + static int ga_probe(struct hid_device *hdev, const struct hid_device_id *id) 135 + { 136 + int ret; 137 + 138 + dev_dbg(&hdev->dev, "Greenasia HID hardware probe..."); 139 + 140 + ret = hid_parse(hdev); 141 + if (ret) { 142 + dev_err(&hdev->dev, "parse failed\n"); 143 + goto err; 144 + } 145 + 146 + ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF); 147 + if (ret) { 148 + dev_err(&hdev->dev, "hw start failed\n"); 149 + goto err; 150 + } 151 + 152 + gaff_init(hdev); 153 + 154 + return 0; 155 + err: 156 + return ret; 157 + } 158 + 159 + static const struct hid_device_id ga_devices[] = { 160 + { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012), }, 161 + { } 162 + }; 163 + MODULE_DEVICE_TABLE(hid, ga_devices); 164 + 165 + static struct hid_driver ga_driver = { 166 + .name = "greenasia", 167 + .id_table = ga_devices, 168 + .probe = ga_probe, 169 + }; 170 + 171 + static int __init ga_init(void) 172 + { 173 + return hid_register_driver(&ga_driver); 174 + } 175 + 176 + static void __exit ga_exit(void) 177 + { 178 + hid_unregister_driver(&ga_driver); 179 + } 180 + 181 + module_init(ga_init); 182 + module_exit(ga_exit); 183 + MODULE_LICENSE("GPL"); 184 + 185 + HID_COMPAT_LOAD_DRIVER(greenasia);

+11 -10

drivers/hid/hid-ids.h

··· 107 107 #define USB_VENDOR_ID_BELKIN 0x050d 108 108 #define USB_DEVICE_ID_FLIP_KVM 0x3201 109 109 110 - #define USB_VENDOR_ID_BRIGHT 0x1241 111 - #define USB_DEVICE_ID_BRIGHT_ABNT2 0x1503 112 - 113 110 #define USB_VENDOR_ID_BERKSHIRE 0x0c98 114 111 #define USB_DEVICE_ID_BERKSHIRE_PCWD 0x1140 115 112 ··· 138 141 #define USB_DEVICE_ID_CYPRESS_BARCODE_1 0xde61 139 142 #define USB_DEVICE_ID_CYPRESS_BARCODE_2 0xde64 140 143 141 - #define USB_VENDOR_ID_DELL 0x413c 142 - #define USB_DEVICE_ID_DELL_W7658 0x2005 143 - #define USB_DEVICE_ID_DELL_SK8115 0x2105 144 + #define USB_VENDOR_ID_DEALEXTREAME 0x10c5 145 + #define USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701 0x819a 144 146 145 147 #define USB_VENDOR_ID_DELORME 0x1163 146 148 #define USB_DEVICE_ID_DELORME_EARTHMATE 0x0100 ··· 162 166 #define USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR 0x0002 163 167 164 168 #define USB_VENDOR_ID_GENERAL_TOUCH 0x0dfc 165 - 166 - #define USB_VENDOR_ID_GENERIC_13BA 0x13ba 167 - #define USB_DEVICE_ID_GENERIC_13BA_KBD_MOUSE 0x0017 168 169 169 170 #define USB_VENDOR_ID_GLAB 0x06c2 170 171 #define USB_DEVICE_ID_4_PHIDGETSERVO_30 0x0038 ··· 285 292 #define USB_DEVICE_ID_LOGITECH_WHEEL 0xc294 286 293 #define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL 0xc295 287 294 #define USB_DEVICE_ID_LOGITECH_ELITE_KBD 0xc30a 288 - #define USB_DEVICE_ID_LOGITECH_KBD 0xc311 289 295 #define USB_DEVICE_ID_S510_RECEIVER 0xc50c 290 296 #define USB_DEVICE_ID_S510_RECEIVER_2 0xc517 291 297 #define USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500 0xc512 ··· 331 339 #define USB_VENDOR_ID_NEC 0x073e 332 340 #define USB_DEVICE_ID_NEC_USB_GAME_PAD 0x0301 333 341 342 + #define USB_VENDOR_ID_NTRIG 0x1b96 343 + #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN 0x0001 344 + 334 345 #define USB_VENDOR_ID_ONTRAK 0x0a07 335 346 #define USB_DEVICE_ID_ONTRAK_ADU100 0x0064 336 347 ··· 378 383 #define USB_VENDOR_ID_TOPMAX 0x0663 379 384 #define USB_DEVICE_ID_TOPMAX_COBRAPAD 0x0103 380 385 386 + #define USB_VENDOR_ID_TOPSEED 0x0766 387 + #define USB_DEVICE_ID_TOPSEED_CYBERLINK 0x0204 388 + 381 389 #define USB_VENDOR_ID_TURBOX 0x062a 382 390 #define USB_DEVICE_ID_TURBOX_KEYBOARD 0x0201 391 + 392 + #define USB_VENDOR_ID_UCLOGIC 0x5543 393 + #define USB_DEVICE_ID_UCLOGIC_TABLET_PF1209 0x0042 383 394 384 395 #define USB_VENDOR_ID_VERNIER 0x08f7 385 396 #define USB_DEVICE_ID_VERNIER_LABPRO 0x0001

-7

drivers/hid/hid-lg.c

··· 26 26 #define LG_RDESC 0x001 27 27 #define LG_BAD_RELATIVE_KEYS 0x002 28 28 #define LG_DUPLICATE_USAGES 0x004 29 - #define LG_RESET_LEDS 0x008 30 29 #define LG_EXPANDED_KEYMAP 0x010 31 30 #define LG_IGNORE_DOUBLED_WHEEL 0x020 32 31 #define LG_WIRELESS 0x040 ··· 247 248 goto err_free; 248 249 } 249 250 250 - if (quirks & LG_RESET_LEDS) 251 - usbhid_set_leds(hdev); 252 - 253 251 if (quirks & LG_FF) 254 252 lgff_init(hdev); 255 253 if (quirks & LG_FF2) ··· 274 278 .driver_data = LG_DUPLICATE_USAGES }, 275 279 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI), 276 280 .driver_data = LG_DUPLICATE_USAGES }, 277 - 278 - { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_KBD), 279 - .driver_data = LG_RESET_LEDS }, 280 281 281 282 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD), 282 283 .driver_data = LG_IGNORE_DOUBLED_WHEEL | LG_EXPANDED_KEYMAP },

+82

drivers/hid/hid-ntrig.c

··· 1 + /* 2 + * HID driver for some ntrig "special" devices 3 + * 4 + * Copyright (c) 1999 Andreas Gal 5 + * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz> 6 + * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc 7 + * Copyright (c) 2006-2007 Jiri Kosina 8 + * Copyright (c) 2007 Paul Walmsley 9 + * Copyright (c) 2008 Jiri Slaby 10 + * Copyright (c) 2008 Rafi Rubin 11 + * 12 + */ 13 + 14 + /* 15 + * This program is free software; you can redistribute it and/or modify it 16 + * under the terms of the GNU General Public License as published by the Free 17 + * Software Foundation; either version 2 of the License, or (at your option) 18 + * any later version. 19 + */ 20 + 21 + #include <linux/device.h> 22 + #include <linux/hid.h> 23 + #include <linux/module.h> 24 + 25 + #include "hid-ids.h" 26 + 27 + #define NTRIG_DUPLICATE_USAGES 0x001 28 + 29 + #define nt_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, \ 30 + EV_KEY, (c)) 31 + 32 + static int ntrig_input_mapping(struct hid_device *hdev, struct hid_input *hi, 33 + struct hid_field *field, struct hid_usage *usage, 34 + unsigned long **bit, int *max) 35 + { 36 + if ((usage->hid & HID_USAGE_PAGE) == HID_UP_DIGITIZER && 37 + (usage->hid & 0xff) == 0x47) { 38 + nt_map_key_clear(BTN_TOOL_DOUBLETAP); 39 + return 1; 40 + } 41 + return 0; 42 + } 43 + 44 + static int ntrig_input_mapped(struct hid_device *hdev, struct hid_input *hi, 45 + struct hid_field *field, struct hid_usage *usage, 46 + unsigned long **bit, int *max) 47 + { 48 + if (usage->type == EV_KEY || usage->type == EV_REL 49 + || usage->type == EV_ABS) 50 + clear_bit(usage->code, *bit); 51 + 52 + return 0; 53 + } 54 + static const struct hid_device_id ntrig_devices[] = { 55 + { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN), 56 + .driver_data = NTRIG_DUPLICATE_USAGES }, 57 + { } 58 + }; 59 + MODULE_DEVICE_TABLE(hid, ntrig_devices); 60 + 61 + static struct hid_driver ntrig_driver = { 62 + .name = "ntrig", 63 + .id_table = ntrig_devices, 64 + .input_mapping = ntrig_input_mapping, 65 + .input_mapped = ntrig_input_mapped, 66 + }; 67 + 68 + static int ntrig_init(void) 69 + { 70 + return hid_register_driver(&ntrig_driver); 71 + } 72 + 73 + static void ntrig_exit(void) 74 + { 75 + hid_unregister_driver(&ntrig_driver); 76 + } 77 + 78 + module_init(ntrig_init); 79 + module_exit(ntrig_exit); 80 + MODULE_LICENSE("GPL"); 81 + 82 + HID_COMPAT_LOAD_DRIVER(ntrig);

+1 -1

drivers/hid/hid-sony.c

··· 102 102 } 103 103 104 104 ret = sony_set_operational(hdev); 105 - if (ret) 105 + if (ret < 0) 106 106 goto err_stop; 107 107 108 108 return 0;

+77

drivers/hid/hid-topseed.c

··· 1 + /* 2 + * HID driver for TopSeed Cyberlink remote 3 + * 4 + * Copyright (c) 2008 Lev Babiev 5 + * based on hid-cherry driver 6 + */ 7 + 8 + /* 9 + * This program is free software; you can redistribute it and/or modify it 10 + * under the terms of the GNU General Public License as published by the Free 11 + * Software Foundation; either version 2 of the License, or (at your option) 12 + * any later version. 13 + */ 14 + 15 + #include <linux/device.h> 16 + #include <linux/hid.h> 17 + #include <linux/module.h> 18 + 19 + #include "hid-ids.h" 20 + 21 + #define ts_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, \ 22 + EV_KEY, (c)) 23 + static int ts_input_mapping(struct hid_device *hdev, struct hid_input *hi, 24 + struct hid_field *field, struct hid_usage *usage, 25 + unsigned long **bit, int *max) 26 + { 27 + if ((usage->hid & HID_USAGE_PAGE) != 0x0ffbc0000) 28 + return 0; 29 + 30 + switch (usage->hid & HID_USAGE) { 31 + case 0x00d: ts_map_key_clear(KEY_HOME); break; 32 + case 0x024: ts_map_key_clear(KEY_MENU); break; 33 + case 0x025: ts_map_key_clear(KEY_TV); break; 34 + case 0x048: ts_map_key_clear(KEY_RED); break; 35 + case 0x047: ts_map_key_clear(KEY_GREEN); break; 36 + case 0x049: ts_map_key_clear(KEY_YELLOW); break; 37 + case 0x04a: ts_map_key_clear(KEY_BLUE); break; 38 + case 0x04b: ts_map_key_clear(KEY_ANGLE); break; 39 + case 0x04c: ts_map_key_clear(KEY_LANGUAGE); break; 40 + case 0x04d: ts_map_key_clear(KEY_SUBTITLE); break; 41 + case 0x031: ts_map_key_clear(KEY_AUDIO); break; 42 + case 0x032: ts_map_key_clear(KEY_TEXT); break; 43 + case 0x033: ts_map_key_clear(KEY_CHANNEL); break; 44 + default: 45 + return 0; 46 + } 47 + 48 + return 1; 49 + } 50 + 51 + static const struct hid_device_id ts_devices[] = { 52 + { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) }, 53 + { } 54 + }; 55 + MODULE_DEVICE_TABLE(hid, ts_devices); 56 + 57 + static struct hid_driver ts_driver = { 58 + .name = "topseed", 59 + .id_table = ts_devices, 60 + .input_mapping = ts_input_mapping, 61 + }; 62 + 63 + static int ts_init(void) 64 + { 65 + return hid_register_driver(&ts_driver); 66 + } 67 + 68 + static void ts_exit(void) 69 + { 70 + hid_unregister_driver(&ts_driver); 71 + } 72 + 73 + module_init(ts_init); 74 + module_exit(ts_exit); 75 + MODULE_LICENSE("GPL"); 76 + 77 + HID_COMPAT_LOAD_DRIVER(topseed);

+30 -2

drivers/hid/hidraw.c

··· 208 208 209 209 list_del(&list->node); 210 210 dev = hidraw_table[minor]; 211 - if (!dev->open--) { 211 + if (!--dev->open) { 212 212 if (list->hidraw->exist) 213 213 dev->hid->ll_driver->close(dev->hid); 214 214 else ··· 265 265 break; 266 266 } 267 267 default: 268 + { 269 + struct hid_device *hid = dev->hid; 270 + if (_IOC_TYPE(cmd) != 'H' || _IOC_DIR(cmd) != _IOC_READ) 271 + return -EINVAL; 272 + 273 + if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGRAWNAME(0))) { 274 + int len; 275 + if (!hid->name) 276 + return 0; 277 + len = strlen(hid->name) + 1; 278 + if (len > _IOC_SIZE(cmd)) 279 + len = _IOC_SIZE(cmd); 280 + return copy_to_user(user_arg, hid->name, len) ? 281 + -EFAULT : len; 282 + } 283 + 284 + if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGRAWPHYS(0))) { 285 + int len; 286 + if (!hid->phys) 287 + return 0; 288 + len = strlen(hid->phys) + 1; 289 + if (len > _IOC_SIZE(cmd)) 290 + len = _IOC_SIZE(cmd); 291 + return copy_to_user(user_arg, hid->phys, len) ? 292 + -EFAULT : len; 293 + } 294 + } 295 + 268 296 ret = -ENOTTY; 269 297 } 270 298 unlock_kernel(); ··· 357 329 goto out; 358 330 } 359 331 360 - dev->dev = device_create(hidraw_class, NULL, MKDEV(hidraw_major, minor), 332 + dev->dev = device_create(hidraw_class, &hid->dev, MKDEV(hidraw_major, minor), 361 333 NULL, "%s%d", "hidraw", minor); 362 334 363 335 if (IS_ERR(dev->dev)) {

+1 -1

drivers/hid/usbhid/Kconfig

··· 45 45 If unsure, say Y. 46 46 47 47 menu "USB HID Boot Protocol drivers" 48 - depends on USB!=n && USB_HID!=y 48 + depends on USB!=n && USB_HID!=y && EMBEDDED 49 49 50 50 config USB_KBD 51 51 tristate "USB HIDBP Keyboard (simple Boot) support"

+22 -12

drivers/hid/usbhid/hid-core.c

··· 4 4 * Copyright (c) 1999 Andreas Gal 5 5 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz> 6 6 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc 7 - * Copyright (c) 2006-2007 Jiri Kosina 7 + * Copyright (c) 2006-2008 Jiri Kosina 8 8 */ 9 9 10 10 /* ··· 641 641 unsigned int size; 642 642 643 643 list_for_each_entry(report, &hid->report_enum[type].report_list, list) { 644 - size = ((report->size - 1) >> 3) + 1; 645 - if (type == HID_INPUT_REPORT && hid->report_enum[type].numbered) 646 - size++; 644 + size = ((report->size - 1) >> 3) + 1 + hid->report_enum[type].numbered; 647 645 if (*max < size) 648 646 *max = size; 649 647 } ··· 651 653 { 652 654 struct usbhid_device *usbhid = hid->driver_data; 653 655 654 - if (!(usbhid->inbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->inbuf_dma))) 655 - return -1; 656 - if (!(usbhid->outbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->outbuf_dma))) 657 - return -1; 658 - if (!(usbhid->cr = usb_buffer_alloc(dev, sizeof(*(usbhid->cr)), GFP_ATOMIC, &usbhid->cr_dma))) 659 - return -1; 660 - if (!(usbhid->ctrlbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->ctrlbuf_dma))) 656 + usbhid->inbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_KERNEL, 657 + &usbhid->inbuf_dma); 658 + usbhid->outbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_KERNEL, 659 + &usbhid->outbuf_dma); 660 + usbhid->cr = usb_buffer_alloc(dev, sizeof(*usbhid->cr), GFP_KERNEL, 661 + &usbhid->cr_dma); 662 + usbhid->ctrlbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_KERNEL, 663 + &usbhid->ctrlbuf_dma); 664 + if (!usbhid->inbuf || !usbhid->outbuf || !usbhid->cr || 665 + !usbhid->ctrlbuf) 661 666 return -1; 662 667 663 668 return 0; ··· 808 807 int interval; 809 808 810 809 endpoint = &interface->endpoint[n].desc; 811 - if ((endpoint->bmAttributes & 3) != 3) /* Not an interrupt endpoint */ 810 + if (!usb_endpoint_xfer_int(endpoint)) 812 811 continue; 813 812 814 813 interval = endpoint->bInterval; ··· 876 875 hid_dump_device(hid); 877 876 878 877 set_bit(HID_STARTED, &usbhid->iofl); 878 + 879 + /* Some keyboards don't work until their LEDs have been set. 880 + * Since BIOSes do set the LEDs, it must be safe for any device 881 + * that supports the keyboard boot protocol. 882 + */ 883 + if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT && 884 + interface->desc.bInterfaceProtocol == 885 + USB_INTERFACE_PROTOCOL_KEYBOARD) 886 + usbhid_set_leds(hid); 879 887 880 888 return 0; 881 889

+1

drivers/hid/usbhid/hid-quirks.c

··· 54 54 { USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2700, HID_QUIRK_NOGET }, 55 55 { USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET }, 56 56 { USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_KEYBOARD, HID_QUIRK_NOGET }, 57 + { USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209, HID_QUIRK_MULTI_INPUT }, 57 58 { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS }, 58 59 { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_QUAD_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT }, 59 60

+99 -36

drivers/hid/usbhid/hiddev.c

··· 49 49 struct hiddev { 50 50 int exist; 51 51 int open; 52 + struct mutex existancelock; 52 53 wait_queue_head_t wait; 53 54 struct hid_device *hid; 54 55 struct list_head list; ··· 64 63 struct fasync_struct *fasync; 65 64 struct hiddev *hiddev; 66 65 struct list_head node; 66 + struct mutex thread_lock; 67 67 }; 68 68 69 69 static struct hiddev *hiddev_table[HIDDEV_MINORS]; ··· 266 264 static int hiddev_open(struct inode *inode, struct file *file) 267 265 { 268 266 struct hiddev_list *list; 269 - unsigned long flags; 267 + int res; 270 268 271 269 int i = iminor(inode) - HIDDEV_MINOR_BASE; 272 270 273 - if (i >= HIDDEV_MINORS || !hiddev_table[i]) 271 + if (i >= HIDDEV_MINORS || i < 0 || !hiddev_table[i]) 274 272 return -ENODEV; 275 273 276 274 if (!(list = kzalloc(sizeof(struct hiddev_list), GFP_KERNEL))) 277 275 return -ENOMEM; 276 + mutex_init(&list->thread_lock); 278 277 279 278 list->hiddev = hiddev_table[i]; 280 279 281 - spin_lock_irqsave(&list->hiddev->list_lock, flags); 282 - list_add_tail(&list->node, &hiddev_table[i]->list); 283 - spin_unlock_irqrestore(&list->hiddev->list_lock, flags); 284 280 285 281 file->private_data = list; 286 282 287 - if (!list->hiddev->open++) 288 - if (list->hiddev->exist) 289 - usbhid_open(hiddev_table[i]->hid); 283 + /* 284 + * no need for locking because the USB major number 285 + * is shared which usbcore guards against disconnect 286 + */ 287 + if (list->hiddev->exist) { 288 + if (!list->hiddev->open++) { 289 + res = usbhid_open(hiddev_table[i]->hid); 290 + if (res < 0) { 291 + res = -EIO; 292 + goto bail; 293 + } 294 + } 295 + } else { 296 + res = -ENODEV; 297 + goto bail; 298 + } 299 + 300 + spin_lock_irq(&list->hiddev->list_lock); 301 + list_add_tail(&list->node, &hiddev_table[i]->list); 302 + spin_unlock_irq(&list->hiddev->list_lock); 290 303 291 304 return 0; 305 + bail: 306 + file->private_data = NULL; 307 + kfree(list->hiddev); 308 + return res; 292 309 } 293 310 294 311 /* ··· 326 305 DECLARE_WAITQUEUE(wait, current); 327 306 struct hiddev_list *list = file->private_data; 328 307 int event_size; 329 - int retval = 0; 308 + int retval; 330 309 331 310 event_size = ((list->flags & HIDDEV_FLAG_UREF) != 0) ? 332 311 sizeof(struct hiddev_usage_ref) : sizeof(struct hiddev_event); ··· 334 313 if (count < event_size) 335 314 return 0; 336 315 316 + /* lock against other threads */ 317 + retval = mutex_lock_interruptible(&list->thread_lock); 318 + if (retval) 319 + return -ERESTARTSYS; 320 + 337 321 while (retval == 0) { 338 322 if (list->head == list->tail) { 339 - add_wait_queue(&list->hiddev->wait, &wait); 340 - set_current_state(TASK_INTERRUPTIBLE); 323 + prepare_to_wait(&list->hiddev->wait, &wait, TASK_INTERRUPTIBLE); 341 324 342 325 while (list->head == list->tail) { 343 326 if (file->f_flags & O_NONBLOCK) { ··· 357 332 break; 358 333 } 359 334 335 + /* let O_NONBLOCK tasks run */ 336 + mutex_unlock(&list->thread_lock); 360 337 schedule(); 338 + if (mutex_lock_interruptible(&list->thread_lock)) 339 + return -EINTR; 361 340 set_current_state(TASK_INTERRUPTIBLE); 362 341 } 342 + finish_wait(&list->hiddev->wait, &wait); 363 343 364 - set_current_state(TASK_RUNNING); 365 - remove_wait_queue(&list->hiddev->wait, &wait); 366 344 } 367 345 368 - if (retval) 346 + if (retval) { 347 + mutex_unlock(&list->thread_lock); 369 348 return retval; 349 + } 370 350 371 351 372 352 while (list->head != list->tail && 373 353 retval + event_size <= count) { 374 354 if ((list->flags & HIDDEV_FLAG_UREF) == 0) { 375 - if (list->buffer[list->tail].field_index != 376 - HID_FIELD_INDEX_NONE) { 355 + if (list->buffer[list->tail].field_index != HID_FIELD_INDEX_NONE) { 377 356 struct hiddev_event event; 357 + 378 358 event.hid = list->buffer[list->tail].usage_code; 379 359 event.value = list->buffer[list->tail].value; 380 - if (copy_to_user(buffer + retval, &event, sizeof(struct hiddev_event))) 360 + if (copy_to_user(buffer + retval, &event, sizeof(struct hiddev_event))) { 361 + mutex_unlock(&list->thread_lock); 381 362 return -EFAULT; 363 + } 382 364 retval += sizeof(struct hiddev_event); 383 365 } 384 366 } else { 385 367 if (list->buffer[list->tail].field_index != HID_FIELD_INDEX_NONE || 386 368 (list->flags & HIDDEV_FLAG_REPORT) != 0) { 387 - if (copy_to_user(buffer + retval, list->buffer + list->tail, sizeof(struct hiddev_usage_ref))) 369 + 370 + if (copy_to_user(buffer + retval, list->buffer + list->tail, sizeof(struct hiddev_usage_ref))) { 371 + mutex_unlock(&list->thread_lock); 388 372 return -EFAULT; 373 + } 389 374 retval += sizeof(struct hiddev_usage_ref); 390 375 } 391 376 } ··· 403 368 } 404 369 405 370 } 371 + mutex_unlock(&list->thread_lock); 406 372 407 373 return retval; 408 374 } ··· 591 555 struct hid_field *field; 592 556 struct usbhid_device *usbhid = hid->driver_data; 593 557 void __user *user_arg = (void __user *)arg; 594 - int i; 558 + int i, r; 595 559 596 560 /* Called without BKL by compat methods so no BKL taken */ 597 561 ··· 655 619 } 656 620 657 621 case HIDIOCGSTRING: 658 - return hiddev_ioctl_string(hiddev, cmd, user_arg); 622 + mutex_lock(&hiddev->existancelock); 623 + if (!hiddev->exist) 624 + r = hiddev_ioctl_string(hiddev, cmd, user_arg); 625 + else 626 + r = -ENODEV; 627 + mutex_unlock(&hiddev->existancelock); 628 + return r; 659 629 660 630 case HIDIOCINITREPORT: 631 + mutex_lock(&hiddev->existancelock); 632 + if (!hiddev->exist) { 633 + mutex_unlock(&hiddev->existancelock); 634 + return -ENODEV; 635 + } 661 636 usbhid_init_reports(hid); 637 + mutex_unlock(&hiddev->existancelock); 662 638 663 639 return 0; 664 640 ··· 684 636 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) 685 637 return -EINVAL; 686 638 687 - usbhid_submit_report(hid, report, USB_DIR_IN); 688 - usbhid_wait_io(hid); 639 + mutex_lock(&hiddev->existancelock); 640 + if (hiddev->exist) { 641 + usbhid_submit_report(hid, report, USB_DIR_IN); 642 + usbhid_wait_io(hid); 643 + } 644 + mutex_unlock(&hiddev->existancelock); 689 645 690 646 return 0; 691 647 ··· 703 651 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) 704 652 return -EINVAL; 705 653 706 - usbhid_submit_report(hid, report, USB_DIR_OUT); 707 - usbhid_wait_io(hid); 654 + mutex_lock(&hiddev->existancelock); 655 + if (hiddev->exist) { 656 + usbhid_submit_report(hid, report, USB_DIR_OUT); 657 + usbhid_wait_io(hid); 658 + } 659 + mutex_unlock(&hiddev->existancelock); 708 660 709 661 return 0; 710 662 ··· 766 710 case HIDIOCGUSAGES: 767 711 case HIDIOCSUSAGES: 768 712 case HIDIOCGCOLLECTIONINDEX: 769 - return hiddev_ioctl_usage(hiddev, cmd, user_arg); 713 + mutex_lock(&hiddev->existancelock); 714 + if (hiddev->exist) 715 + r = hiddev_ioctl_usage(hiddev, cmd, user_arg); 716 + else 717 + r = -ENODEV; 718 + mutex_unlock(&hiddev->existancelock); 719 + return r; 770 720 771 721 case HIDIOCGCOLLECTIONINFO: 772 722 if (copy_from_user(&cinfo, user_arg, sizeof(cinfo))) ··· 870 808 if (!(hiddev = kzalloc(sizeof(struct hiddev), GFP_KERNEL))) 871 809 return -1; 872 810 811 + init_waitqueue_head(&hiddev->wait); 812 + INIT_LIST_HEAD(&hiddev->list); 813 + spin_lock_init(&hiddev->list_lock); 814 + mutex_init(&hiddev->existancelock); 815 + hiddev->hid = hid; 816 + hiddev->exist = 1; 817 + 873 818 retval = usb_register_dev(usbhid->intf, &hiddev_class); 874 819 if (retval) { 875 820 err_hid("Not able to get a minor for this device."); 876 821 kfree(hiddev); 877 822 return -1; 823 + } else { 824 + hid->minor = usbhid->intf->minor; 825 + hiddev_table[usbhid->intf->minor - HIDDEV_MINOR_BASE] = hiddev; 878 826 } 879 - 880 - init_waitqueue_head(&hiddev->wait); 881 - INIT_LIST_HEAD(&hiddev->list); 882 - spin_lock_init(&hiddev->list_lock); 883 - hiddev->hid = hid; 884 - hiddev->exist = 1; 885 - 886 - hid->minor = usbhid->intf->minor; 887 - hid->hiddev = hiddev; 888 - 889 - hiddev_table[usbhid->intf->minor - HIDDEV_MINOR_BASE] = hiddev; 890 827 891 828 return 0; 892 829 } ··· 900 839 struct hiddev *hiddev = hid->hiddev; 901 840 struct usbhid_device *usbhid = hid->driver_data; 902 841 842 + mutex_lock(&hiddev->existancelock); 903 843 hiddev->exist = 0; 844 + mutex_unlock(&hiddev->existancelock); 904 845 905 846 hiddev_table[hiddev->hid->minor - HIDDEV_MINOR_BASE] = NULL; 906 847 usb_deregister_dev(usbhid->intf, &hiddev_class);

+10

drivers/hid/usbhid/usbhid.h

··· 40 40 void usbhid_init_reports(struct hid_device *hid); 41 41 void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir); 42 42 43 + /* iofl flags */ 44 + #define HID_CTRL_RUNNING 1 45 + #define HID_OUT_RUNNING 2 46 + #define HID_IN_RUNNING 3 47 + #define HID_RESET_PENDING 4 48 + #define HID_SUSPENDED 5 49 + #define HID_CLEAR_HALT 6 50 + #define HID_DISCONNECTED 7 51 + #define HID_STARTED 8 52 + 43 53 /* 44 54 * USB-specific HID struct, to be pointed to 45 55 * from struct hid_device->driver_data

+7 -9

include/linux/hid.h

··· 403 403 #define HID_STAT_ADDED 1 404 404 #define HID_STAT_PARSED 2 405 405 406 - #define HID_CTRL_RUNNING 1 407 - #define HID_OUT_RUNNING 2 408 - #define HID_IN_RUNNING 3 409 - #define HID_RESET_PENDING 4 410 - #define HID_SUSPENDED 5 411 - #define HID_CLEAR_HALT 6 412 - #define HID_DISCONNECTED 7 413 - #define HID_STARTED 8 414 - 415 406 struct hid_input { 416 407 struct list_head list; 417 408 struct hid_report *report; ··· 531 540 * @name: driver name (e.g. "Footech_bar-wheel") 532 541 * @id_table: which devices is this driver for (must be non-NULL for probe 533 542 * to be called) 543 + * @dyn_list: list of dynamically added device ids 544 + * @dyn_lock: lock protecting @dyn_list 534 545 * @probe: new device inserted 535 546 * @remove: device removed (NULL if not a hot-plug capable driver) 536 547 * @report_table: on which reports to call raw_event (NULL means all) ··· 559 566 struct hid_driver { 560 567 char *name; 561 568 const struct hid_device_id *id_table; 569 + 570 + struct list_head dyn_list; 571 + spinlock_t dyn_lock; 562 572 563 573 int (*probe)(struct hid_device *dev, const struct hid_device_id *id); 564 574 void (*remove)(struct hid_device *dev); ··· 793 797 794 798 #ifdef CONFIG_HID_COMPAT 795 799 #define HID_COMPAT_LOAD_DRIVER(name) \ 800 + /* prototype to avoid sparse warning */ \ 801 + extern void hid_compat_##name(void); \ 796 802 void hid_compat_##name(void) { } \ 797 803 EXPORT_SYMBOL(hid_compat_##name) 798 804 #else

+2

include/linux/hidraw.h

··· 33 33 #define HIDIOCGRDESCSIZE _IOR('H', 0x01, int) 34 34 #define HIDIOCGRDESC _IOR('H', 0x02, struct hidraw_report_descriptor) 35 35 #define HIDIOCGRAWINFO _IOR('H', 0x03, struct hidraw_devinfo) 36 + #define HIDIOCGRAWNAME(len) _IOC(_IOC_READ, 'H', 0x04, len) 37 + #define HIDIOCGRAWPHYS(len) _IOC(_IOC_READ, 'H', 0x05, len) 36 38 37 39 #define HIDRAW_FIRST_MINOR 0 38 40 #define HIDRAW_MAX_DEVICES 64