[deliverable/linux.git] / drivers / usb / gadget / legacy / hid.c

/*
 * hid.c -- HID Composite driver
 *
 * Based on multi.c
 *
 * Copyright (C) 2010 Fabien Chouteau <fabien.chouteau@barco.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */


#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/usb/composite.h>
#include <linux/usb/g_hid.h>

#define DRIVER_DESC		"HID Gadget"
#define DRIVER_VERSION		"2010/03/16"

#include "u_hid.h"

/*-------------------------------------------------------------------------*/

#define HIDG_VENDOR_NUM		0x0525	/* XXX NetChip */
#define HIDG_PRODUCT_NUM	0xa4ac	/* Linux-USB HID gadget */

/*-------------------------------------------------------------------------*/

struct hidg_func_node {
	struct usb_function_instance *fi;
	struct usb_function *f;
	struct list_head node;
	struct hidg_func_descriptor *func;
};

static LIST_HEAD(hidg_func_list);

/*-------------------------------------------------------------------------*/
USB_GADGET_COMPOSITE_OPTIONS();

static struct usb_device_descriptor device_desc = {
	.bLength =		sizeof device_desc,
	.bDescriptorType =	USB_DT_DEVICE,

	.bcdUSB =		cpu_to_le16(0x0200),

	/* .bDeviceClass =		USB_CLASS_COMM, */
	/* .bDeviceSubClass =	0, */
	/* .bDeviceProtocol =	0, */
	.bDeviceClass =		USB_CLASS_PER_INTERFACE,
	.bDeviceSubClass =	0,
	.bDeviceProtocol =	0,
	/* .bMaxPacketSize0 = f(hardware) */

	/* Vendor and product id can be overridden by module parameters.  */
	.idVendor =		cpu_to_le16(HIDG_VENDOR_NUM),
	.idProduct =		cpu_to_le16(HIDG_PRODUCT_NUM),
	/* .bcdDevice = f(hardware) */
	/* .iManufacturer = DYNAMIC */
	/* .iProduct = DYNAMIC */
	/* NO SERIAL NUMBER */
	.bNumConfigurations =	1,
};

static const struct usb_descriptor_header *otg_desc[2];

