Commit 207733f9 authored by Dmitry Torokhov's avatar Dmitry Torokhov Committed by Jiri Kosina
Browse files

HID: split apart hid_device_probe to make logic more apparent 



hid_device_probe() has a complex flow and locks and unlocks a mutex.
Move the most of the logic into __hid_device_probe() and
hid_check_device_match() and leave the locking in hid_device_probe()
which makes the code more clear.

Signed-off-by: default avatarDmitry Torokhov <dmitry.torokhov@gmail.com>
Signed-off-by: default avatarJiri Kosina <jkosina@suse.cz>
parent 34da76dc

drivers/hid/hid-core.c

+54 −47
Original line number Diff line number Diff line
@@ -2587,48 +2587,37 @@ bool hid_compare_device_paths(struct hid_device *hdev_a, 
}

EXPORT_SYMBOL_GPL(hid_compare_device_paths);



static int hid_device_probe(struct device *dev)

static bool hid_check_device_match(struct hid_device *hdev,

				   struct hid_driver *hdrv,

				   const struct hid_device_id **id)

{

	struct hid_driver *hdrv = to_hid_driver(dev->driver);

	struct hid_device *hdev = to_hid_device(dev);

	const struct hid_device_id *id;

	int ret = 0;



	if (down_interruptible(&hdev->driver_input_lock)) {

		ret = -EINTR;

		goto end;

	}

	hdev->io_started = false;



	clear_bit(ffs(HID_STAT_REPROBED), &hdev->status);

	*id = hid_match_device(hdev, hdrv);

	if (!*id)

		return -ENODEV;



	if (!hdev->driver) {

		id = hid_match_device(hdev, hdrv);

		if (id == NULL) {

			ret = -ENODEV;

			goto unlock;

		}

	if (hdrv->match)

		return hdrv->match(hdev, hid_ignore_special_drivers);



		if (hdrv->match) {

			if (!hdrv->match(hdev, hid_ignore_special_drivers)) {

				ret = -ENODEV;

				goto unlock;

			}

		} else {

	/*

			 * hid-generic implements .match(), so if

			 * hid_ignore_special_drivers is set, we can safely

			 * return.

	 * hid-generic implements .match(), so we must be dealing with a

	 * different HID driver here, and can simply check if

	 * hid_ignore_special_drivers is set or not.

	 */

			if (hid_ignore_special_drivers) {

				ret = -ENODEV;

				goto unlock;

			}

	return !hid_ignore_special_drivers;

}



static int __hid_device_probe(struct hid_device *hdev, struct hid_driver *hdrv)

{

	const struct hid_device_id *id;

	int ret;



	if (!hid_check_device_match(hdev, hdrv, &id))

		return -ENODEV;



	/* reset the quirks that has been previously set */

	hdev->quirks = hid_lookup_quirk(hdev);

	hdev->driver = hdrv;



	if (hdrv->probe) {

		ret = hdrv->probe(hdev, id);

	} else { /* default probe */
@@ -2636,15 +2625,33 @@ static int hid_device_probe(struct device *dev) 
		if (!ret)

			ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);

	}



	if (ret) {

		hid_close_report(hdev);

		hdev->driver = NULL;

	}



	return ret;

}

unlock:



static int hid_device_probe(struct device *dev)

{

	struct hid_device *hdev = to_hid_device(dev);

	struct hid_driver *hdrv = to_hid_driver(dev->driver);

	int ret = 0;



	if (down_interruptible(&hdev->driver_input_lock))

		return -EINTR;



	hdev->io_started = false;

	clear_bit(ffs(HID_STAT_REPROBED), &hdev->status);



	if (!hdev->driver)

		ret = __hid_device_probe(hdev, hdrv);



	if (!hdev->io_started)

		up(&hdev->driver_input_lock);

end:



	return ret;

}