Lines Matching defs:hdev
1881 bool hid_match_one_id(const struct hid_device *hdev,
1884 return (id->bus == HID_BUS_ANY || id->bus == hdev->bus) &&
1885 (id->group == HID_GROUP_ANY || id->group == hdev->group) &&
1886 (id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&
1887 (id->product == HID_ANY_ID || id->product == hdev->product);
1890 const struct hid_device_id *hid_match_id(const struct hid_device *hdev,
1894 if (hid_match_one_id(hdev, id))
1906 static bool hid_hiddev(struct hid_device *hdev)
1908 return !!hid_match_id(hdev, hid_hiddev_list);
1918 struct hid_device *hdev = to_hid_device(dev);
1920 if (off >= hdev->rsize)
1923 if (off + count > hdev->rsize)
1924 count = hdev->rsize - off;
1926 memcpy(buf, hdev->rdesc + off, count);
1935 struct hid_device *hdev = to_hid_device(dev);
1937 return sprintf(buf, "%02x\n", hdev->country & 0xff);
1951 int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
1963 if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE)
1965 if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE)
1967 if (hdev->bus != BUS_USB)
1969 if (hid_hiddev(hdev))
1972 if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,
1974 hdev->claimed |= HID_CLAIMED_INPUT;
1976 if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&
1977 !hdev->hiddev_connect(hdev,
1979 hdev->claimed |= HID_CLAIMED_HIDDEV;
1980 if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev))
1981 hdev->claimed |= HID_CLAIMED_HIDRAW;
1984 hdev->claimed |= HID_CLAIMED_DRIVER;
1988 if (!hdev->claimed && !hdev->driver->raw_event) {
1989 hid_err(hdev, "device has no listeners, quitting\n");
1993 if ((hdev->claimed & HID_CLAIMED_INPUT) &&
1994 (connect_mask & HID_CONNECT_FF) && hdev->ff_init)
1995 hdev->ff_init(hdev);
1998 if (hdev->claimed & HID_CLAIMED_INPUT)
2000 if (hdev->claimed & HID_CLAIMED_HIDDEV)
2002 ((struct hiddev *)hdev->hiddev)->minor);
2003 if (hdev->claimed & HID_CLAIMED_HIDRAW)
2005 ((struct hidraw *)hdev->hidraw)->minor);
2008 for (i = 0; i < hdev->maxcollection; i++) {
2009 struct hid_collection *col = &hdev->collection[i];
2018 switch (hdev->bus) {
2035 ret = device_create_file(&hdev->dev, &dev_attr_country);
2037 hid_warn(hdev,
2040 hid_info(hdev, "%s: %s HID v%x.%02x %s [%s] on %s\n",
2041 buf, bus, hdev->version >> 8, hdev->version & 0xff,
2042 type, hdev->name, hdev->phys);
2048 void hid_disconnect(struct hid_device *hdev)
2050 device_remove_file(&hdev->dev, &dev_attr_country);
2051 if (hdev->claimed & HID_CLAIMED_INPUT)
2052 hidinput_disconnect(hdev);
2053 if (hdev->claimed & HID_CLAIMED_HIDDEV)
2054 hdev->hiddev_disconnect(hdev);
2055 if (hdev->claimed & HID_CLAIMED_HIDRAW)
2056 hidraw_disconnect(hdev);
2057 hdev->claimed = 0;
2063 * @hdev: hid device
2070 int hid_hw_start(struct hid_device *hdev, unsigned int connect_mask)
2074 error = hdev->ll_driver->start(hdev);
2079 error = hid_connect(hdev, connect_mask);
2081 hdev->ll_driver->stop(hdev);
2092 * @hdev: hid device
2097 void hid_hw_stop(struct hid_device *hdev)
2099 hid_disconnect(hdev);
2100 hdev->ll_driver->stop(hdev);
2106 * @hdev: hid device
2112 int hid_hw_open(struct hid_device *hdev)
2116 ret = mutex_lock_killable(&hdev->ll_open_lock);
2120 if (!hdev->ll_open_count++) {
2121 ret = hdev->ll_driver->open(hdev);
2123 hdev->ll_open_count--;
2126 mutex_unlock(&hdev->ll_open_lock);
2134 * @hdev: hid device
2140 void hid_hw_close(struct hid_device *hdev)
2142 mutex_lock(&hdev->ll_open_lock);
2143 if (!--hdev->ll_open_count)
2144 hdev->ll_driver->close(hdev);
2145 mutex_unlock(&hdev->ll_open_lock);
2215 const struct hid_device_id *hid_match_device(struct hid_device *hdev,
2222 if (hid_match_one_id(hdev, &dynid->id)) {
2229 return hid_match_id(hdev, hdrv->id_table);
2236 struct hid_device *hdev = to_hid_device(dev);
2238 return hid_match_device(hdev, hdrv) != NULL;
2267 struct hid_device *hdev = to_hid_device(dev);
2271 if (down_interruptible(&hdev->driver_input_lock)) {
2275 hdev->io_started = false;
2277 clear_bit(ffs(HID_STAT_REPROBED), &hdev->status);
2279 if (!hdev->driver) {
2280 id = hid_match_device(hdev, hdrv);
2287 if (!hdrv->match(hdev, hid_ignore_special_drivers)) {
2304 hdev->quirks = hid_lookup_quirk(hdev);
2305 hdev->driver = hdrv;
2307 ret = hdrv->probe(hdev, id);
2309 ret = hid_open_report(hdev);
2311 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
2314 hid_close_report(hdev);
2315 hdev->driver = NULL;
2319 if (!hdev->io_started)
2320 up(&hdev->driver_input_lock);
2327 struct hid_device *hdev = to_hid_device(dev);
2330 down(&hdev->driver_input_lock);
2331 hdev->io_started = false;
2333 hdrv = hdev->driver;
2336 hdrv->remove(hdev);
2338 hid_hw_stop(hdev);
2339 hid_close_report(hdev);
2340 hdev->driver = NULL;
2343 if (!hdev->io_started)
2344 up(&hdev->driver_input_lock);
2352 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
2355 hdev->bus, hdev->group, hdev->vendor, hdev->product);
2375 struct hid_device *hdev = to_hid_device(dev);
2378 hdev->bus, hdev->vendor, hdev->product))
2381 if (add_uevent_var(env, "HID_NAME=%s", hdev->name))
2384 if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys))
2387 if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq))
2391 hdev->bus, hdev->group, hdev->vendor, hdev->product))
2408 int hid_add_device(struct hid_device *hdev)
2413 if (WARN_ON(hdev->status & HID_STAT_ADDED))
2416 hdev->quirks = hid_lookup_quirk(hdev);
2420 if (hid_ignore(hdev))
2426 if (!hdev->ll_driver->raw_request) {
2427 hid_err(hdev, "transport driver missing .raw_request()\n");
2435 ret = hdev->ll_driver->parse(hdev);
2438 if (!hdev->dev_rdesc)
2445 hdev->group = HID_GROUP_GENERIC;
2446 } else if (!hdev->group &&
2447 !(hdev->quirks & HID_QUIRK_HAVE_SPECIAL_DRIVER)) {
2448 ret = hid_scan_report(hdev);
2450 hid_warn(hdev, "bad device descriptor (%d)\n", ret);
2453 hdev->id = atomic_inc_return(&id);
2457 dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus,
2458 hdev->vendor, hdev->product, hdev->id);
2460 hid_debug_register(hdev, dev_name(&hdev->dev));
2461 ret = device_add(&hdev->dev);
2463 hdev->status |= HID_STAT_ADDED;
2465 hid_debug_unregister(hdev);
2482 struct hid_device *hdev;
2485 hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
2486 if (hdev == NULL)
2489 device_initialize(&hdev->dev);
2490 hdev->dev.release = hid_device_release;
2491 hdev->dev.bus = &hid_bus_type;
2492 device_enable_async_suspend(&hdev->dev);
2494 hid_close_report(hdev);
2496 init_waitqueue_head(&hdev->debug_wait);
2497 INIT_LIST_HEAD(&hdev->debug_list);
2498 spin_lock_init(&hdev->debug_list_lock);
2499 sema_init(&hdev->driver_input_lock, 1);
2500 mutex_init(&hdev->ll_open_lock);
2501 kref_init(&hdev->ref);
2503 return hdev;
2507 static void hid_remove_device(struct hid_device *hdev)
2509 if (hdev->status & HID_STAT_ADDED) {
2510 device_del(&hdev->dev);
2511 hid_debug_unregister(hdev);
2512 hdev->status &= ~HID_STAT_ADDED;
2514 kfree(hdev->dev_rdesc);
2515 hdev->dev_rdesc = NULL;
2516 hdev->dev_rsize = 0;
2522 * @hdev: hid device
2527 void hid_destroy_device(struct hid_device *hdev)
2529 hid_remove_device(hdev);
2530 put_device(&hdev->dev);
2538 struct hid_device *hdev = to_hid_device(dev);
2540 if (hdev->driver == hdrv &&
2541 !hdrv->match(hdev, hid_ignore_special_drivers) &&
2542 !test_and_set_bit(ffs(HID_STAT_REPROBED), &hdev->status))