[deliverable/linux.git] / drivers / usb / gadget / acm_ms.c

/*
 * acm_ms.c -- Composite driver, with ACM and mass storage support
 *
 * Copyright (C) 2008 David Brownell
 * Copyright (C) 2008 Nokia Corporation
 * Author: David Brownell
 * Modified: Klaus Schwarzkopf <schwarzkopf@sensortherm.de>
 *
 * Heavily based on multi.c and cdc2.c
 *
 * 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/module.h>

#include "u_serial.h"

#define DRIVER_DESC		"Composite Gadget (ACM + MS)"
#define DRIVER_VERSION		"2011/10/10"

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

/*
 * DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
 * Instead:  allocate your own, using normal USB-IF procedures.
 */
#define ACM_MS_VENDOR_NUM	0x1d6b	/* Linux Foundation */
#define ACM_MS_PRODUCT_NUM	0x0106	/* Composite Gadget: ACM + MS*/

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

/*
 * Kbuild is not very cooperative with respect to linking separately
 * compiled library objects into one module.  So for now we won't use
 * separate compilation ... ensuring init/exit sections work to shrink
 * the runtime footprint, and giving us at least some parts of what
 * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
 */
#include "f_mass_storage.c"

/*-------------------------------------------------------------------------*/
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_MISC /* 0xEF */,
	.bDeviceSubClass =	2,
	.bDeviceProtocol =	1,

	/* .bMaxPacketSize0 = f(hardware) */

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

static struct usb_otg_descriptor otg_descriptor = {
	.bLength =		sizeof otg_descriptor,
	.bDescriptorType =	USB_DT_OTG,

	/*
	 * REVISIT SRP-only hardware is possible, although
	 * it would not be called "OTG" ...
	 */
	.bmAttributes =		USB_OTG_SRP | USB_OTG_HNP,
};

static const struct usb_descriptor_header *otg_desc[] = {
	(struct usb_descriptor_header *) &otg_descriptor,
	NULL,
};

/* 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 struct fsg_module_parameters fsg_mod_data = { .stall = 1 };
FSG_MODULE_PARAMETERS(/* no prefix */, fsg_mod_data);

static struct fsg_common fsg_common;

/*-------------------------------------------------------------------------*/
static unsigned char tty_line;
static struct usb_function *f_acm;
static struct usb_function_instance *f_acm_inst;
/*
 * We _always_ have both ACM and mass storage functions.
 */
static int __init acm_ms_do_config(struct usb_configuration *c)
{
	struct f_serial_opts *opts;
	int	status;

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

	f_acm_inst = usb_get_function_instance("acm");
	if (IS_ERR(f_acm_inst))
		return PTR_ERR(f_acm_inst);

	opts = container_of(f_acm_inst, struct f_serial_opts, func_inst);
	opts->port_num = tty_line;

	f_acm = usb_get_function(f_acm_inst);
	if (IS_ERR(f_acm)) {
		status = PTR_ERR(f_acm);
		goto err_func;
	}

	status = usb_add_function(c, f_acm);
	if (status < 0)
		goto err_conf;

	status = fsg_bind_config(c->cdev, c, &fsg_common);
	if (status < 0)
		goto err_fsg;

	return 0;
err_fsg:
	usb_remove_function(c, f_acm);
err_conf:
	usb_put_function(f_acm);
err_func:
	usb_put_function_instance(f_acm_inst);
	return status;
}

static struct usb_configuration acm_ms_config_driver = {
	.label			= DRIVER_DESC,
	.bConfigurationValue	= 1,
	/* .iConfiguration = DYNAMIC */
	.bmAttributes		= USB_CONFIG_ATT_SELFPOWER,
};

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

