2 * g_ffs.c -- user mode file system API for USB composite function controllers
4 * Copyright (C) 2010 Samsung Electronics
5 * Author: Michal Nazarewicz <mina86@mina86.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
13 #define pr_fmt(fmt) "g_ffs: " fmt
15 #include <linux/module.h>
16 #include <linux/utsname.h>
19 * kbuild is not very cooperative with respect to linking separately
20 * compiled library objects into one module. So for now we won't use
21 * separate compilation ... ensuring init/exit sections work to shrink
22 * the runtime footprint, and giving us at least some parts of what
23 * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
26 #include "composite.c"
27 #include "usbstring.c"
29 #include "epautoconf.c"
31 #if defined CONFIG_USB_FUNCTIONFS_ETH || defined CONFIG_USB_FUNCTIONFS_RNDIS
32 # if defined USB_ETH_RNDIS
35 # ifdef CONFIG_USB_FUNCTIONFS_RNDIS
36 # define USB_ETH_RNDIS y
40 # include "f_subset.c"
47 static u8 gfs_hostaddr
[ETH_ALEN
];
48 # ifdef CONFIG_USB_FUNCTIONFS_ETH
49 static int eth_bind_config(struct usb_configuration
*c
, u8 ethaddr
[ETH_ALEN
]);
52 # define gether_cleanup() do { } while (0)
53 # define gether_setup(gadget, hostaddr) ((int)0)
54 # define gfs_hostaddr NULL
59 #define DRIVER_NAME "g_ffs"
60 #define DRIVER_DESC "USB Function Filesystem"
61 #define DRIVER_VERSION "24 Aug 2004"
63 MODULE_DESCRIPTION(DRIVER_DESC
);
64 MODULE_AUTHOR("Michal Nazarewicz");
65 MODULE_LICENSE("GPL");
67 #define GFS_VENDOR_ID 0x1d6b /* Linux Foundation */
68 #define GFS_PRODUCT_ID 0x0105 /* FunctionFS Gadget */
70 #define GFS_MAX_DEVS 10
76 struct ffs_data
*ffs_data
;
79 static struct usb_device_descriptor gfs_dev_desc
= {
80 .bLength
= sizeof gfs_dev_desc
,
81 .bDescriptorType
= USB_DT_DEVICE
,
83 .bcdUSB
= cpu_to_le16(0x0200),
84 .bDeviceClass
= USB_CLASS_PER_INTERFACE
,
86 .idVendor
= cpu_to_le16(GFS_VENDOR_ID
),
87 .idProduct
= cpu_to_le16(GFS_PRODUCT_ID
),
90 static char *func_names
[GFS_MAX_DEVS
];
91 static unsigned int func_num
;
93 module_param_named(bDeviceClass
, gfs_dev_desc
.bDeviceClass
, byte
, 0644);
94 MODULE_PARM_DESC(bDeviceClass
, "USB Device class");
95 module_param_named(bDeviceSubClass
, gfs_dev_desc
.bDeviceSubClass
, byte
, 0644);
96 MODULE_PARM_DESC(bDeviceSubClass
, "USB Device subclass");
97 module_param_named(bDeviceProtocol
, gfs_dev_desc
.bDeviceProtocol
, byte
, 0644);
98 MODULE_PARM_DESC(bDeviceProtocol
, "USB Device protocol");
99 module_param_array_named(functions
, func_names
, charp
, &func_num
, 0);
100 MODULE_PARM_DESC(functions
, "USB Functions list");
102 static const struct usb_descriptor_header
*gfs_otg_desc
[] = {
103 (const struct usb_descriptor_header
*)
104 &(const struct usb_otg_descriptor
) {
105 .bLength
= sizeof(struct usb_otg_descriptor
),
106 .bDescriptorType
= USB_DT_OTG
,
109 * REVISIT SRP-only hardware is possible, although
110 * it would not be called "OTG" ...
112 .bmAttributes
= USB_OTG_SRP
| USB_OTG_HNP
,
118 /* String IDs are assigned dynamically */
119 static struct usb_string gfs_strings
[] = {
120 #ifdef CONFIG_USB_FUNCTIONFS_RNDIS
121 { .s
= "FunctionFS + RNDIS" },
123 #ifdef CONFIG_USB_FUNCTIONFS_ETH
124 { .s
= "FunctionFS + ECM" },
126 #ifdef CONFIG_USB_FUNCTIONFS_GENERIC
127 { .s
= "FunctionFS" },
129 { } /* end of list */
132 static struct usb_gadget_strings
*gfs_dev_strings
[] = {
133 &(struct usb_gadget_strings
) {
134 .language
= 0x0409, /* en-us */
135 .strings
= gfs_strings
,
140 struct gfs_configuration
{
141 struct usb_configuration c
;
142 int (*eth
)(struct usb_configuration
*c
, u8
*ethaddr
);
143 } gfs_configurations
[] = {
144 #ifdef CONFIG_USB_FUNCTIONFS_RNDIS
146 .eth
= rndis_bind_config
,
150 #ifdef CONFIG_USB_FUNCTIONFS_ETH
152 .eth
= eth_bind_config
,
156 #ifdef CONFIG_USB_FUNCTIONFS_GENERIC
162 static int gfs_bind(struct usb_composite_dev
*cdev
);
163 static int gfs_unbind(struct usb_composite_dev
*cdev
);
164 static int gfs_do_config(struct usb_configuration
*c
);
166 static struct usb_composite_driver gfs_driver
= {
168 .dev
= &gfs_dev_desc
,
169 .strings
= gfs_dev_strings
,
170 .max_speed
= USB_SPEED_HIGH
,
171 .unbind
= gfs_unbind
,
172 .iProduct
= DRIVER_DESC
,
175 static DEFINE_MUTEX(gfs_lock
);
176 static unsigned int missing_funcs
;
177 static bool gfs_ether_setup
;
178 static bool gfs_registered
;
179 static bool gfs_single_func
;
180 static struct gfs_ffs_obj
*ffs_tab
;
182 static int __init
gfs_init(void)
189 gfs_single_func
= true;
193 ffs_tab
= kcalloc(func_num
, sizeof *ffs_tab
, GFP_KERNEL
);
197 if (!gfs_single_func
)
198 for (i
= 0; i
< func_num
; i
++)
199 ffs_tab
[i
].name
= func_names
[i
];
201 missing_funcs
= func_num
;
203 return functionfs_init();
205 module_init(gfs_init
);
207 static void __exit
gfs_exit(void)
210 mutex_lock(&gfs_lock
);
213 usb_composite_unregister(&gfs_driver
);
214 gfs_registered
= false;
216 functionfs_cleanup();
218 mutex_unlock(&gfs_lock
);
221 module_exit(gfs_exit
);
223 static struct gfs_ffs_obj
*gfs_find_dev(const char *dev_name
)
232 for (i
= 0; i
< func_num
; i
++)
233 if (strcmp(ffs_tab
[i
].name
, dev_name
) == 0)
239 static int functionfs_ready_callback(struct ffs_data
*ffs
)
241 struct gfs_ffs_obj
*ffs_obj
;
245 mutex_lock(&gfs_lock
);
247 ffs_obj
= ffs
->private_data
;
253 if (WARN_ON(ffs_obj
->desc_ready
)) {
257 ffs_obj
->desc_ready
= true;
258 ffs_obj
->ffs_data
= ffs
;
260 if (--missing_funcs
) {
265 if (gfs_registered
) {
269 gfs_registered
= true;
271 ret
= usb_composite_probe(&gfs_driver
, gfs_bind
);
272 if (unlikely(ret
< 0))
273 gfs_registered
= false;
276 mutex_unlock(&gfs_lock
);
280 static void functionfs_closed_callback(struct ffs_data
*ffs
)
282 struct gfs_ffs_obj
*ffs_obj
;
285 mutex_lock(&gfs_lock
);
287 ffs_obj
= ffs
->private_data
;
291 ffs_obj
->desc_ready
= false;
295 usb_composite_unregister(&gfs_driver
);
296 gfs_registered
= false;
299 mutex_unlock(&gfs_lock
);
302 static void *functionfs_acquire_dev_callback(const char *dev_name
)
304 struct gfs_ffs_obj
*ffs_dev
;
307 mutex_lock(&gfs_lock
);
309 ffs_dev
= gfs_find_dev(dev_name
);
311 ffs_dev
= ERR_PTR(-ENODEV
);
315 if (ffs_dev
->mounted
) {
316 ffs_dev
= ERR_PTR(-EBUSY
);
319 ffs_dev
->mounted
= true;
322 mutex_unlock(&gfs_lock
);
326 static void functionfs_release_dev_callback(struct ffs_data
*ffs_data
)
328 struct gfs_ffs_obj
*ffs_dev
;
331 mutex_lock(&gfs_lock
);
333 ffs_dev
= ffs_data
->private_data
;
335 ffs_dev
->mounted
= false;
337 mutex_unlock(&gfs_lock
);
341 * It is assumed that gfs_bind is called from a context where gfs_lock is held
343 static int gfs_bind(struct usb_composite_dev
*cdev
)
352 ret
= gether_setup(cdev
->gadget
, gfs_hostaddr
);
353 if (unlikely(ret
< 0))
355 gfs_ether_setup
= true;
357 ret
= usb_string_ids_tab(cdev
, gfs_strings
);
358 if (unlikely(ret
< 0))
361 for (i
= func_num
; --i
; ) {
362 ret
= functionfs_bind(ffs_tab
[i
].ffs_data
, cdev
);
363 if (unlikely(ret
< 0)) {
364 while (++i
< func_num
)
365 functionfs_unbind(ffs_tab
[i
].ffs_data
);
370 for (i
= 0; i
< ARRAY_SIZE(gfs_configurations
); ++i
) {
371 struct gfs_configuration
*c
= gfs_configurations
+ i
;
373 c
->c
.label
= gfs_strings
[i
].s
;
374 c
->c
.iConfiguration
= gfs_strings
[i
].id
;
375 c
->c
.bConfigurationValue
= 1 + i
;
376 c
->c
.bmAttributes
= USB_CONFIG_ATT_SELFPOWER
;
378 ret
= usb_add_config(cdev
, &c
->c
, gfs_do_config
);
379 if (unlikely(ret
< 0))
386 for (i
= 0; i
< func_num
; i
++)
387 functionfs_unbind(ffs_tab
[i
].ffs_data
);
391 gfs_ether_setup
= false;
396 * It is assumed that gfs_unbind is called from a context where gfs_lock is held
398 static int gfs_unbind(struct usb_composite_dev
*cdev
)
405 * We may have been called in an error recovery from
406 * composite_bind() after gfs_unbind() failure so we need to
407 * check if gfs_ffs_data is not NULL since gfs_bind() handles
408 * all error recovery itself. I'd rather we werent called
409 * from composite on orror recovery, but what you're gonna
414 gfs_ether_setup
= false;
416 for (i
= func_num
; --i
; )
417 if (ffs_tab
[i
].ffs_data
)
418 functionfs_unbind(ffs_tab
[i
].ffs_data
);
424 * It is assumed that gfs_do_config is called from a context where
427 static int gfs_do_config(struct usb_configuration
*c
)
429 struct gfs_configuration
*gc
=
430 container_of(c
, struct gfs_configuration
, c
);
437 if (gadget_is_otg(c
->cdev
->gadget
)) {
438 c
->descriptors
= gfs_otg_desc
;
439 c
->bmAttributes
|= USB_CONFIG_ATT_WAKEUP
;
443 ret
= gc
->eth(c
, gfs_hostaddr
);
444 if (unlikely(ret
< 0))
448 for (i
= 0; i
< func_num
; i
++) {
449 ret
= functionfs_bind_config(c
->cdev
, c
, ffs_tab
[i
].ffs_data
);
450 if (unlikely(ret
< 0))
455 * After previous do_configs there may be some invalid
456 * pointers in c->interface array. This happens every time
457 * a user space function with fewer interfaces than a user
458 * space function that was run before the new one is run. The
459 * compasit's set_config() assumes that if there is no more
460 * then MAX_CONFIG_INTERFACES interfaces in a configuration
461 * then there is a NULL pointer after the last interface in
462 * c->interface array. We need to make sure this is true.
464 if (c
->next_interface_id
< ARRAY_SIZE(c
->interface
))
465 c
->interface
[c
->next_interface_id
] = NULL
;
470 #ifdef CONFIG_USB_FUNCTIONFS_ETH
472 static int eth_bind_config(struct usb_configuration
*c
, u8 ethaddr
[ETH_ALEN
])
474 return can_support_ecm(c
->cdev
->gadget
)
475 ? ecm_bind_config(c
, ethaddr
)
476 : geth_bind_config(c
, ethaddr
);