multi.c 8.18 KB
Newer Older
1
2
3
4
5
6
/*
 * multi.c -- Multifunction Composite driver
 *
 * Copyright (C) 2008 David Brownell
 * Copyright (C) 2008 Nokia Corporation
 * Copyright (C) 2009 Samsung Electronics
7
 * Author: Michal Nazarewicz (mina86@mina86.com)
8
9
10
11
12
13
14
15
16
 *
 * 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>
17
#include <linux/module.h>
18

19
#include "u_serial.h"
20
21
22
#if defined USB_ETH_RNDIS
#  undef USB_ETH_RNDIS
#endif
23
#ifdef CONFIG_USB_G_MULTI_RNDIS
24
#  define USB_ETH_RNDIS y
25
26
27
28
29
#endif


#define DRIVER_DESC		"Multifunction Composite Gadget"

30
31
32
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR("Michal Nazarewicz");
MODULE_LICENSE("GPL");
33
34


35
/***************************** All the files... *****************************/
36
37
38
39
40
41
42
43

/*
 * 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.
 */
44
#include "f_mass_storage.c"
45
46
47

#include "f_ecm.c"
#include "f_subset.c"
48
#ifdef USB_ETH_RNDIS
49
50
51
52
53
#  include "f_rndis.c"
#  include "rndis.c"
#endif
#include "u_ether.c"

54
USB_GADGET_COMPOSITE_OPTIONS();
55
56
57

/***************************** Device Descriptor ****************************/

58
59
#define MULTI_VENDOR_NUM	0x1d6b	/* Linux Foundation */
#define MULTI_PRODUCT_NUM	0x0104	/* Multifunction Composite Gadget */
60
61
62
63
64
65
66
67
68
69
70
71


enum {
	__MULTI_NO_CONFIG,
#ifdef CONFIG_USB_G_MULTI_RNDIS
	MULTI_RNDIS_CONFIG_NUM,
#endif
#ifdef CONFIG_USB_G_MULTI_CDC
	MULTI_CDC_CONFIG_NUM,
#endif
};

72
73
74
75
76
77
78

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

	.bcdUSB =		cpu_to_le16(0x0200),

79
	.bDeviceClass =		USB_CLASS_MISC /* 0xEF */,
80
81
82
83
84
85
86
87
88
89
	.bDeviceSubClass =	2,
	.bDeviceProtocol =	1,

	/* Vendor and product id can be overridden by module parameters.  */
	.idVendor =		cpu_to_le16(MULTI_VENDOR_NUM),
	.idProduct =		cpu_to_le16(MULTI_PRODUCT_NUM),
};