static int __init acm_ms_bind(struct usb_composite_dev *cdev)
{
	struct usb_gadget	*gadget = cdev->gadget;
	int			status;
	void			*retp;

	/* set up serial link layer */
	status = gserial_alloc_line(&tty_line);
	if (status < 0)
		return status;

	/* set up mass storage function */
	retp = fsg_common_from_params(&fsg_common, cdev, &fsg_mod_data);
	if (IS_ERR(retp)) {
		status = PTR_ERR(retp);
		goto fail0;
	}

	/*
	 * 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 fail1;
	device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
	device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;

	/* register our configuration */
	status = usb_add_config(cdev, &acm_ms_config_driver, acm_ms_do_config);
	if (status < 0)
		goto fail1;

	usb_composite_overwrite_options(cdev, &coverwrite);
	dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n",
			DRIVER_DESC);
	fsg_common_put(&fsg_common);
	return 0;

	/* error recovery */
fail1:
	fsg_common_put(&fsg_common);
fail0:
	gserial_free_line(tty_line);
	return status;
}

static int __exit acm_ms_unbind(struct usb_composite_dev *cdev)
{
	usb_put_function(f_acm);
	usb_put_function_instance(f_acm_inst);
	gserial_free_line(tty_line);
	return 0;
}

static __refdata struct usb_composite_driver acm_ms_driver = {
	.name		= "g_acm_ms",
	.dev		= &device_desc,
	.max_speed	= USB_SPEED_SUPER,
	.strings	= dev_strings,
	.bind		= acm_ms_bind,
	.unbind		= __exit_p(acm_ms_unbind),
};

MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR("Klaus Schwarzkopf <schwarzkopf@sensortherm.de>");
MODULE_LICENSE("GPL v2");

static int __init init(void)
{
	return usb_composite_probe(&acm_ms_driver);
}
module_init(init);

static void __exit cleanup(void)
{
	usb_composite_unregister(&acm_ms_driver);
}
module_exit(cleanup);
Commit	Line	Data
fa3ae0c1 KS	1	/*
	2	* acm_ms.c -- Composite driver, with ACM and mass storage support
	3	*
	4	* Copyright (C) 2008 David Brownell
	5	* Copyright (C) 2008 Nokia Corporation
	6	* Author: David Brownell
	7	* Modified: Klaus Schwarzkopf <schwarzkopf@sensortherm.de>
	8	*
	9	* Heavily based on multi.c and cdc2.c
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
	13	* the Free Software Foundation; either version 2 of the License, or
	14	* (at your option) any later version.
	15	*/
	16
	17	#include <linux/kernel.h>
721e2e91	18	#include <linux/module.h>
fa3ae0c1 KS	19
	20	#include "u_serial.h"
	21
	22	#define DRIVER_DESC "Composite Gadget (ACM + MS)"
	23	#define DRIVER_VERSION "2011/10/10"
	24
	25	/-------------------------------------------------------------------------/
	26
	27	/*
	28	* DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
	29	* Instead: allocate your own, using normal USB-IF procedures.
	30	*/
	31	#define ACM_MS_VENDOR_NUM 0x1d6b /* Linux Foundation */
	32	#define ACM_MS_PRODUCT_NUM 0x0106 /* Composite Gadget: ACM + MS*/
	33
	34	/-------------------------------------------------------------------------/
	35
	36	/*
	37	* Kbuild is not very cooperative with respect to linking separately
	38	* compiled library objects into one module. So for now we won't use
	39	* separate compilation ... ensuring init/exit sections work to shrink
	40	* the runtime footprint, and giving us at least some parts of what
	41	* a "gcc --combine ... part1.c part2.c part3.c ... " build would.
	42	*/
fa3ae0c1 KS	43	#include "f_mass_storage.c"
	44
	45	/-------------------------------------------------------------------------/