/* string IDs are assigned dynamically */
static struct usb_string strings_dev[] = {
	[USB_GADGET_MANUFACTURER_IDX].s = "",
	[USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
	[USB_GADGET_SERIAL_IDX].s = "",
	{  } /* end of list */
};

static struct usb_gadget_strings stringtab_dev = {
	.language	= 0x0409,	/* en-us */
	.strings	= strings_dev,
};

static struct usb_gadget_strings *dev_strings[] = {
	&stringtab_dev,
	NULL,
};


/****************************** Configurations ******************************/

static int do_config(struct usb_configuration *c)
{
	struct hidg_func_node *e, *n;
	int status = 0;

	if (gadget_is_otg(c->cdev->gadget)) {
		c->descriptors = otg_desc;
		c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
	}

	list_for_each_entry(e, &hidg_func_list, node) {
		e->f = usb_get_function(e->fi);
		if (IS_ERR(e->f))
			goto put;
		status = usb_add_function(c, e->f);
		if (status < 0) {
			usb_put_function(e->f);
			goto put;
		}
	}

	return 0;
put:
	list_for_each_entry(n, &hidg_func_list, node) {
		if (n == e)
			break;
		usb_remove_function(c, n->f);
		usb_put_function(n->f);
	}
	return status;
}

static struct usb_configuration config_driver = {
	.label			= "HID Gadget",
	.bConfigurationValue	= 1,
	/* .iConfiguration = DYNAMIC */
	.bmAttributes		= USB_CONFIG_ATT_SELFPOWER,
};

/****************************** Gadget Bind ******************************/

static int hid_bind(struct usb_composite_dev *cdev)
{
	struct usb_gadget *gadget = cdev->gadget;
	struct list_head *tmp;
	struct hidg_func_node *n, *m;
	struct f_hid_opts *hid_opts;
	int status, funcs = 0;

	list_for_each(tmp, &hidg_func_list)
		funcs++;

	if (!funcs)
		return -ENODEV;

	list_for_each_entry(n, &hidg_func_list, node) {
		n->fi = usb_get_function_instance("hid");
		if (IS_ERR(n->fi)) {
			status = PTR_ERR(n->fi);
			goto put;
		}
		hid_opts = container_of(n->fi, struct f_hid_opts, func_inst);
		hid_opts->subclass = n->func->subclass;
		hid_opts->protocol = n->func->protocol;
		hid_opts->report_length = n->func->report_length;
		hid_opts->report_desc_length = n->func->report_desc_length;
		hid_opts->report_desc = n->func->report_desc;
	}


	/* Allocate string descriptor numbers ... note that string
	 * contents can be overridden by the composite_dev glue.
	 */

	status = usb_string_ids_tab(cdev, strings_dev);
	if (status < 0)
		goto put;
	device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
	device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;

	if (gadget_is_otg(gadget) && !otg_desc[0]) {
		struct usb_descriptor_header *usb_desc;

		usb_desc = usb_otg_descriptor_alloc(gadget);
		if (!usb_desc)
			goto put;
		usb_otg_descriptor_init(gadget, usb_desc);
		otg_desc[0] = usb_desc;
		otg_desc[1] = NULL;
	}

	/* register our configuration */
	status = usb_add_config(cdev, &config_driver, do_config);
	if (status < 0)
		goto free_otg_desc;

	usb_composite_overwrite_options(cdev, &coverwrite);
	dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n");

	return 0;

free_otg_desc:
	kfree(otg_desc[0]);
	otg_desc[0] = NULL;
put:
	list_for_each_entry(m, &hidg_func_list, node) {
		if (m == n)
			break;
		usb_put_function_instance(m->fi);
	}
	return status;
}

static int hid_unbind(struct usb_composite_dev *cdev)
{
	struct hidg_func_node *n;

	list_for_each_entry(n, &hidg_func_list, node) {
		usb_put_function(n->f);
		usb_put_function_instance(n->fi);
	}

	kfree(otg_desc[0]);
	otg_desc[0] = NULL;

	return 0;
}

static int hidg_plat_driver_probe(struct platform_device *pdev)
{
	struct hidg_func_descriptor *func = dev_get_platdata(&pdev->dev);
	struct hidg_func_node *entry;

	if (!func) {
		dev_err(&pdev->dev, "Platform data missing\n");
		return -ENODEV;
	}

	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
	if (!entry)
		return -ENOMEM;

	entry->func = func;
	list_add_tail(&entry->node, &hidg_func_list);

	return 0;
}

static int hidg_plat_driver_remove(struct platform_device *pdev)
{
	struct hidg_func_node *e, *n;

	list_for_each_entry_safe(e, n, &hidg_func_list, node) {
		list_del(&e->node);
		kfree(e);
	}

	return 0;
}


/****************************** Some noise ******************************/


static struct usb_composite_driver hidg_driver = {
	.name		= "g_hid",
	.dev		= &device_desc,
	.strings	= dev_strings,
	.max_speed	= USB_SPEED_HIGH,
	.bind		= hid_bind,
	.unbind		= hid_unbind,
};

static struct platform_driver hidg_plat_driver = {
	.remove		= hidg_plat_driver_remove,
	.driver		= {
		.name	= "hidg",
	},
};


MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR("Fabien Chouteau, Peter Korsgaard");
MODULE_LICENSE("GPL");

static int __init hidg_init(void)
{
	int status;

	status = platform_driver_probe(&hidg_plat_driver,
				hidg_plat_driver_probe);
	if (status < 0)
		return status;

	status = usb_composite_probe(&hidg_driver);
	if (status < 0)
		platform_driver_unregister(&hidg_plat_driver);

	return status;
}
module_init(hidg_init);

static void __exit hidg_cleanup(void)
{
	usb_composite_unregister(&hidg_driver);
	platform_driver_unregister(&hidg_plat_driver);
}
module_exit(hidg_cleanup);
Commit	Line	Data
71adf118 FC	1	/*
	2	* hid.c -- HID Composite driver
	3	*
	4	* Based on multi.c
	5	*
	6	* Copyright (C) 2010 Fabien Chouteau <fabien.chouteau@barco.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
71adf118 FC	12	*/
	13
	14
	15	#include <linux/kernel.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/list.h>
721e2e91 SAS	18	#include <linux/module.h>
721e2e91 SAS	19	#include <linux/usb/composite.h>
4bc8a33f	20	#include <linux/usb/g_hid.h>
71adf118 FC	21
	22	#define DRIVER_DESC "HID Gadget"
	23	#define DRIVER_VERSION "2010/03/16"
	24
4bc8a33f AP	25	#include "u_hid.h"
4bc8a33f AP	26
71adf118 FC	27	/-------------------------------------------------------------------------/
	28
	29	#define HIDG_VENDOR_NUM 0x0525 /* XXX NetChip */
	30	#define HIDG_PRODUCT_NUM 0xa4ac /* Linux-USB HID gadget */
	31
	32	/-------------------------------------------------------------------------/
	33
71adf118	34	struct hidg_func_node {
4bc8a33f AP	35	struct usb_function_instance *fi;
4bc8a33f AP	36	struct usb_function *f;
71adf118 FC	37	struct list_head node;
	38	struct hidg_func_descriptor *func;
	39	};
	40
	41	static LIST_HEAD(hidg_func_list);
	42
	43	/-------------------------------------------------------------------------/
7d16e8d3	44	USB_GADGET_COMPOSITE_OPTIONS();
71adf118 FC	45
	46	static struct usb_device_descriptor device_desc = {
	47	.bLength = sizeof device_desc,
	48	.bDescriptorType = USB_DT_DEVICE,
	49
	50	.bcdUSB = cpu_to_le16(0x0200),
	51
	52	/* .bDeviceClass = USB_CLASS_COMM, */
	53	/* .bDeviceSubClass = 0, */
	54	/* .bDeviceProtocol = 0, */
33d2832a OF	55	.bDeviceClass = USB_CLASS_PER_INTERFACE,
	56	.bDeviceSubClass = 0,
	57	.bDeviceProtocol = 0,
71adf118 FC	58	/* .bMaxPacketSize0 = f(hardware) */
	59
	60	/* Vendor and product id can be overridden by module parameters. */
	61	.idVendor = cpu_to_le16(HIDG_VENDOR_NUM),
	62	.idProduct = cpu_to_le16(HIDG_PRODUCT_NUM),
	63	/* .bcdDevice = f(hardware) */
	64	/* .iManufacturer = DYNAMIC */
	65	/* .iProduct = DYNAMIC */
	66	/* NO SERIAL NUMBER */
	67	.bNumConfigurations = 1,
	68	};
	69
d9e18679	70	static const struct usb_descriptor_header *otg_desc[2];
71adf118 FC	71
71adf118 FC	72	/* string IDs are assigned dynamically */
71adf118	73	static struct usb_string strings_dev[] = {
cc2683c3	74	[USB_GADGET_MANUFACTURER_IDX].s = "",
276e2e4f SAS	75	[USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
276e2e4f SAS	76	[USB_GADGET_SERIAL_IDX].s = "",
71adf118 FC	77	{ } /* end of list */
	78	};
	79
	80	static struct usb_gadget_strings stringtab_dev = {
	81	.language = 0x0409, /* en-us */
	82	.strings = strings_dev,
	83	};
	84
	85	static struct usb_gadget_strings *dev_strings[] = {
	86	&stringtab_dev,
	87	NULL,
	88	};
	89
	90
	91
	92	/**************************** Configurations ****************************/
	93
c94e289f	94	static int do_config(struct usb_configuration *c)
71adf118	95	{
4bc8a33f AP	96	struct hidg_func_node e, n;
4bc8a33f AP	97	int status = 0;
71adf118 FC	98
	99	if (gadget_is_otg(c->cdev->gadget)) {
	100	c->descriptors = otg_desc;
	101	c->bmAttributes \|= USB_CONFIG_ATT_WAKEUP;
	102	}
	103
	104	list_for_each_entry(e, &hidg_func_list, node) {
4bc8a33f AP	105	e->f = usb_get_function(e->fi);
	106	if (IS_ERR(e->f))
	107	goto put;
	108	status = usb_add_function(c, e->f);
	109	if (status < 0) {
	110	usb_put_function(e->f);
	111	goto put;
	112	}
71adf118 FC	113	}
71adf118 FC	114
4bc8a33f AP	115	return 0;
	116	put:
	117	list_for_each_entry(n, &hidg_func_list, node) {
	118	if (n == e)
	119	break;
	120	usb_remove_function(c, n->f);
	121	usb_put_function(n->f);
	122	}
71adf118 FC	123	return status;
	124	}
	125
	126	static struct usb_configuration config_driver = {
	127	.label = "HID Gadget",
71adf118 FC	128	.bConfigurationValue = 1,
	129	/* .iConfiguration = DYNAMIC */
	130	.bmAttributes = USB_CONFIG_ATT_SELFPOWER,
	131	};
	132
	133	/**************************** Gadget Bind ****************************/
	134
c94e289f	135	static int hid_bind(struct usb_composite_dev *cdev)
71adf118 FC	136	{
	137	struct usb_gadget *gadget = cdev->gadget;
	138	struct list_head *tmp;
4bc8a33f AP	139	struct hidg_func_node n, m;
4bc8a33f AP	140	struct f_hid_opts *hid_opts;
ed9cbda6	141	int status, funcs = 0;
71adf118 FC	142
	143	list_for_each(tmp, &hidg_func_list)
	144	funcs++;
	145
	146	if (!funcs)
	147	return -ENODEV;
	148
4bc8a33f AP	149	list_for_each_entry(n, &hidg_func_list, node) {
	150	n->fi = usb_get_function_instance("hid");
	151	if (IS_ERR(n->fi)) {
	152	status = PTR_ERR(n->fi);
	153	goto put;
	154	}
	155	hid_opts = container_of(n->fi, struct f_hid_opts, func_inst);
	156	hid_opts->subclass = n->func->subclass;
	157	hid_opts->protocol = n->func->protocol;
	158	hid_opts->report_length = n->func->report_length;
	159	hid_opts->report_desc_length = n->func->report_desc_length;
	160	hid_opts->report_desc = n->func->report_desc;
	161	}
	162
71adf118	163
71adf118 FC	164	/* Allocate string descriptor numbers ... note that string
	165	* contents can be overridden by the composite_dev glue.
	166	*/
	167
e1f15ccb	168	status = usb_string_ids_tab(cdev, strings_dev);
71adf118	169	if (status < 0)
4bc8a33f	170	goto put;
276e2e4f SAS	171	device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
276e2e4f SAS	172	device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
71adf118	173
d9e18679 LJ	174	if (gadget_is_otg(gadget) && !otg_desc[0]) {
	175	struct usb_descriptor_header *usb_desc;
	176
	177	usb_desc = usb_otg_descriptor_alloc(gadget);
	178	if (!usb_desc)
	179	goto put;
	180	usb_otg_descriptor_init(gadget, usb_desc);
	181	otg_desc[0] = usb_desc;
	182	otg_desc[1] = NULL;
	183	}
	184
71adf118	185	/* register our configuration */
c9bfff9c	186	status = usb_add_config(cdev, &config_driver, do_config);
71adf118	187	if (status < 0)
d9e18679	188	goto free_otg_desc;
71adf118	189
7d16e8d3	190	usb_composite_overwrite_options(cdev, &coverwrite);
71adf118 FC	191	dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
	192
	193	return 0;
4bc8a33f	194
d9e18679 LJ	195	free_otg_desc:
	196	kfree(otg_desc[0]);
	197	otg_desc[0] = NULL;
4bc8a33f AP	198	put:
	199	list_for_each_entry(m, &hidg_func_list, node) {
	200	if (m == n)
	201	break;
	202	usb_put_function_instance(m->fi);
	203	}
	204	return status;
71adf118 FC	205	}
71adf118 FC	206
c94e289f	207	static int hid_unbind(struct usb_composite_dev *cdev)
71adf118	208	{
4bc8a33f AP	209	struct hidg_func_node *n;
	210
	211	list_for_each_entry(n, &hidg_func_list, node) {
	212	usb_put_function(n->f);
	213	usb_put_function_instance(n->fi);
	214	}
d9e18679 LJ	215
	216	kfree(otg_desc[0]);
	217	otg_desc[0] = NULL;
	218
71adf118 FC	219	return 0;
	220	}
	221
c94e289f	222	static int hidg_plat_driver_probe(struct platform_device *pdev)
71adf118	223	{
e01ee9f5	224	struct hidg_func_descriptor *func = dev_get_platdata(&pdev->dev);
71adf118 FC	225	struct hidg_func_node *entry;
	226
	227	if (!func) {
	228	dev_err(&pdev->dev, "Platform data missing\n");
	229	return -ENODEV;
	230	}
	231
	232	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
	233	if (!entry)
	234	return -ENOMEM;
	235
	236	entry->func = func;
	237	list_add_tail(&entry->node, &hidg_func_list);
	238
	239	return 0;
	240	}
	241
fb4e98ab	242	static int hidg_plat_driver_remove(struct platform_device *pdev)
71adf118 FC	243	{
	244	struct hidg_func_node e, n;
	245
	246	list_for_each_entry_safe(e, n, &hidg_func_list, node) {
	247	list_del(&e->node);
	248	kfree(e);
	249	}
	250
	251	return 0;
	252	}
	253
	254
	255	/**************************** Some noise ****************************/
	256
	257
c94e289f	258	static struct usb_composite_driver hidg_driver = {
71adf118 FC	259	.name = "g_hid",
	260	.dev = &device_desc,
	261	.strings = dev_strings,
35a0e0bf	262	.max_speed = USB_SPEED_HIGH,
03e42bd5	263	.bind = hid_bind,
c94e289f	264	.unbind = hid_unbind,
71adf118 FC	265	};
	266
	267	static struct platform_driver hidg_plat_driver = {
7690417d	268	.remove = hidg_plat_driver_remove,
71adf118	269	.driver = {
71adf118 FC	270	.name = "hidg",
	271	},
	272	};
	273
	274
	275	MODULE_DESCRIPTION(DRIVER_DESC);
	276	MODULE_AUTHOR("Fabien Chouteau, Peter Korsgaard");
	277	MODULE_LICENSE("GPL");
	278
	279	static int __init hidg_init(void)
	280	{
da01c7a4 PK	281	int status;
	282
	283	status = platform_driver_probe(&hidg_plat_driver,
	284	hidg_plat_driver_probe);
	285	if (status < 0)
	286	return status;
	287
03e42bd5	288	status = usb_composite_probe(&hidg_driver);
da01c7a4 PK	289	if (status < 0)
	290	platform_driver_unregister(&hidg_plat_driver);
	291
	292	return status;
71adf118 FC	293	}
	294	module_init(hidg_init);
	295
	296	static void __exit hidg_cleanup(void)
	297	{
71adf118	298	usb_composite_unregister(&hidg_driver);
00896f66	299	platform_driver_unregister(&hidg_plat_driver);
71adf118 FC	300	}
71adf118 FC	301	module_exit(hidg_cleanup);