static const struct usb_descriptor_header *otg_desc[] = {
90
91
92
93
94
95
96
97
98
99
	(struct usb_descriptor_header *) &(struct usb_otg_descriptor){
		.bLength =		sizeof(struct usb_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,
	},
100
101
102
103
	NULL,
};


104
enum {
105
	MULTI_STRING_RNDIS_CONFIG_IDX = USB_GADGET_FIRST_AVAIL_IDX,
106
107
	MULTI_STRING_CDC_CONFIG_IDX,
};
108
109

static struct usb_string strings_dev[] = {
110
	[USB_GADGET_MANUFACTURER_IDX].s = "",
111
	[USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
112
	[USB_GADGET_SERIAL_IDX].s = "",
113
114
	[MULTI_STRING_RNDIS_CONFIG_IDX].s = "Multifunction with RNDIS",
	[MULTI_STRING_CDC_CONFIG_IDX].s   = "Multifunction with CDC ECM",
115
116
117
118
	{  } /* end of list */
};

static struct usb_gadget_strings *dev_strings[] = {
119
120
121
122
	&(struct usb_gadget_strings){
		.language	= 0x0409,	/* en-us */
		.strings	= strings_dev,
	},
123
124
125
126
127
128
129
130
	NULL,
};




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

131
132
133
134
135
136
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 u8 hostaddr[ETH_ALEN];
137

138
static struct usb_function_instance *fi_acm;
139
static struct eth_dev *the_dev;
140

141
/********** RNDIS **********/
142

143
#ifdef USB_ETH_RNDIS
144
static struct usb_function *f_acm_rndis;
145

146
static __init int rndis_do_config(struct usb_configuration *c)
147
148
149
150
151
152
153
154
{
	int ret;

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

155
	ret = rndis_bind_config(c, hostaddr, the_dev);
156
157
158
	if (ret < 0)
		return ret;

159
	f_acm_rndis = usb_get_function(fi_acm);
160
161
	if (IS_ERR(f_acm_rndis)) {
		ret = PTR_ERR(f_acm_rndis);
162
		goto err_func_acm;
163
	}
164
165
166
167

	ret = usb_add_function(c, f_acm_rndis);
	if (ret)
		goto err_conf;
168

169
	ret = fsg_bind_config(c->cdev, c, &fsg_common);
170
	if (ret < 0)
171
		goto err_fsg;
172
173

	return 0;
174
175
176
177
178
179
err_fsg:
	usb_remove_function(c, f_acm_rndis);
err_conf:
	usb_put_function(f_acm_rndis);
err_func_acm:
	return ret;
180
181
}

182
183
184
185
186
187
188
189
190
191
static int rndis_config_register(struct usb_composite_dev *cdev)
{
	static struct usb_configuration config = {
		.bConfigurationValue	= MULTI_RNDIS_CONFIG_NUM,
		.bmAttributes		= USB_CONFIG_ATT_SELFPOWER,
	};

	config.label          = strings_dev[MULTI_STRING_RNDIS_CONFIG_IDX].s;
	config.iConfiguration = strings_dev[MULTI_STRING_RNDIS_CONFIG_IDX].id;

192
	return usb_add_config(cdev, &config, rndis_do_config);
193
194
195
196
197
198
199
200
}

#else

static int rndis_config_register(struct usb_composite_dev *cdev)
{
	return 0;
}
201
202
203

#endif

204
205
206

/********** CDC ECM **********/

207
#ifdef CONFIG_USB_G_MULTI_CDC
208
static struct usb_function *f_acm_multi;
209

210
static __init int cdc_do_config(struct usb_configuration *c)
211
212
213
214
215
216
217
218
{
	int ret;

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

219
	ret = ecm_bind_config(c, hostaddr, the_dev);
220
221
222
	if (ret < 0)
		return ret;

223
224
225
226
227
228
229
230
	/* implicit port_num is zero */
	f_acm_multi = usb_get_function(fi_acm);
	if (IS_ERR(f_acm_multi))
		goto err_func_acm;

	ret = usb_add_function(c, f_acm_multi);
	if (ret)
		goto err_conf;
231

232
	ret = fsg_bind_config(c->cdev, c, &fsg_common);
233
	if (ret < 0)
234
		goto err_fsg;
235
236

	return 0;
237
238
239
240
241
242
err_fsg:
	usb_remove_function(c, f_acm_multi);
err_conf:
	usb_put_function(f_acm_multi);
err_func_acm:
	return ret;
243
244
}

245
246
247
248
249
250
251
252
253
254
static int cdc_config_register(struct usb_composite_dev *cdev)
{
	static struct usb_configuration config = {
		.bConfigurationValue	= MULTI_CDC_CONFIG_NUM,
		.bmAttributes		= USB_CONFIG_ATT_SELFPOWER,
	};

	config.label          = strings_dev[MULTI_STRING_CDC_CONFIG_IDX].s;
	config.iConfiguration = strings_dev[MULTI_STRING_CDC_CONFIG_IDX].id;

255
	return usb_add_config(cdev, &config, cdc_do_config);
256
257
258
259
260
261
262
263
}

#else

static int cdc_config_register(struct usb_composite_dev *cdev)
{
	return 0;
}
264
265
266
267
268
269
270

#endif



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

271
static int __ref multi_bind(struct usb_composite_dev *cdev)
272
273
{
	struct usb_gadget *gadget = cdev->gadget;
274
	int status;
275
276
277
278
279
280
281
282

	if (!can_support_ecm(cdev->gadget)) {
		dev_err(&gadget->dev, "controller '%s' not usable\n",
		        gadget->name);
		return -EINVAL;
	}

	/* set up network link layer */
283
284
285
	the_dev = gether_setup(cdev->gadget, hostaddr);
	if (IS_ERR(the_dev))
		return PTR_ERR(the_dev);
286
287

	/* set up serial link layer */
288
289
290
	fi_acm = usb_get_function_instance("acm");
	if (IS_ERR(fi_acm)) {
		status = PTR_ERR(fi_acm);
291
		goto fail0;
292
293
	}

294
	/* set up mass storage function */
295
296
297
298
299
300
301
	{
		void *retp;
		retp = fsg_common_from_params(&fsg_common, cdev, &fsg_mod_data);
		if (IS_ERR(retp)) {
			status = PTR_ERR(retp);
			goto fail1;
		}
302
303
	}

304
	/* allocate string IDs */
305
306
	status = usb_string_ids_tab(cdev, strings_dev);
	if (unlikely(status < 0))
307
		goto fail2;
308
	device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
309

310
311
312
	/* register configurations */
	status = rndis_config_register(cdev);
	if (unlikely(status < 0))
313
314
		goto fail2;

315
316
	status = cdc_config_register(cdev);
	if (unlikely(status < 0))
317
		goto fail2;
318
	usb_composite_overwrite_options(cdev, &coverwrite);
319

320
321
322
	/* we're done */
	dev_info(&gadget->dev, DRIVER_DESC "\n");
	fsg_common_put(&fsg_common);
323
324
	return 0;

325
326

	/* error recovery */
327
fail2:
328
	fsg_common_put(&fsg_common);
329
fail1:
330
	usb_put_function_instance(fi_acm);
331
fail0:
332
	gether_cleanup(the_dev);
333
334
335
336
337
	return status;
}

static int __exit multi_unbind(struct usb_composite_dev *cdev)
{
338
339
340
341
342
343
344
#ifdef CONFIG_USB_G_MULTI_CDC
	usb_put_function(f_acm_multi);
#endif
#ifdef USB_ETH_RNDIS
	usb_put_function(f_acm_rndis);
#endif
	usb_put_function_instance(fi_acm);
345
	gether_cleanup(the_dev);
346
347
348
349
350
351
352
	return 0;
}


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


353
static __refdata struct usb_composite_driver multi_driver = {
354
355
356
	.name		= "g_multi",
	.dev		= &device_desc,
	.strings	= dev_strings,
357
	.max_speed	= USB_SPEED_HIGH,
358
	.bind		= multi_bind,
359
	.unbind		= __exit_p(multi_unbind),
360
	.needs_serial	= 1,
361
362
363
};


364
static int __init multi_init(void)
365
{
366
	return usb_composite_probe(&multi_driver);
367
}
368
module_init(multi_init);
369

370
static void __exit multi_exit(void)
371
372
373
{
	usb_composite_unregister(&multi_driver);
}
374
module_exit(multi_exit);