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

/*
 * g_ffs.c -- user mode file system API for USB composite function controllers
 *
 * Copyright (C) 2010 Samsung Electronics
 * Author: Michal Nazarewicz <mina86@mina86.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.
 */

#define pr_fmt(fmt) "g_ffs: " fmt

#include <linux/module.h>

#if defined CONFIG_USB_FUNCTIONFS_ETH || defined CONFIG_USB_FUNCTIONFS_RNDIS
#include <linux/netdevice.h>

#  if defined USB_ETH_RNDIS
#    undef USB_ETH_RNDIS
#  endif
#  ifdef CONFIG_USB_FUNCTIONFS_RNDIS
#    define USB_ETH_RNDIS y
#  endif

#  include "u_ecm.h"
#  include "u_gether.h"
#  ifdef USB_ETH_RNDIS
#    include "u_rndis.h"
#    include "rndis.h"
#  endif
#  include "u_ether.h"

USB_ETHERNET_MODULE_PARAMETERS();

#  ifdef CONFIG_USB_FUNCTIONFS_ETH
static int eth_bind_config(struct usb_configuration *c);
static struct usb_function_instance *fi_ecm;
static struct usb_function *f_ecm;
static struct usb_function_instance *fi_geth;
static struct usb_function *f_geth;
#  endif
#  ifdef CONFIG_USB_FUNCTIONFS_RNDIS
static int bind_rndis_config(struct usb_configuration *c);
static struct usb_function_instance *fi_rndis;
static struct usb_function *f_rndis;
#  endif
#endif

#include "u_fs.h"

#define DRIVER_NAME	"g_ffs"
#define DRIVER_DESC	"USB Function Filesystem"
#define DRIVER_VERSION	"24 Aug 2004"

MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR("Michal Nazarewicz");
MODULE_LICENSE("GPL");

#define GFS_VENDOR_ID	0x1d6b	/* Linux Foundation */
#define GFS_PRODUCT_ID	0x0105	/* FunctionFS Gadget */

#define GFS_MAX_DEVS	10

USB_GADGET_COMPOSITE_OPTIONS();

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

	/* .bcdUSB = DYNAMIC */
	.bDeviceClass		= USB_CLASS_PER_INTERFACE,

	.idVendor		= cpu_to_le16(GFS_VENDOR_ID),
	.idProduct		= cpu_to_le16(GFS_PRODUCT_ID),
};

static char *func_names[GFS_MAX_DEVS];
static unsigned int func_num;

module_param_named(bDeviceClass,    gfs_dev_desc.bDeviceClass,    byte,   0644);
MODULE_PARM_DESC(bDeviceClass, "USB Device class");
module_param_named(bDeviceSubClass, gfs_dev_desc.bDeviceSubClass, byte,   0644);
MODULE_PARM_DESC(bDeviceSubClass, "USB Device subclass");
module_param_named(bDeviceProtocol, gfs_dev_desc.bDeviceProtocol, byte,   0644);
MODULE_PARM_DESC(bDeviceProtocol, "USB Device protocol");
module_param_array_named(functions, func_names, charp, &func_num, 0);
MODULE_PARM_DESC(functions, "USB Functions list");

static const struct usb_descriptor_header *gfs_otg_desc[2];