7d16e8d3	46	USB_GADGET_COMPOSITE_OPTIONS();
fa3ae0c1 KS	47
	48	static struct usb_device_descriptor device_desc = {
	49	.bLength = sizeof device_desc,
	50	.bDescriptorType = USB_DT_DEVICE,
	51
	52	.bcdUSB = cpu_to_le16(0x0200),
	53
	54	.bDeviceClass = USB_CLASS_MISC /* 0xEF */,
	55	.bDeviceSubClass = 2,
	56	.bDeviceProtocol = 1,
	57
	58	/* .bMaxPacketSize0 = f(hardware) */
	59
	60	/* Vendor and product id can be overridden by module parameters. */
	61	.idVendor = cpu_to_le16(ACM_MS_VENDOR_NUM),
	62	.idProduct = cpu_to_le16(ACM_MS_PRODUCT_NUM),
	63	/* .bcdDevice = f(hardware) */
	64	/* .iManufacturer = DYNAMIC */
	65	/* .iProduct = DYNAMIC */
	66	/* NO SERIAL NUMBER */
	67	/.bNumConfigurations = DYNAMIC/
	68	};
	69
	70	static struct usb_otg_descriptor otg_descriptor = {
	71	.bLength = sizeof otg_descriptor,
	72	.bDescriptorType = USB_DT_OTG,
	73
	74	/*
	75	* REVISIT SRP-only hardware is possible, although
	76	* it would not be called "OTG" ...
	77	*/
	78	.bmAttributes = USB_OTG_SRP \| USB_OTG_HNP,
	79	};
	80
	81	static const struct usb_descriptor_header *otg_desc[] = {
	82	(struct usb_descriptor_header *) &otg_descriptor,
	83	NULL,
	84	};
	85
