Attachment #18453 for bug #11827

View | Details | Raw Unified | Return to bug 11827
Collapse All | Expand All




#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/mm.h>
#include <linux/mutex.h>
#include <linux/smp_lock.h>
#include <linux/spinlock.h>
#include <asm/unaligned.h>

	struct usb_interface *intf = to_usb_interface(hid->dev.parent);
	struct usb_host_interface *interface = intf->cur_altsetting;
	struct usb_device *dev = interface_to_usbdev(intf);
	struct usbhid_device *usbhid = hid->driver_data;
	unsigned int n, insize = 0;
	int ret;

	WARN_ON(hid->driver_data);

	usbhid = kzalloc(sizeof(struct usbhid_device), GFP_KERNEL);
	if (usbhid == NULL) {
		ret = -ENOMEM;
		goto err;
	}

	hid->driver_data = usbhid;
	usbhid->hid = hid;

	usbhid->bufsize = HID_MIN_BUFFER_SIZE;
	hid_find_max_report(hid, HID_INPUT_REPORT, &usbhid->bufsize);
	hid_find_max_report(hid, HID_OUTPUT_REPORT, &usbhid->bufsize);

	if (insize > HID_MAX_BUFFER_SIZE)
		insize = HID_MAX_BUFFER_SIZE;

	mutex_lock(&usbhid->setup);
	if (hid_alloc_buffers(dev, hid)) {
		ret = -ENOMEM;
		goto fail;

	usbhid_init_reports(hid);
	hid_dump_device(hid);

	set_bit(HID_STARTED, &usbhid->iofl);
	mutex_unlock(&usbhid->setup);

	return 0;

fail:

	usb_free_urb(usbhid->urbout);
	usb_free_urb(usbhid->urbctrl);
	hid_free_buffers(dev, hid);
	mutex_unlock(&usbhid->setup);
err:
	return ret;
}


	if (WARN_ON(!usbhid))
		return;

	mutex_lock(&usbhid->setup);
	clear_bit(HID_STARTED, &usbhid->iofl);
	spin_lock_irq(&usbhid->inlock);	/* Sync with error handler */
	set_bit(HID_DISCONNECTED, &usbhid->iofl);
	spin_unlock_irq(&usbhid->inlock);

	usb_free_urb(usbhid->urbout);

	hid_free_buffers(hid_to_usb_dev(hid), hid);
	mutex_unlock(&usbhid->setup);
	hid->driver_data = NULL;
}

static struct hid_ll_driver usb_hid_driver = {

static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
	struct usb_device *dev = interface_to_usbdev(intf);
	struct usbhid_device *usbhid;
	struct hid_device *hid;
	size_t len;
	int ret;

	if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)
		hid->uniq[0] = 0;

	usbhid = kzalloc(sizeof(*usbhid), GFP_KERNEL);
	if (usbhid == NULL) {
		ret = -ENOMEM;
		goto err;
	}

	hid->driver_data = usbhid;
	usbhid->hid = hid;
	mutex_init(&usbhid->setup); /* needed on suspend/resume */

	ret = hid_add_device(hid);
	if (ret) {
		if (ret != -ENODEV)
			dev_err(&intf->dev, "can't add hid device: %d\n", ret);
		goto err_free;
	}

	return 0;
err_free:
	kfree(usbhid);
err:
	hid_destroy_device(hid);
	return ret;

static void hid_disconnect(struct usb_interface *intf)
{
	struct hid_device *hid = usb_get_intfdata(intf);
	struct usbhid_device *usbhid;

	if (WARN_ON(!hid))
		return;

	usbhid = hid->driver_data;
	hid_destroy_device(hid);
	kfree(usbhid);
}

static int hid_suspend(struct usb_interface *intf, pm_message_t message)

	struct hid_device *hid = usb_get_intfdata (intf);
	struct usbhid_device *usbhid = hid->driver_data;

	mutex_lock(&usbhid->setup);
	if (!test_bit(HID_STARTED, &usbhid->iofl)) {
		mutex_unlock(&usbhid->setup);
		return 0;
	}

	spin_lock_irq(&usbhid->inlock);	/* Sync with error handler */
	set_bit(HID_SUSPENDED, &usbhid->iofl);
	spin_unlock_irq(&usbhid->inlock);
	del_timer(&usbhid->io_retry);
	usb_kill_urb(usbhid->urbin);
	mutex_unlock(&usbhid->setup);
	dev_dbg(&intf->dev, "suspend\n");
	return 0;
}

	struct usbhid_device *usbhid = hid->driver_data;
	int status;

	mutex_lock(&usbhid->setup);
	if (!test_bit(HID_STARTED, &usbhid->iofl)) {
		mutex_unlock(&usbhid->setup);
		return 0;
	}

	clear_bit(HID_SUSPENDED, &usbhid->iofl);
	usbhid->retry_delay = 0;
	status = hid_start_in(hid);
	mutex_unlock(&usbhid->setup);
	dev_dbg(&intf->dev, "resume status %d\n", status);
	return status;
}