/* String IDs are assigned dynamically */
static struct usb_string gfs_strings[] = {
	[USB_GADGET_MANUFACTURER_IDX].s = "",
	[USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
	[USB_GADGET_SERIAL_IDX].s = "",
#ifdef CONFIG_USB_FUNCTIONFS_RNDIS
	{ .s = "FunctionFS + RNDIS" },
#endif
#ifdef CONFIG_USB_FUNCTIONFS_ETH
	{ .s = "FunctionFS + ECM" },
#endif
#ifdef CONFIG_USB_FUNCTIONFS_GENERIC
	{ .s = "FunctionFS" },
#endif
	{  } /* end of list */
};

static struct usb_gadget_strings *gfs_dev_strings[] = {
	&(struct usb_gadget_strings) {
		.language	= 0x0409,	/* en-us */
		.strings	= gfs_strings,
	},
	NULL,
};

struct gfs_configuration {
	struct usb_configuration c;
	int (*eth)(struct usb_configuration *c);
	int num;
};

static struct gfs_configuration gfs_configurations[] = {
#ifdef CONFIG_USB_FUNCTIONFS_RNDIS
	{
		.eth		= bind_rndis_config,
	},
#endif

#ifdef CONFIG_USB_FUNCTIONFS_ETH
	{
		.eth		= eth_bind_config,
	},
#endif

#ifdef CONFIG_USB_FUNCTIONFS_GENERIC
	{
	},
#endif
};

static void *functionfs_acquire_dev(struct ffs_dev *dev);
static void functionfs_release_dev(struct ffs_dev *dev);
static int functionfs_ready_callback(struct ffs_data *ffs);
static void functionfs_closed_callback(struct ffs_data *ffs);
static int gfs_bind(struct usb_composite_dev *cdev);
static int gfs_unbind(struct usb_composite_dev *cdev);
static int gfs_do_config(struct usb_configuration *c);


static struct usb_composite_driver gfs_driver = {
	.name		= DRIVER_NAME,
	.dev		= &gfs_dev_desc,
	.strings	= gfs_dev_strings,
	.max_speed	= USB_SPEED_HIGH,
	.bind		= gfs_bind,
	.unbind		= gfs_unbind,
};

static unsigned int missing_funcs;
static bool gfs_registered;
static bool gfs_single_func;
static struct usb_function_instance **fi_ffs;
static struct usb_function **f_ffs[] = {
#ifdef CONFIG_USB_FUNCTIONFS_RNDIS
	NULL,
#endif

#ifdef CONFIG_USB_FUNCTIONFS_ETH
	NULL,
#endif

#ifdef CONFIG_USB_FUNCTIONFS_GENERIC
	NULL,
#endif
};

#define N_CONF ARRAY_SIZE(f_ffs)

static int __init gfs_init(void)
{
	struct f_fs_opts *opts;
	int i;
	int ret = 0;

	ENTER();

	if (func_num < 2) {
		gfs_single_func = true;
		func_num = 1;
	}

	/*
	 * Allocate in one chunk for easier maintenance
	 */
	f_ffs[0] = kcalloc(func_num * N_CONF, sizeof(*f_ffs), GFP_KERNEL);
	if (!f_ffs[0]) {
		ret = -ENOMEM;
		goto no_func;
	}
	for (i = 1; i < N_CONF; ++i)
		f_ffs[i] = f_ffs[0] + i * func_num;

	fi_ffs = kcalloc(func_num, sizeof(*fi_ffs), GFP_KERNEL);
	if (!fi_ffs) {
		ret = -ENOMEM;
		goto no_func;
	}

	for (i = 0; i < func_num; i++) {
		fi_ffs[i] = usb_get_function_instance("ffs");
		if (IS_ERR(fi_ffs[i])) {
			ret = PTR_ERR(fi_ffs[i]);
			--i;
			goto no_dev;
		}
		opts = to_f_fs_opts(fi_ffs[i]);
		if (gfs_single_func)
			ret = ffs_single_dev(opts->dev);
		else
			ret = ffs_name_dev(opts->dev, func_names[i]);
		if (ret)
			goto no_dev;
		opts->dev->ffs_ready_callback = functionfs_ready_callback;
		opts->dev->ffs_closed_callback = functionfs_closed_callback;
		opts->dev->ffs_acquire_dev_callback = functionfs_acquire_dev;
		opts->dev->ffs_release_dev_callback = functionfs_release_dev;
		opts->no_configfs = true;
	}

	missing_funcs = func_num;

	return 0;
no_dev:
	while (i >= 0)
		usb_put_function_instance(fi_ffs[i--]);
	kfree(fi_ffs);
no_func:
	kfree(f_ffs[0]);
	return ret;
}
module_init(gfs_init);

static void __exit gfs_exit(void)
{
	int i;

	ENTER();

	if (gfs_registered)
		usb_composite_unregister(&gfs_driver);
	gfs_registered = false;

	kfree(f_ffs[0]);

	for (i = 0; i < func_num; i++)
		usb_put_function_instance(fi_ffs[i]);

	kfree(fi_ffs);
}
module_exit(gfs_exit);

static void *functionfs_acquire_dev(struct ffs_dev *dev)
{
	if (!try_module_get(THIS_MODULE))
		return ERR_PTR(-ENOENT);
	
	return NULL;
}

static void functionfs_release_dev(struct ffs_dev *dev)
{
	module_put(THIS_MODULE);
}

/*
 * The caller of this function takes ffs_lock 
 */
static int functionfs_ready_callback(struct ffs_data *ffs)
{
	int ret = 0;

	if (--missing_funcs)
		return 0;

	if (gfs_registered)
		return -EBUSY;

	gfs_registered = true;

	ret = usb_composite_probe(&gfs_driver);
	if (unlikely(ret < 0)) {
		++missing_funcs;
		gfs_registered = false;
	}
	
	return ret;
}

/*
 * The caller of this function takes ffs_lock 
 */
static void functionfs_closed_callback(struct ffs_data *ffs)
{
	missing_funcs++;

	if (gfs_registered)
		usb_composite_unregister(&gfs_driver);
	gfs_registered = false;
}

/*
 * It is assumed that gfs_bind is called from a context where ffs_lock is held
 */
static int gfs_bind(struct usb_composite_dev *cdev)
{
#if defined CONFIG_USB_FUNCTIONFS_ETH || defined CONFIG_USB_FUNCTIONFS_RNDIS
	struct net_device *net;
#endif
	int ret, i;

	ENTER();

	if (missing_funcs)
		return -ENODEV;
#if defined CONFIG_USB_FUNCTIONFS_ETH
	if (can_support_ecm(cdev->gadget)) {
		struct f_ecm_opts *ecm_opts;

		fi_ecm = usb_get_function_instance("ecm");
		if (IS_ERR(fi_ecm))
			return PTR_ERR(fi_ecm);
		ecm_opts = container_of(fi_ecm, struct f_ecm_opts, func_inst);
		net = ecm_opts->net;
	} else {
		struct f_gether_opts *geth_opts;

		fi_geth = usb_get_function_instance("geth");
		if (IS_ERR(fi_geth))
			return PTR_ERR(fi_geth);
		geth_opts = container_of(fi_geth, struct f_gether_opts,
					 func_inst);
		net = geth_opts->net;
	}
#endif

#ifdef CONFIG_USB_FUNCTIONFS_RNDIS
	{
		struct f_rndis_opts *rndis_opts;

		fi_rndis = usb_get_function_instance("rndis");
		if (IS_ERR(fi_rndis)) {
			ret = PTR_ERR(fi_rndis);
			goto error;
		}
		rndis_opts = container_of(fi_rndis, struct f_rndis_opts,
					  func_inst);
#ifndef CONFIG_USB_FUNCTIONFS_ETH
		net = rndis_opts->net;
#endif
	}
#endif

#if defined CONFIG_USB_FUNCTIONFS_ETH || defined CONFIG_USB_FUNCTIONFS_RNDIS
	gether_set_qmult(net, qmult);
	if (!gether_set_host_addr(net, host_addr))
		pr_info("using host ethernet address: %s", host_addr);
	if (!gether_set_dev_addr(net, dev_addr))
		pr_info("using self ethernet address: %s", dev_addr);
#endif

#if defined CONFIG_USB_FUNCTIONFS_RNDIS && defined CONFIG_USB_FUNCTIONFS_ETH
	gether_set_gadget(net, cdev->gadget);
	ret = gether_register_netdev(net);
	if (ret)
		goto error_rndis;

	if (can_support_ecm(cdev->gadget)) {
		struct f_ecm_opts *ecm_opts;

		ecm_opts = container_of(fi_ecm, struct f_ecm_opts, func_inst);
		ecm_opts->bound = true;
	} else {
		struct f_gether_opts *geth_opts;

		geth_opts = container_of(fi_geth, struct f_gether_opts,
					 func_inst);
		geth_opts->bound = true;
	}

	rndis_borrow_net(fi_rndis, net);
#endif

	/* TODO: gstrings_attach? */
	ret = usb_string_ids_tab(cdev, gfs_strings);
	if (unlikely(ret < 0))
		goto error_rndis;
	gfs_dev_desc.iProduct = gfs_strings[USB_GADGET_PRODUCT_IDX].id;

	if (gadget_is_otg(cdev->gadget) && !gfs_otg_desc[0]) {
		struct usb_descriptor_header *usb_desc;

		usb_desc = usb_otg_descriptor_alloc(cdev->gadget);
		if (!usb_desc)
			goto error_rndis;
		usb_otg_descriptor_init(cdev->gadget, usb_desc);
		gfs_otg_desc[0] = usb_desc;
		gfs_otg_desc[1] = NULL;
	}

	for (i = 0; i < ARRAY_SIZE(gfs_configurations); ++i) {
		struct gfs_configuration *c = gfs_configurations + i;
		int sid = USB_GADGET_FIRST_AVAIL_IDX + i;

		c->c.label			= gfs_strings[sid].s;
		c->c.iConfiguration		= gfs_strings[sid].id;
		c->c.bConfigurationValue	= 1 + i;
		c->c.bmAttributes		= USB_CONFIG_ATT_SELFPOWER;

		c->num = i;

		ret = usb_add_config(cdev, &c->c, gfs_do_config);
		if (unlikely(ret < 0))
			goto error_unbind;
	}
	usb_composite_overwrite_options(cdev, &coverwrite);
	return 0;

/* TODO */
error_unbind:
	kfree(gfs_otg_desc[0]);
	gfs_otg_desc[0] = NULL;
error_rndis:
#ifdef CONFIG_USB_FUNCTIONFS_RNDIS
	usb_put_function_instance(fi_rndis);
error:
#endif
#if defined CONFIG_USB_FUNCTIONFS_ETH
	if (can_support_ecm(cdev->gadget))
		usb_put_function_instance(fi_ecm);
	else
		usb_put_function_instance(fi_geth);
#endif
	return ret;
}

/*
 * It is assumed that gfs_unbind is called from a context where ffs_lock is held
 */
static int gfs_unbind(struct usb_composite_dev *cdev)
{
	int i;

	ENTER();


#ifdef CONFIG_USB_FUNCTIONFS_RNDIS
	usb_put_function(f_rndis);
	usb_put_function_instance(fi_rndis);
#endif

#if defined CONFIG_USB_FUNCTIONFS_ETH
	if (can_support_ecm(cdev->gadget)) {
		usb_put_function(f_ecm);
		usb_put_function_instance(fi_ecm);
	} else {
		usb_put_function(f_geth);
		usb_put_function_instance(fi_geth);
	}
#endif
	for (i = 0; i < N_CONF * func_num; ++i)
		usb_put_function(*(f_ffs[0] + i));

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

	return 0;
}

/*
 * It is assumed that gfs_do_config is called from a context where
 * ffs_lock is held
 */
static int gfs_do_config(struct usb_configuration *c)
{
	struct gfs_configuration *gc =
		container_of(c, struct gfs_configuration, c);
	int i;
	int ret;

	if (missing_funcs)
		return -ENODEV;

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

	if (gc->eth) {
		ret = gc->eth(c);
		if (unlikely(ret < 0))
			return ret;
	}

	for (i = 0; i < func_num; i++) {
		f_ffs[gc->num][i] = usb_get_function(fi_ffs[i]);
		if (IS_ERR(f_ffs[gc->num][i])) {
			ret = PTR_ERR(f_ffs[gc->num][i]);
			goto error;
		}
		ret = usb_add_function(c, f_ffs[gc->num][i]);
		if (ret < 0) {
			usb_put_function(f_ffs[gc->num][i]);
			goto error;
		}
	}

	/*
	 * After previous do_configs there may be some invalid
	 * pointers in c->interface array.  This happens every time
	 * a user space function with fewer interfaces than a user
	 * space function that was run before the new one is run.  The
	 * compasit's set_config() assumes that if there is no more
	 * then MAX_CONFIG_INTERFACES interfaces in a configuration
	 * then there is a NULL pointer after the last interface in
	 * c->interface array.  We need to make sure this is true.
	 */
	if (c->next_interface_id < ARRAY_SIZE(c->interface))
		c->interface[c->next_interface_id] = NULL;

	return 0;
error:
	while (--i >= 0) {
		if (!IS_ERR(f_ffs[gc->num][i]))
			usb_remove_function(c, f_ffs[gc->num][i]);
		usb_put_function(f_ffs[gc->num][i]);
	}
	return ret;
}

#ifdef CONFIG_USB_FUNCTIONFS_ETH

static int eth_bind_config(struct usb_configuration *c)
{
	int status = 0;

	if (can_support_ecm(c->cdev->gadget)) {
		f_ecm = usb_get_function(fi_ecm);
		if (IS_ERR(f_ecm))
			return PTR_ERR(f_ecm);

		status = usb_add_function(c, f_ecm);
		if (status < 0)
			usb_put_function(f_ecm);

	} else {
		f_geth = usb_get_function(fi_geth);
		if (IS_ERR(f_geth))
			return PTR_ERR(f_geth);

		status = usb_add_function(c, f_geth);
		if (status < 0)
			usb_put_function(f_geth);
	}
	return status;
}

#endif

#ifdef CONFIG_USB_FUNCTIONFS_RNDIS

static int bind_rndis_config(struct usb_configuration *c)
{
	int status = 0;

	f_rndis = usb_get_function(fi_rndis);
	if (IS_ERR(f_rndis))
		return PTR_ERR(f_rndis);

	status = usb_add_function(c, f_rndis);
	if (status < 0)
		usb_put_function(f_rndis);

	return status;
}

#endif
Commit	Line	Data
5ab54cf7 MN	1	/*
	2	* g_ffs.c -- user mode file system API for USB composite function controllers
	3	*
	4	* Copyright (C) 2010 Samsung Electronics
54b8360f	5	* Author: Michal Nazarewicz <mina86@mina86.com>
5ab54cf7 MN	6	*
	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.
5ab54cf7 MN	11	*/
5ab54cf7 MN	12
aa02f172 MN	13	#define pr_fmt(fmt) "g_ffs: " fmt
aa02f172 MN	14
c6c56008	15	#include <linux/module.h>
6f823cd5	16
c6c56008	17	#if defined CONFIG_USB_FUNCTIONFS_ETH \|\| defined CONFIG_USB_FUNCTIONFS_RNDIS
85aec59f AP	18	#include <linux/netdevice.h>
85aec59f AP	19
c6c56008 MN	20	# if defined USB_ETH_RNDIS
	21	# undef USB_ETH_RNDIS
	22	# endif
	23	# ifdef CONFIG_USB_FUNCTIONFS_RNDIS
	24	# define USB_ETH_RNDIS y
	25	# endif
	26
f212ad4e	27	# include "u_ecm.h"
85aec59f	28	# include "u_gether.h"
c6c56008	29	# ifdef USB_ETH_RNDIS
6e257b14	30	# include "u_rndis.h"
cbbd14a9	31	# include "rndis.h"
c6c56008	32	# endif
f1a1823f	33	# include "u_ether.h"
c6c56008	34
f212ad4e AP	35	USB_ETHERNET_MODULE_PARAMETERS();
f212ad4e AP	36
f8dae531	37	# ifdef CONFIG_USB_FUNCTIONFS_ETH
6e257b14	38	static int eth_bind_config(struct usb_configuration *c);
f212ad4e AP	39	static struct usb_function_instance *fi_ecm;
f212ad4e AP	40	static struct usb_function *f_ecm;
85aec59f AP	41	static struct usb_function_instance *fi_geth;
85aec59f AP	42	static struct usb_function *f_geth;
c6c56008	43	# endif
6e257b14 AP	44	# ifdef CONFIG_USB_FUNCTIONFS_RNDIS
	45	static int bind_rndis_config(struct usb_configuration *c);
	46	static struct usb_function_instance *fi_rndis;
	47	static struct usb_function *f_rndis;
	48	# endif
c6c56008 MN	49	#endif
c6c56008 MN	50
6f823cd5	51	#include "u_fs.h"
c6c56008	52
c6c56008 MN	53	#define DRIVER_NAME "g_ffs"
	54	#define DRIVER_DESC "USB Function Filesystem"
	55	#define DRIVER_VERSION "24 Aug 2004"
	56
	57	MODULE_DESCRIPTION(DRIVER_DESC);
	58	MODULE_AUTHOR("Michal Nazarewicz");
	59	MODULE_LICENSE("GPL");
	60
fc19de61 MN	61	#define GFS_VENDOR_ID 0x1d6b /* Linux Foundation */
fc19de61 MN	62	#define GFS_PRODUCT_ID 0x0105 /* FunctionFS Gadget */
c6c56008	63
581791f5 AP	64	#define GFS_MAX_DEVS 10
581791f5 AP	65
7d16e8d3 SAS	66	USB_GADGET_COMPOSITE_OPTIONS();
7d16e8d3 SAS	67
c6c56008 MN	68	static struct usb_device_descriptor gfs_dev_desc = {
	69	.bLength = sizeof gfs_dev_desc,
	70	.bDescriptorType = USB_DT_DEVICE,
	71
0aecfc1b	72	/* .bcdUSB = DYNAMIC */
c6c56008 MN	73	.bDeviceClass = USB_CLASS_PER_INTERFACE,
c6c56008 MN	74
fc19de61 MN	75	.idVendor = cpu_to_le16(GFS_VENDOR_ID),
fc19de61 MN	76	.idProduct = cpu_to_le16(GFS_PRODUCT_ID),
c6c56008 MN	77	};
c6c56008 MN	78
581791f5 AP	79	static char *func_names[GFS_MAX_DEVS];
	80	static unsigned int func_num;
	81
fc19de61 MN	82	module_param_named(bDeviceClass, gfs_dev_desc.bDeviceClass, byte, 0644);
	83	MODULE_PARM_DESC(bDeviceClass, "USB Device class");
	84	module_param_named(bDeviceSubClass, gfs_dev_desc.bDeviceSubClass, byte, 0644);
	85	MODULE_PARM_DESC(bDeviceSubClass, "USB Device subclass");
	86	module_param_named(bDeviceProtocol, gfs_dev_desc.bDeviceProtocol, byte, 0644);
	87	MODULE_PARM_DESC(bDeviceProtocol, "USB Device protocol");
581791f5 AP	88	module_param_array_named(functions, func_names, charp, &func_num, 0);
581791f5 AP	89	MODULE_PARM_DESC(functions, "USB Functions list");
c6c56008	90
75c9310a	91	static const struct usb_descriptor_header *gfs_otg_desc[2];
c6c56008	92
5ab54cf7	93	/* String IDs are assigned dynamically */
c6c56008	94	static struct usb_string gfs_strings[] = {
276e2e4f	95	[USB_GADGET_MANUFACTURER_IDX].s = "",
d33f74fc	96	[USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
276e2e4f	97	[USB_GADGET_SERIAL_IDX].s = "",
c6c56008	98	#ifdef CONFIG_USB_FUNCTIONFS_RNDIS
f8dae531	99	{ .s = "FunctionFS + RNDIS" },
c6c56008 MN	100	#endif
c6c56008 MN	101	#ifdef CONFIG_USB_FUNCTIONFS_ETH
f8dae531	102	{ .s = "FunctionFS + ECM" },
c6c56008 MN	103	#endif
c6c56008 MN	104	#ifdef CONFIG_USB_FUNCTIONFS_GENERIC
f8dae531	105	{ .s = "FunctionFS" },
c6c56008 MN	106	#endif
	107	{ } /* end of list */
	108	};
	109
	110	static struct usb_gadget_strings *gfs_dev_strings[] = {
	111	&(struct usb_gadget_strings) {
	112	.language = 0x0409, /* en-us */
	113	.strings = gfs_strings,
	114	},
	115	NULL,
	116	};
	117
f8dae531 MN	118	struct gfs_configuration {
f8dae531 MN	119	struct usb_configuration c;
6e257b14	120	int (eth)(struct usb_configuration c);
6f823cd5	121	int num;
2b87cd24 LP	122	};
	123
	124	static struct gfs_configuration gfs_configurations[] = {
c6c56008	125	#ifdef CONFIG_USB_FUNCTIONFS_RNDIS
f8dae531	126	{
6e257b14	127	.eth = bind_rndis_config,
f8dae531	128	},
c6c56008 MN	129	#endif
c6c56008 MN	130
c6c56008	131	#ifdef CONFIG_USB_FUNCTIONFS_ETH
f8dae531 MN	132	{
	133	.eth = eth_bind_config,
	134	},
c6c56008 MN	135	#endif
c6c56008 MN	136
c6c56008	137	#ifdef CONFIG_USB_FUNCTIONFS_GENERIC
f8dae531 MN	138	{
f8dae531 MN	139	},
c6c56008	140	#endif
f8dae531	141	};
c6c56008	142
6f823cd5 AP	143	static void functionfs_acquire_dev(struct ffs_dev dev);
6f823cd5 AP	144	static void functionfs_release_dev(struct ffs_dev *dev);
4b187fce AP	145	static int functionfs_ready_callback(struct ffs_data *ffs);
4b187fce AP	146	static void functionfs_closed_callback(struct ffs_data *ffs);
c6c56008 MN	147	static int gfs_bind(struct usb_composite_dev *cdev);
c6c56008 MN	148	static int gfs_unbind(struct usb_composite_dev *cdev);
f8dae531	149	static int gfs_do_config(struct usb_configuration *c);
c6c56008	150
6f823cd5	151
c94e289f	152	static struct usb_composite_driver gfs_driver = {
fc19de61	153	.name = DRIVER_NAME,
c6c56008 MN	154	.dev = &gfs_dev_desc,
c6c56008 MN	155	.strings = gfs_dev_strings,
35a0e0bf	156	.max_speed = USB_SPEED_HIGH,
03e42bd5	157	.bind = gfs_bind,
c6c56008 MN	158	.unbind = gfs_unbind,
	159	};
	160
581791f5	161	static unsigned int missing_funcs;
581791f5 AP	162	static bool gfs_registered;
581791f5 AP	163	static bool gfs_single_func;
6f823cd5 AP	164	static struct usb_function_instance **fi_ffs;
	165	static struct usb_function **f_ffs[] = {
	166	#ifdef CONFIG_USB_FUNCTIONFS_RNDIS
	167	NULL,
	168	#endif
	169
	170	#ifdef CONFIG_USB_FUNCTIONFS_ETH
	171	NULL,
	172	#endif
	173
	174	#ifdef CONFIG_USB_FUNCTIONFS_GENERIC
	175	NULL,
	176	#endif
	177	};
	178
	179	#define N_CONF ARRAY_SIZE(f_ffs)
c6c56008	180
8545e603	181	static int __init gfs_init(void)
c6c56008	182	{
6f823cd5	183	struct f_fs_opts *opts;
581791f5	184	int i;
4b187fce	185	int ret = 0;
581791f5	186
c6c56008 MN	187	ENTER();
c6c56008 MN	188
4b187fce	189	if (func_num < 2) {
581791f5 AP	190	gfs_single_func = true;
	191	func_num = 1;
	192	}
	193
6f823cd5 AP	194	/*
	195	* Allocate in one chunk for easier maintenance
	196	*/
	197	f_ffs[0] = kcalloc(func_num * N_CONF, sizeof(*f_ffs), GFP_KERNEL);
	198	if (!f_ffs[0]) {
	199	ret = -ENOMEM;
	200	goto no_func;
	201	}
	202	for (i = 1; i < N_CONF; ++i)
	203	f_ffs[i] = f_ffs[0] + i * func_num;
	204
	205	fi_ffs = kcalloc(func_num, sizeof(*fi_ffs), GFP_KERNEL);
	206	if (!fi_ffs) {
	207	ret = -ENOMEM;
	208	goto no_func;
	209	}
581791f5	210
4b187fce	211	for (i = 0; i < func_num; i++) {
6f823cd5 AP	212	fi_ffs[i] = usb_get_function_instance("ffs");
	213	if (IS_ERR(fi_ffs[i])) {
	214	ret = PTR_ERR(fi_ffs[i]);
4b187fce AP	215	--i;
	216	goto no_dev;
	217	}
6f823cd5	218	opts = to_f_fs_opts(fi_ffs[i]);
4b187fce	219	if (gfs_single_func)
6f823cd5	220	ret = ffs_single_dev(opts->dev);
4b187fce	221	else
6f823cd5	222	ret = ffs_name_dev(opts->dev, func_names[i]);
4b187fce AP	223	if (ret)
4b187fce AP	224	goto no_dev;
6f823cd5 AP	225	opts->dev->ffs_ready_callback = functionfs_ready_callback;
	226	opts->dev->ffs_closed_callback = functionfs_closed_callback;
	227	opts->dev->ffs_acquire_dev_callback = functionfs_acquire_dev;
	228	opts->dev->ffs_release_dev_callback = functionfs_release_dev;
	229	opts->no_configfs = true;
4b187fce	230	}
581791f5 AP	231
	232	missing_funcs = func_num;
	233
4b187fce AP	234	return 0;
4b187fce AP	235	no_dev:
4b187fce	236	while (i >= 0)
6f823cd5 AP	237	usb_put_function_instance(fi_ffs[i--]);
	238	kfree(fi_ffs);
	239	no_func:
	240	kfree(f_ffs[0]);
4b187fce	241	return ret;
c6c56008 MN	242	}
	243	module_init(gfs_init);
	244
8545e603	245	static void __exit gfs_exit(void)
c6c56008	246	{
4b187fce AP	247	int i;
4b187fce AP	248
c6c56008 MN	249	ENTER();
c6c56008 MN	250
581791f5	251	if (gfs_registered)
c6c56008	252	usb_composite_unregister(&gfs_driver);
581791f5	253	gfs_registered = false;
c6c56008	254
6f823cd5 AP	255	kfree(f_ffs[0]);
6f823cd5 AP	256
4b187fce	257	for (i = 0; i < func_num; i++)
6f823cd5 AP	258	usb_put_function_instance(fi_ffs[i]);
	259
	260	kfree(fi_ffs);
c6c56008 MN	261	}
	262	module_exit(gfs_exit);
	263
6f823cd5 AP	264	static void functionfs_acquire_dev(struct ffs_dev dev)
	265	{
	266	if (!try_module_get(THIS_MODULE))
d668b4f3	267	return ERR_PTR(-ENOENT);
6f823cd5	268
2b87cd24	269	return NULL;
6f823cd5 AP	270	}
	271
	272	static void functionfs_release_dev(struct ffs_dev *dev)
	273	{
	274	module_put(THIS_MODULE);
	275	}
	276
4b187fce AP	277	/*
	278	* The caller of this function takes ffs_lock
	279	*/
c6c56008 MN	280	static int functionfs_ready_callback(struct ffs_data *ffs)
c6c56008 MN	281	{
4b187fce	282	int ret = 0;
581791f5	283
4b187fce AP	284	if (--missing_funcs)
4b187fce AP	285	return 0;
c6c56008	286
4b187fce AP	287	if (gfs_registered)
4b187fce AP	288	return -EBUSY;
581791f5	289
581791f5	290	gfs_registered = true;
c6c56008	291
03e42bd5	292	ret = usb_composite_probe(&gfs_driver);
c41b33c5 KO	293	if (unlikely(ret < 0)) {
c41b33c5 KO	294	++missing_funcs;
581791f5	295	gfs_registered = false;
c41b33c5	296	}
4b187fce	297
c6c56008 MN	298	return ret;
	299	}
	300
4b187fce AP	301	/*
	302	* The caller of this function takes ffs_lock
	303	*/
c6c56008 MN	304	static void functionfs_closed_callback(struct ffs_data *ffs)
c6c56008 MN	305	{
581791f5 AP	306	missing_funcs++;
	307
	308	if (gfs_registered)
c6c56008	309	usb_composite_unregister(&gfs_driver);
581791f5	310	gfs_registered = false;
581791f5 AP	311	}
	312
	313	/*
4b187fce	314	* It is assumed that gfs_bind is called from a context where ffs_lock is held
581791f5	315	*/
c6c56008 MN	316	static int gfs_bind(struct usb_composite_dev *cdev)
c6c56008 MN	317	{
6e257b14	318	#if defined CONFIG_USB_FUNCTIONFS_ETH \|\| defined CONFIG_USB_FUNCTIONFS_RNDIS
85aec59f AP	319	struct net_device *net;
85aec59f AP	320	#endif
f8dae531	321	int ret, i;
c6c56008 MN	322
	323	ENTER();
	324
581791f5	325	if (missing_funcs)
c6c56008	326	return -ENODEV;
f212ad4e AP	327	#if defined CONFIG_USB_FUNCTIONFS_ETH
	328	if (can_support_ecm(cdev->gadget)) {
	329	struct f_ecm_opts *ecm_opts;
	330
	331	fi_ecm = usb_get_function_instance("ecm");
	332	if (IS_ERR(fi_ecm))
	333	return PTR_ERR(fi_ecm);
	334	ecm_opts = container_of(fi_ecm, struct f_ecm_opts, func_inst);
85aec59f	335	net = ecm_opts->net;
f212ad4e	336	} else {
85aec59f AP	337	struct f_gether_opts *geth_opts;
	338
	339	fi_geth = usb_get_function_instance("geth");
	340	if (IS_ERR(fi_geth))
	341	return PTR_ERR(fi_geth);
	342	geth_opts = container_of(fi_geth, struct f_gether_opts,
	343	func_inst);
	344	net = geth_opts->net;
f212ad4e	345	}
6e257b14 AP	346	#endif
	347
	348	#ifdef CONFIG_USB_FUNCTIONFS_RNDIS
	349	{
	350	struct f_rndis_opts *rndis_opts;
	351
	352	fi_rndis = usb_get_function_instance("rndis");
	353	if (IS_ERR(fi_rndis)) {
	354	ret = PTR_ERR(fi_rndis);
	355	goto error;
	356	}
	357	rndis_opts = container_of(fi_rndis, struct f_rndis_opts,
	358	func_inst);
	359	#ifndef CONFIG_USB_FUNCTIONFS_ETH
	360	net = rndis_opts->net;
	361	#endif
	362	}
	363	#endif
85aec59f	364
6e257b14 AP	365	#if defined CONFIG_USB_FUNCTIONFS_ETH \|\| defined CONFIG_USB_FUNCTIONFS_RNDIS
6e257b14 AP	366	gether_set_qmult(net, qmult);
85aec59f AP	367	if (!gether_set_host_addr(net, host_addr))
	368	pr_info("using host ethernet address: %s", host_addr);
	369	if (!gether_set_dev_addr(net, dev_addr))
	370	pr_info("using self ethernet address: %s", dev_addr);
d6a01439	371	#endif
f212ad4e AP	372
f212ad4e AP	373	#if defined CONFIG_USB_FUNCTIONFS_RNDIS && defined CONFIG_USB_FUNCTIONFS_ETH
85aec59f AP	374	gether_set_gadget(net, cdev->gadget);
	375	ret = gether_register_netdev(net);
	376	if (ret)
6e257b14	377	goto error_rndis;
85aec59f	378
f212ad4e AP	379	if (can_support_ecm(cdev->gadget)) {
	380	struct f_ecm_opts *ecm_opts;
	381
	382	ecm_opts = container_of(fi_ecm, struct f_ecm_opts, func_inst);
f212ad4e	383	ecm_opts->bound = true;
85aec59f AP	384	} else {
	385	struct f_gether_opts *geth_opts;
	386
	387	geth_opts = container_of(fi_geth, struct f_gether_opts,
	388	func_inst);
	389	geth_opts->bound = true;
d6a01439	390	}
6e257b14 AP	391
6e257b14 AP	392	rndis_borrow_net(fi_rndis, net);
f212ad4e	393	#endif
c6c56008	394
6f823cd5	395	/* TODO: gstrings_attach? */
f8dae531	396	ret = usb_string_ids_tab(cdev, gfs_strings);
c6c56008	397	if (unlikely(ret < 0))
6e257b14	398	goto error_rndis;
d33f74fc	399	gfs_dev_desc.iProduct = gfs_strings[USB_GADGET_PRODUCT_IDX].id;
c6c56008	400
75c9310a LJ	401	if (gadget_is_otg(cdev->gadget) && !gfs_otg_desc[0]) {
	402	struct usb_descriptor_header *usb_desc;
	403
	404	usb_desc = usb_otg_descriptor_alloc(cdev->gadget);
	405	if (!usb_desc)
	406	goto error_rndis;
	407	usb_otg_descriptor_init(cdev->gadget, usb_desc);
	408	gfs_otg_desc[0] = usb_desc;
	409	gfs_otg_desc[1] = NULL;
	410	}
	411
f8dae531 MN	412	for (i = 0; i < ARRAY_SIZE(gfs_configurations); ++i) {
f8dae531 MN	413	struct gfs_configuration *c = gfs_configurations + i;
276e2e4f	414	int sid = USB_GADGET_FIRST_AVAIL_IDX + i;
c6c56008	415
276e2e4f SAS	416	c->c.label = gfs_strings[sid].s;
276e2e4f SAS	417	c->c.iConfiguration = gfs_strings[sid].id;
f8dae531 MN	418	c->c.bConfigurationValue = 1 + i;
f8dae531 MN	419	c->c.bmAttributes = USB_CONFIG_ATT_SELFPOWER;
c6c56008	420
6f823cd5 AP	421	c->num = i;
6f823cd5 AP	422
c9bfff9c	423	ret = usb_add_config(cdev, &c->c, gfs_do_config);
f8dae531 MN	424	if (unlikely(ret < 0))
	425	goto error_unbind;
	426	}
7d16e8d3	427	usb_composite_overwrite_options(cdev, &coverwrite);
c6c56008 MN	428	return 0;
c6c56008 MN	429
6f823cd5	430	/* TODO */
c6c56008	431	error_unbind:
75c9310a LJ	432	kfree(gfs_otg_desc[0]);
75c9310a LJ	433	gfs_otg_desc[0] = NULL;
6e257b14 AP	434	error_rndis:
	435	#ifdef CONFIG_USB_FUNCTIONFS_RNDIS
	436	usb_put_function_instance(fi_rndis);
c6c56008	437	error:
6e257b14	438	#endif
f212ad4e AP	439	#if defined CONFIG_USB_FUNCTIONFS_ETH
	440	if (can_support_ecm(cdev->gadget))
	441	usb_put_function_instance(fi_ecm);
	442	else
85aec59f	443	usb_put_function_instance(fi_geth);
f212ad4e	444	#endif
c6c56008 MN	445	return ret;
	446	}
	447
581791f5	448	/*
4b187fce	449	* It is assumed that gfs_unbind is called from a context where ffs_lock is held
581791f5	450	*/
c6c56008 MN	451	static int gfs_unbind(struct usb_composite_dev *cdev)
c6c56008 MN	452	{
581791f5 AP	453	int i;
581791f5 AP	454
c6c56008 MN	455	ENTER();
c6c56008 MN	456
f212ad4e	457
6e257b14 AP	458	#ifdef CONFIG_USB_FUNCTIONFS_RNDIS
	459	usb_put_function(f_rndis);
	460	usb_put_function_instance(fi_rndis);
	461	#endif
	462
f212ad4e AP	463	#if defined CONFIG_USB_FUNCTIONFS_ETH
	464	if (can_support_ecm(cdev->gadget)) {
	465	usb_put_function(f_ecm);
	466	usb_put_function_instance(fi_ecm);
	467	} else {
85aec59f AP	468	usb_put_function(f_geth);
85aec59f AP	469	usb_put_function_instance(fi_geth);
f212ad4e	470	}
f212ad4e	471	#endif
6f823cd5 AP	472	for (i = 0; i < N_CONF * func_num; ++i)
6f823cd5 AP	473	usb_put_function(*(f_ffs[0] + i));
c6c56008	474
75c9310a LJ	475	kfree(gfs_otg_desc[0]);
	476	gfs_otg_desc[0] = NULL;
	477
c6c56008 MN	478	return 0;
	479	}
	480
581791f5 AP	481	/*
581791f5 AP	482	* It is assumed that gfs_do_config is called from a context where
4b187fce	483	* ffs_lock is held
581791f5	484	*/
f8dae531	485	static int gfs_do_config(struct usb_configuration *c)
c6c56008	486	{
f8dae531 MN	487	struct gfs_configuration *gc =
f8dae531 MN	488	container_of(c, struct gfs_configuration, c);
581791f5	489	int i;
c6c56008 MN	490	int ret;
c6c56008 MN	491
581791f5	492	if (missing_funcs)
c6c56008 MN	493	return -ENODEV;
	494
	495	if (gadget_is_otg(c->cdev->gadget)) {
	496	c->descriptors = gfs_otg_desc;
	497	c->bmAttributes \|= USB_CONFIG_ATT_WAKEUP;
	498	}
	499
f8dae531	500	if (gc->eth) {
6e257b14	501	ret = gc->eth(c);
c6c56008 MN	502	if (unlikely(ret < 0))
	503	return ret;
	504	}
	505
581791f5	506	for (i = 0; i < func_num; i++) {
6f823cd5 AP	507	f_ffs[gc->num][i] = usb_get_function(fi_ffs[i]);
	508	if (IS_ERR(f_ffs[gc->num][i])) {
	509	ret = PTR_ERR(f_ffs[gc->num][i]);
	510	goto error;
	511	}
	512	ret = usb_add_function(c, f_ffs[gc->num][i]);
	513	if (ret < 0) {
	514	usb_put_function(f_ffs[gc->num][i]);
	515	goto error;
	516	}
581791f5	517	}
c6c56008	518
fc19de61 MN	519	/*
fc19de61 MN	520	* After previous do_configs there may be some invalid
f588c0db MN	521	* pointers in c->interface array. This happens every time
	522	* a user space function with fewer interfaces than a user
	523	* space function that was run before the new one is run. The
	524	* compasit's set_config() assumes that if there is no more
	525	* then MAX_CONFIG_INTERFACES interfaces in a configuration
	526	* then there is a NULL pointer after the last interface in
fc19de61 MN	527	* c->interface array. We need to make sure this is true.
fc19de61 MN	528	*/
f588c0db MN	529	if (c->next_interface_id < ARRAY_SIZE(c->interface))
	530	c->interface[c->next_interface_id] = NULL;
	531
c6c56008	532	return 0;
6f823cd5 AP	533	error:
	534	while (--i >= 0) {
	535	if (!IS_ERR(f_ffs[gc->num][i]))
	536	usb_remove_function(c, f_ffs[gc->num][i]);
	537	usb_put_function(f_ffs[gc->num][i]);
	538	}
	539	return ret;
c6c56008 MN	540	}
c6c56008 MN	541
c6c56008	542	#ifdef CONFIG_USB_FUNCTIONFS_ETH
fc19de61	543
6e257b14	544	static int eth_bind_config(struct usb_configuration *c)
c6c56008	545	{
f212ad4e AP	546	int status = 0;
	547
	548	if (can_support_ecm(c->cdev->gadget)) {
	549	f_ecm = usb_get_function(fi_ecm);
	550	if (IS_ERR(f_ecm))
	551	return PTR_ERR(f_ecm);
	552
	553	status = usb_add_function(c, f_ecm);
	554	if (status < 0)
	555	usb_put_function(f_ecm);
	556
	557	} else {
85aec59f AP	558	f_geth = usb_get_function(fi_geth);
	559	if (IS_ERR(f_geth))
	560	return PTR_ERR(f_geth);
	561
	562	status = usb_add_function(c, f_geth);
	563	if (status < 0)
	564	usb_put_function(f_geth);
f212ad4e AP	565	}
f212ad4e AP	566	return status;
c6c56008	567	}
fc19de61	568
c6c56008	569	#endif
6e257b14 AP	570
	571	#ifdef CONFIG_USB_FUNCTIONFS_RNDIS
	572
	573	static int bind_rndis_config(struct usb_configuration *c)
	574	{
	575	int status = 0;
	576
	577	f_rndis = usb_get_function(fi_rndis);
	578	if (IS_ERR(f_rndis))
	579	return PTR_ERR(f_rndis);
	580
	581	status = usb_add_function(c, f_rndis);
	582	if (status < 0)
	583	usb_put_function(f_rndis);
	584
	585	return status;
	586	}
	587
	588	#endif