fa3ae0c1	86	/* string IDs are assigned dynamically */
fa3ae0c1	87	static struct usb_string strings_dev[] = {
cc2683c3	88	[USB_GADGET_MANUFACTURER_IDX].s = "",
276e2e4f SAS	89	[USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
276e2e4f SAS	90	[USB_GADGET_SERIAL_IDX].s = "",
fa3ae0c1 KS	91	{ } /* end of list */
	92	};
	93
	94	static struct usb_gadget_strings stringtab_dev = {
	95	.language = 0x0409, /* en-us */
	96	.strings = strings_dev,
	97	};
	98
	99	static struct usb_gadget_strings *dev_strings[] = {
	100	&stringtab_dev,
	101	NULL,
	102	};
	103
	104	/**************************** Configurations ****************************/
	105
	106	static struct fsg_module_parameters fsg_mod_data = { .stall = 1 };
	107	FSG_MODULE_PARAMETERS(/* no prefix */, fsg_mod_data);
	108
	109	static struct fsg_common fsg_common;
	110
	111	/-------------------------------------------------------------------------/
19b10a88	112	static unsigned char tty_line;
5f72bbfd SAS	113	static struct usb_function *f_acm;
5f72bbfd SAS	114	static struct usb_function_instance *f_acm_inst;
fa3ae0c1 KS	115	/*
	116	* We _always_ have both ACM and mass storage functions.
	117	*/
	118	static int __init acm_ms_do_config(struct usb_configuration *c)
	119	{
5f72bbfd	120	struct f_serial_opts *opts;
fa3ae0c1 KS	121	int status;
	122
	123	if (gadget_is_otg(c->cdev->gadget)) {
	124	c->descriptors = otg_desc;
	125	c->bmAttributes \|= USB_CONFIG_ATT_WAKEUP;
	126	}
	127
5f72bbfd SAS	128	f_acm_inst = usb_get_function_instance("acm");
	129	if (IS_ERR(f_acm_inst))
	130	return PTR_ERR(f_acm_inst);
	131
	132	opts = container_of(f_acm_inst, struct f_serial_opts, func_inst);
	133	opts->port_num = tty_line;
	134
	135	f_acm = usb_get_function(f_acm_inst);
	136	if (IS_ERR(f_acm)) {
	137	status = PTR_ERR(f_acm);
	138	goto err_func;
	139	}
fa3ae0c1	140
5f72bbfd	141	status = usb_add_function(c, f_acm);
fa3ae0c1	142	if (status < 0)
5f72bbfd	143	goto err_conf;
fa3ae0c1 KS	144
	145	status = fsg_bind_config(c->cdev, c, &fsg_common);
	146	if (status < 0)
5f72bbfd	147	goto err_fsg;
fa3ae0c1 KS	148
fa3ae0c1 KS	149	return 0;
5f72bbfd SAS	150	err_fsg:
	151	usb_remove_function(c, f_acm);
	152	err_conf:
	153	usb_put_function(f_acm);
	154	err_func:
	155	usb_put_function_instance(f_acm_inst);
	156	return status;
fa3ae0c1 KS	157	}
	158
	159	static struct usb_configuration acm_ms_config_driver = {
	160	.label = DRIVER_DESC,
	161	.bConfigurationValue = 1,
	162	/* .iConfiguration = DYNAMIC */
	163	.bmAttributes = USB_CONFIG_ATT_SELFPOWER,
	164	};
	165
	166	/-------------------------------------------------------------------------/
	167
	168	static int __init acm_ms_bind(struct usb_composite_dev *cdev)
	169	{
fa3ae0c1 KS	170	struct usb_gadget *gadget = cdev->gadget;
	171	int status;
	172	void *retp;
	173
	174	/* set up serial link layer */
19b10a88	175	status = gserial_alloc_line(&tty_line);
fa3ae0c1 KS	176	if (status < 0)
	177	return status;
	178
	179	/* set up mass storage function */
	180	retp = fsg_common_from_params(&fsg_common, cdev, &fsg_mod_data);
	181	if (IS_ERR(retp)) {
	182	status = PTR_ERR(retp);
	183	goto fail0;
	184	}
	185
fa3ae0c1 KS	186	/*
	187	* Allocate string descriptor numbers ... note that string
	188	* contents can be overridden by the composite_dev glue.
	189	*/
e1f15ccb	190	status = usb_string_ids_tab(cdev, strings_dev);
fa3ae0c1 KS	191	if (status < 0)
fa3ae0c1 KS	192	goto fail1;
276e2e4f SAS	193	device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
276e2e4f SAS	194	device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
fa3ae0c1 KS	195
	196	/* register our configuration */
	197	status = usb_add_config(cdev, &acm_ms_config_driver, acm_ms_do_config);
	198	if (status < 0)
	199	goto fail1;
	200
7d16e8d3	201	usb_composite_overwrite_options(cdev, &coverwrite);
fa3ae0c1 KS	202	dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n",
	203	DRIVER_DESC);
	204	fsg_common_put(&fsg_common);
	205	return 0;
	206
	207	/* error recovery */
	208	fail1:
	209	fsg_common_put(&fsg_common);
	210	fail0:
19b10a88	211	gserial_free_line(tty_line);
fa3ae0c1 KS	212	return status;
	213	}
	214
	215	static int __exit acm_ms_unbind(struct usb_composite_dev *cdev)
	216	{
5f72bbfd SAS	217	usb_put_function(f_acm);
5f72bbfd SAS	218	usb_put_function_instance(f_acm_inst);
19b10a88	219	gserial_free_line(tty_line);
fa3ae0c1 KS	220	return 0;
	221	}
	222
c2ec75c2	223	static __refdata struct usb_composite_driver acm_ms_driver = {
fa3ae0c1 KS	224	.name = "g_acm_ms",
fa3ae0c1 KS	225	.dev = &device_desc,
6f47209b	226	.max_speed = USB_SPEED_SUPER,
fa3ae0c1	227	.strings = dev_strings,
03e42bd5	228	.bind = acm_ms_bind,
fa3ae0c1 KS	229	.unbind = __exit_p(acm_ms_unbind),
	230	};
	231
	232	MODULE_DESCRIPTION(DRIVER_DESC);
	233	MODULE_AUTHOR("Klaus Schwarzkopf <schwarzkopf@sensortherm.de>");
	234	MODULE_LICENSE("GPL v2");
	235
	236	static int __init init(void)
	237	{
03e42bd5	238	return usb_composite_probe(&acm_ms_driver);
fa3ae0c1 KS	239	}
	240	module_init(init);
	241
	242	static void __exit cleanup(void)
	243	{
	244	usb_composite_unregister(&acm_ms_driver);
	245	}
	246	module_exit(cleanup);