Lines 27-32 Link Here

(-)a/drivers/hid/usbhid/usbhid.h (+2 lines)
27	#include <linux/types.h>	27	#include <linux/types.h>
28	#include <linux/slab.h>	28	#include <linux/slab.h>
29	#include <linux/list.h>	29	#include <linux/list.h>
		30	#include <linux/mutex.h>
30	#include <linux/timer.h>	31	#include <linux/timer.h>
31	#include <linux/wait.h>	32	#include <linux/wait.h>
32	#include <linux/workqueue.h>	33	#include <linux/workqueue.h>
Lines 73-78 struct usbhid_device { Link Here
73	dma_addr_t outbuf_dma; /* Output buffer dma */	74	dma_addr_t outbuf_dma; /* Output buffer dma */
74	spinlock_t outlock; /* Output fifo spinlock */	75	spinlock_t outlock; /* Output fifo spinlock */
75		76
		77	struct mutex setup;
76	unsigned long iofl; /* I/O flags (CTRL_RUNNING, OUT_RUNNING) */	78	unsigned long iofl; /* I/O flags (CTRL_RUNNING, OUT_RUNNING) */
77	struct timer_list io_retry; /* Retry timer */	79	struct timer_list io_retry; /* Retry timer */
78	unsigned long stop_retry; /* Time to give up, in jiffies */	80	unsigned long stop_retry; /* Time to give up, in jiffies */

Lines 410-415 struct hid_output_fifo { Link Here

(-)a/include/linux/hid.h (-1 / +1 lines)
410	#define HID_SUSPENDED 5	410	#define HID_SUSPENDED 5
411	#define HID_CLEAR_HALT 6	411	#define HID_CLEAR_HALT 6
412	#define HID_DISCONNECTED 7	412	#define HID_DISCONNECTED 7
		413	#define HID_STARTED 8
413		414
414	struct hid_input {	415	struct hid_input {
415	struct list_head list;	416	struct list_head list;
416	-

Return to bug 11827

Lines 20-25 Link Here

(-)a/drivers/hid/usbhid/hid-core.c (-17 / +41 lines)
20	#include <linux/kernel.h>	20	#include <linux/kernel.h>
21	#include <linux/list.h>	21	#include <linux/list.h>
22	#include <linux/mm.h>	22	#include <linux/mm.h>
		23	#include <linux/mutex.h>
23	#include <linux/smp_lock.h>	24	#include <linux/smp_lock.h>
24	#include <linux/spinlock.h>	25	#include <linux/spinlock.h>
25	#include <asm/unaligned.h>	26	#include <asm/unaligned.h>
Lines 776-796 static int usbhid_start(struct hid_device *hid) Link Here
776	struct usb_interface *intf = to_usb_interface(hid->dev.parent);	777	struct usb_interface *intf = to_usb_interface(hid->dev.parent);
777	struct usb_host_interface *interface = intf->cur_altsetting;	778	struct usb_host_interface *interface = intf->cur_altsetting;
778	struct usb_device *dev = interface_to_usbdev(intf);	779	struct usb_device *dev = interface_to_usbdev(intf);
779	struct usbhid_device *usbhid;	780	struct usbhid_device *usbhid = hid->driver_data;
780	unsigned int n, insize = 0;	781	unsigned int n, insize = 0;
781	int ret;	782	int ret;
782		783
783	WARN_ON(hid->driver_data);
784
785	usbhid = kzalloc(sizeof(struct usbhid_device), GFP_KERNEL);
786	if (usbhid == NULL) {
787	ret = -ENOMEM;
788	goto err;
789	}
790
791	hid->driver_data = usbhid;
792	usbhid->hid = hid;
793
794	usbhid->bufsize = HID_MIN_BUFFER_SIZE;	784	usbhid->bufsize = HID_MIN_BUFFER_SIZE;
795	hid_find_max_report(hid, HID_INPUT_REPORT, &usbhid->bufsize);	785	hid_find_max_report(hid, HID_INPUT_REPORT, &usbhid->bufsize);
796	hid_find_max_report(hid, HID_OUTPUT_REPORT, &usbhid->bufsize);	786	hid_find_max_report(hid, HID_OUTPUT_REPORT, &usbhid->bufsize);
Lines 804-809 static int usbhid_start(struct hid_device *hid) Link Here
804	if (insize > HID_MAX_BUFFER_SIZE)	794	if (insize > HID_MAX_BUFFER_SIZE)
805	insize = HID_MAX_BUFFER_SIZE;	795	insize = HID_MAX_BUFFER_SIZE;
806		796
		797	mutex_lock(&usbhid->setup);
807	if (hid_alloc_buffers(dev, hid)) {	798	if (hid_alloc_buffers(dev, hid)) {
808	ret = -ENOMEM;	799	ret = -ENOMEM;
809	goto fail;	800	goto fail;
Lines 888-893 static int usbhid_start(struct hid_device *hid) Link Here
888	usbhid_init_reports(hid);	879	usbhid_init_reports(hid);
889	hid_dump_device(hid);	880	hid_dump_device(hid);
890		881
		882	set_bit(HID_STARTED, &usbhid->iofl);
		883	mutex_unlock(&usbhid->setup);
		884
891	return 0;	885	return 0;
892		886
893	fail:	887	fail:
Lines 895-902 fail: Link Here
895	usb_free_urb(usbhid->urbout);	889	usb_free_urb(usbhid->urbout);
896	usb_free_urb(usbhid->urbctrl);	890	usb_free_urb(usbhid->urbctrl);
897	hid_free_buffers(dev, hid);	891	hid_free_buffers(dev, hid);
898	kfree(usbhid);	892	mutex_unlock(&usbhid->setup);
899	err:
900	return ret;	893	return ret;
901	}	894	}
902		895
Lines 907-912 static void usbhid_stop(struct hid_device *hid) Link Here
907	if (WARN_ON(!usbhid))	900	if (WARN_ON(!usbhid))
908	return;	901	return;
909		902
		903	mutex_lock(&usbhid->setup);
		904	clear_bit(HID_STARTED, &usbhid->iofl);
910	spin_lock_irq(&usbhid->inlock); /* Sync with error handler */	905	spin_lock_irq(&usbhid->inlock); /* Sync with error handler */
911	set_bit(HID_DISCONNECTED, &usbhid->iofl);	906	set_bit(HID_DISCONNECTED, &usbhid->iofl);
912	spin_unlock_irq(&usbhid->inlock);	907	spin_unlock_irq(&usbhid->inlock);
Lines 931-938 static void usbhid_stop(struct hid_device *hid) Link Here
931	usb_free_urb(usbhid->urbout);	926	usb_free_urb(usbhid->urbout);
932		927
933	hid_free_buffers(hid_to_usb_dev(hid), hid);	928	hid_free_buffers(hid_to_usb_dev(hid), hid);
934	kfree(usbhid);	929	mutex_unlock(&usbhid->setup);
935	hid->driver_data = NULL;
936	}	930	}
937		931
938	static struct hid_ll_driver usb_hid_driver = {	932	static struct hid_ll_driver usb_hid_driver = {
Lines 947-952 static struct hid_ll_driver usb_hid_driver = { Link Here
947	static int hid_probe(struct usb_interface intf, const struct usb_device_id id)	941	static int hid_probe(struct usb_interface intf, const struct usb_device_id id)
948	{	942	{
949	struct usb_device *dev = interface_to_usbdev(intf);	943	struct usb_device *dev = interface_to_usbdev(intf);
		944	struct usbhid_device *usbhid;
950	struct hid_device *hid;	945	struct hid_device *hid;
951	size_t len;	946	size_t len;
952	int ret;	947	int ret;
Lines 1000-1013 static int hid_probe(struct usb_interface intf, const struct usb_device_id id) Link Here
1000	if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)	995	if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)
1001	hid->uniq[0] = 0;	996	hid->uniq[0] = 0;
1002		997
		998	usbhid = kzalloc(sizeof(*usbhid), GFP_KERNEL);
		999	if (usbhid == NULL) {
		1000	ret = -ENOMEM;
		1001	goto err;
		1002	}
		1003
		1004	hid->driver_data = usbhid;
		1005	usbhid->hid = hid;
		1006	mutex_init(&usbhid->setup); /* needed on suspend/resume */
		1007
1003	ret = hid_add_device(hid);	1008	ret = hid_add_device(hid);
1004	if (ret) {	1009	if (ret) {
1005	if (ret != -ENODEV)	1010	if (ret != -ENODEV)
1006	dev_err(&intf->dev, "can't add hid device: %d\n", ret);	1011	dev_err(&intf->dev, "can't add hid device: %d\n", ret);
1007	goto err;	1012	goto err_free;
1008	}	1013	}
1009		1014
1010	return 0;	1015	return 0;
		1016	err_free:
		1017	kfree(usbhid);
1011	err:	1018	err:
1012	hid_destroy_device(hid);	1019	hid_destroy_device(hid);
1013	return ret;	1020	return ret;
Lines 1016-1026 err: Link Here
1016	static void hid_disconnect(struct usb_interface *intf)	1023	static void hid_disconnect(struct usb_interface *intf)
1017	{	1024	{
1018	struct hid_device *hid = usb_get_intfdata(intf);	1025	struct hid_device *hid = usb_get_intfdata(intf);
		1026	struct usbhid_device *usbhid;
1019		1027
1020	if (WARN_ON(!hid))	1028	if (WARN_ON(!hid))
1021	return;	1029	return;
1022		1030
		1031	usbhid = hid->driver_data;
1023	hid_destroy_device(hid);	1032	hid_destroy_device(hid);
		1033	kfree(usbhid);
1024	}	1034	}
1025		1035
1026	static int hid_suspend(struct usb_interface *intf, pm_message_t message)	1036	static int hid_suspend(struct usb_interface *intf, pm_message_t message)
Lines 1028-1038 static int hid_suspend(struct usb_interface *intf, pm_message_t message) Link Here
1028	struct hid_device *hid = usb_get_intfdata (intf);	1038	struct hid_device *hid = usb_get_intfdata (intf);
1029	struct usbhid_device *usbhid = hid->driver_data;	1039	struct usbhid_device *usbhid = hid->driver_data;
1030		1040
		1041	mutex_lock(&usbhid->setup);
		1042	if (!test_bit(HID_STARTED, &usbhid->iofl)) {
		1043	mutex_unlock(&usbhid->setup);
		1044	return 0;
		1045	}
		1046
1031	spin_lock_irq(&usbhid->inlock); /* Sync with error handler */	1047	spin_lock_irq(&usbhid->inlock); /* Sync with error handler */
1032	set_bit(HID_SUSPENDED, &usbhid->iofl);	1048	set_bit(HID_SUSPENDED, &usbhid->iofl);
1033	spin_unlock_irq(&usbhid->inlock);	1049	spin_unlock_irq(&usbhid->inlock);
1034	del_timer(&usbhid->io_retry);	1050	del_timer(&usbhid->io_retry);
1035	usb_kill_urb(usbhid->urbin);	1051	usb_kill_urb(usbhid->urbin);
		1052	mutex_unlock(&usbhid->setup);
1036	dev_dbg(&intf->dev, "suspend\n");	1053	dev_dbg(&intf->dev, "suspend\n");
1037	return 0;	1054	return 0;
1038	}	1055	}
Lines 1043-1051 static int hid_resume(struct usb_interface *intf) Link Here
1043	struct usbhid_device *usbhid = hid->driver_data;	1060	struct usbhid_device *usbhid = hid->driver_data;
1044	int status;	1061	int status;
1045		1062
		1063	mutex_lock(&usbhid->setup);
		1064	if (!test_bit(HID_STARTED, &usbhid->iofl)) {
		1065	mutex_unlock(&usbhid->setup);
		1066	return 0;
		1067	}
		1068
1046	clear_bit(HID_SUSPENDED, &usbhid->iofl);	1069	clear_bit(HID_SUSPENDED, &usbhid->iofl);
1047	usbhid->retry_delay = 0;	1070	usbhid->retry_delay = 0;
1048	status = hid_start_in(hid);	1071	status = hid_start_in(hid);
		1072	mutex_unlock(&usbhid->setup);
1049	dev_dbg(&intf->dev, "resume status %d\n", status);	1073	dev_dbg(&intf->dev, "resume status %d\n", status);
1050	return status;	1074	return status;
1051	}	1075	}