text: #include <linux/module.h>
  #include <linux/utsname.h>
  
  
  /*
   * 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 "composite.c"
  #include "usbstring.c"
  #include "config.c"
  #include "epautoconf.c"
  
  #if defined CONFIG_USB_FUNCTIONFS_ETH || defined CONFIG_USB_FUNCTIONFS_RNDIS
  #  if defined USB_ETH_RNDIS
  #    undef USB_ETH_RNDIS
  #  endif
  #  ifdef CONFIG_USB_FUNCTIONFS_RNDIS
  #    define USB_ETH_RNDIS y
  #  endif
  
  #  include "f_ecm.c"
  #  include "f_subset.c"
  #  ifdef USB_ETH_RNDIS
  #    include "f_rndis.c"
  #    include "rndis.c"
  #  endif
  #  include "u_ether.c"
  
  static u8 gfs_hostaddr[ETH_ALEN];
  #else
  #  if !defined CONFIG_USB_FUNCTIONFS_GENERIC
  #    define CONFIG_USB_FUNCTIONFS_GENERIC
  #  endif
  #  define gether_cleanup() do { } while (0)
  #  define gether_setup(gadget, hostaddr)   ((int)0)
  #endif
  
  #include "f_fs.c"
  
  
  #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");
  
  
  static unsigned short gfs_vendor_id    = 0x0525;	/* XXX NetChip */
  static unsigned short gfs_product_id   = 0xa4ac;	/* XXX */
  
  static struct usb_device_descriptor gfs_dev_desc = {
  	.bLength		= sizeof gfs_dev_desc,
  	.bDescriptorType	= USB_DT_DEVICE,
  
  	.bcdUSB			= cpu_to_le16(0x0200),
  	.bDeviceClass		= USB_CLASS_PER_INTERFACE,
  
  	/* Vendor and product id can be overridden by module parameters.  */
  	/* .idVendor		= cpu_to_le16(gfs_vendor_id), */
  	/* .idProduct		= cpu_to_le16(gfs_product_id), */
  	/* .bcdDevice		= f(hardware) */
  	/* .iManufacturer	= DYNAMIC */
  	/* .iProduct		= DYNAMIC */
  	/* NO SERIAL NUMBER */
  	.bNumConfigurations	= 1,
  };
  
  #define GFS_MODULE_PARAM_DESC(name, field) \
  	MODULE_PARM_DESC(name, "Value of the " #field " field of the device descriptor sent to the host.  Takes effect only prior to the user-space driver registering to the FunctionFS.")
  
  module_param_named(usb_class,    gfs_dev_desc.bDeviceClass,    byte,   0644);
  GFS_MODULE_PARAM_DESC(usb_class, bDeviceClass);
  module_param_named(usb_subclass, gfs_dev_desc.bDeviceSubClass, byte,   0644);
  GFS_MODULE_PARAM_DESC(usb_subclass, bDeviceSubClass);
  module_param_named(usb_protocol, gfs_dev_desc.bDeviceProtocol, byte,   0644);
  GFS_MODULE_PARAM_DESC(usb_protocol, bDeviceProtocol);
  module_param_named(usb_vendor,   gfs_vendor_id,                ushort, 0644);
  GFS_MODULE_PARAM_DESC(usb_vendor, idVendor);
  module_param_named(usb_product,  gfs_product_id,               ushort, 0644);
  GFS_MODULE_PARAM_DESC(usb_product, idProduct);
  
  
  
  static const struct usb_descriptor_header *gfs_otg_desc[] = {
  	(const struct usb_descriptor_header *)
  	&(const 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,
  	},
  
  	NULL
  };
  
  /* string IDs are assigned dynamically */
  
  enum {
  	GFS_STRING_MANUFACTURER_IDX,
  	GFS_STRING_PRODUCT_IDX,
  #ifdef CONFIG_USB_FUNCTIONFS_RNDIS
  	GFS_STRING_RNDIS_CONFIG_IDX,
  #endif
  #ifdef CONFIG_USB_FUNCTIONFS_ETH
  	GFS_STRING_ECM_CONFIG_IDX,
  #endif
  #ifdef CONFIG_USB_FUNCTIONFS_GENERIC
  	GFS_STRING_GENERIC_CONFIG_IDX,
  #endif
  };
  
  static       char gfs_manufacturer[50];
  static const char gfs_driver_desc[] = DRIVER_DESC;
  static const char gfs_short_name[]  = DRIVER_NAME;
  
  static struct usb_string gfs_strings[] = {
  	[GFS_STRING_MANUFACTURER_IDX].s = gfs_manufacturer,
  	[GFS_STRING_PRODUCT_IDX].s = gfs_driver_desc,
  #ifdef CONFIG_USB_FUNCTIONFS_RNDIS
  	[GFS_STRING_RNDIS_CONFIG_IDX].s = "FunctionFS + RNDIS",
  #endif
  #ifdef CONFIG_USB_FUNCTIONFS_ETH
  	[GFS_STRING_ECM_CONFIG_IDX].s = "FunctionFS + ECM",
  #endif
  #ifdef CONFIG_USB_FUNCTIONFS_GENERIC
  	[GFS_STRING_GENERIC_CONFIG_IDX].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,
  };
  
  
  #ifdef CONFIG_USB_FUNCTIONFS_RNDIS
  static int gfs_do_rndis_config(struct usb_configuration *c);
  
  static struct usb_configuration gfs_rndis_config_driver = {
  	.label			= "FunctionFS + RNDIS",
  	.bind			= gfs_do_rndis_config,
  	.bConfigurationValue	= 1,
  	/* .iConfiguration	= DYNAMIC */
  	.bmAttributes		= USB_CONFIG_ATT_SELFPOWER,
  };
  #  define gfs_add_rndis_config(cdev) \
  	usb_add_config(cdev, &gfs_rndis_config_driver)
  #else
  #  define gfs_add_rndis_config(cdev) 0
  #endif
  
  
  #ifdef CONFIG_USB_FUNCTIONFS_ETH
  static int gfs_do_ecm_config(struct usb_configuration *c);
  
  static struct usb_configuration gfs_ecm_config_driver = {
  	.label			= "FunctionFS + ECM",
  	.bind			= gfs_do_ecm_config,
  	.bConfigurationValue	= 1,
  	/* .iConfiguration	= DYNAMIC */
  	.bmAttributes		= USB_CONFIG_ATT_SELFPOWER,
  };
  #  define gfs_add_ecm_config(cdev) \
  	usb_add_config(cdev, &gfs_ecm_config_driver)
  #else
  #  define gfs_add_ecm_config(cdev) 0
  #endif
  
  
  #ifdef CONFIG_USB_FUNCTIONFS_GENERIC
  static int gfs_do_generic_config(struct usb_configuration *c);
  
  static struct usb_configuration gfs_generic_config_driver = {
  	.label			= "FunctionFS",
  	.bind			= gfs_do_generic_config,
  	.bConfigurationValue	= 2,
  	/* .iConfiguration	= DYNAMIC */
  	.bmAttributes		= USB_CONFIG_ATT_SELFPOWER,
  };
  #  define gfs_add_generic_config(cdev) \
  	usb_add_config(cdev, &gfs_generic_config_driver)
  #else
  #  define gfs_add_generic_config(cdev) 0
  #endif
  
  
  static int gfs_bind(struct usb_composite_dev *cdev);
  static int gfs_unbind(struct usb_composite_dev *cdev);
  
  static struct usb_composite_driver gfs_driver = {
  	.name		= gfs_short_name,
  	.dev		= &gfs_dev_desc,
  	.strings	= gfs_dev_strings,
  	.bind		= gfs_bind,
  	.unbind		= gfs_unbind,
  };
  
  
  static struct ffs_data *gfs_ffs_data;
  static unsigned long gfs_registered;
  
  
  static int  gfs_init(void)
  {
  	ENTER();
  
  	return functionfs_init();
  }
  module_init(gfs_init);
  
  static void  gfs_exit(void)
  {
  	ENTER();
  
  	if (test_and_clear_bit(0, &gfs_registered))
  		usb_composite_unregister(&gfs_driver);
  
  	functionfs_cleanup();
  }
  module_exit(gfs_exit);
  
  
  static int functionfs_ready_callback(struct ffs_data *ffs)
  {
  	int ret;
  
  	ENTER();
  
  	if (WARN_ON(test_and_set_bit(0, &gfs_registered)))
  		return -EBUSY;
  
  	gfs_ffs_data = ffs;
  	ret = usb_composite_register(&gfs_driver);
  	if (unlikely(ret < 0))
  		clear_bit(0, &gfs_registered);
  	return ret;
  }
  
  static void functionfs_closed_callback(struct ffs_data *ffs)
  {
  	ENTER();
  
  	if (test_and_clear_bit(0, &gfs_registered))
  		usb_composite_unregister(&gfs_driver);
  }
  
  
  static int functionfs_check_dev_callback(const char *dev_name)
  {
  	return 0;
  }
  
  
  
  static int gfs_bind(struct usb_composite_dev *cdev)
  {
  	int ret;
  
  	ENTER();
  
  	if (WARN_ON(!gfs_ffs_data))
  		return -ENODEV;
  
  	ret = gether_setup(cdev->gadget, gfs_hostaddr);
  	if (unlikely(ret < 0))
  		goto error_quick;
  
  	gfs_dev_desc.idVendor  = cpu_to_le16(gfs_vendor_id);
  	gfs_dev_desc.idProduct = cpu_to_le16(gfs_product_id);
  
  	snprintf(gfs_manufacturer, sizeof gfs_manufacturer, "%s %s with %s",
  		 init_utsname()->sysname, init_utsname()->release,
  		 cdev->gadget->name);
  	ret = usb_string_id(cdev);
  	if (unlikely(ret < 0))
  		goto error;
  	gfs_strings[GFS_STRING_MANUFACTURER_IDX].id = ret;
  	gfs_dev_desc.iManufacturer = ret;
  
  	ret = usb_string_id(cdev);
  	if (unlikely(ret < 0))
  		goto error;
  	gfs_strings[GFS_STRING_PRODUCT_IDX].id = ret;
  	gfs_dev_desc.iProduct = ret;
  
  #ifdef CONFIG_USB_FUNCTIONFS_RNDIS
  	ret = usb_string_id(cdev);
  	if (unlikely(ret < 0))
  		goto error;
  	gfs_strings[GFS_STRING_RNDIS_CONFIG_IDX].id = ret;
  	gfs_rndis_config_driver.iConfiguration = ret;
  #endif
  
  #ifdef CONFIG_USB_FUNCTIONFS_ETH
  	ret = usb_string_id(cdev);
  	if (unlikely(ret < 0))
  		goto error;
  	gfs_strings[GFS_STRING_ECM_CONFIG_IDX].id = ret;
  	gfs_ecm_config_driver.iConfiguration = ret;
  #endif
  
  #ifdef CONFIG_USB_FUNCTIONFS_GENERIC
  	ret = usb_string_id(cdev);
  	if (unlikely(ret < 0))
  		goto error;
  	gfs_strings[GFS_STRING_GENERIC_CONFIG_IDX].id = ret;
  	gfs_generic_config_driver.iConfiguration = ret;
  #endif
  
  	ret = functionfs_bind(gfs_ffs_data, cdev);
  	if (unlikely(ret < 0))
  		goto error;
  
  	ret = gfs_add_rndis_config(cdev);
  	if (unlikely(ret < 0))
  		goto error_unbind;
  
  	ret = gfs_add_ecm_config(cdev);
  	if (unlikely(ret < 0))
  		goto error_unbind;
  
  	ret = gfs_add_generic_config(cdev);
  	if (unlikely(ret < 0))
  		goto error_unbind;
  
  	return 0;
  
  error_unbind:
  	functionfs_unbind(gfs_ffs_data);
  error:
  	gether_cleanup();
  error_quick:
  	gfs_ffs_data = NULL;
  	return ret;
  }
  
  static int gfs_unbind(struct usb_composite_dev *cdev)
  {
  	ENTER();
  
  	/* We may have been called in an error recovery frem
  	 * composite_bind() after gfs_unbind() failure so we need to
  	 * check if gfs_ffs_data is not NULL since gfs_bind() handles
  	 * all error recovery itself.  I'd rather we werent called
  	 * from composite on orror recovery, but what you're gonna
  	 * do...? */
  
  	if (gfs_ffs_data) {
  		gether_cleanup();
  		functionfs_unbind(gfs_ffs_data);
  		gfs_ffs_data = NULL;
  	}
  
  	return 0;
  }
  
  
  static int __gfs_do_config(struct usb_configuration *c,
  			   int (*eth)(struct usb_configuration *c, u8 *ethaddr),
  			   u8 *ethaddr)
  {
  	int ret;
  
  	if (WARN_ON(!gfs_ffs_data))
  		return -ENODEV;
  
  	if (gadget_is_otg(c->cdev->gadget)) {
  		c->descriptors = gfs_otg_desc;
  		c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
  	}
  
  	if (eth) {
  		ret = eth(c, ethaddr);
  		if (unlikely(ret < 0))
  			return ret;
  	}
  
  	ret = functionfs_add(c->cdev, c, gfs_ffs_data);
  	if (unlikely(ret < 0))
  		return ret;
  
  	/* 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;
  }
  
  #ifdef CONFIG_USB_FUNCTIONFS_RNDIS
  static int gfs_do_rndis_config(struct usb_configuration *c)
  {
  	ENTER();
  
  	return __gfs_do_config(c, rndis_bind_config, gfs_hostaddr);
  }
  #endif
  
  #ifdef CONFIG_USB_FUNCTIONFS_ETH
  static int gfs_do_ecm_config(struct usb_configuration *c)
  {
  	ENTER();
  
  	return __gfs_do_config(c,
  			       can_support_ecm(c->cdev->gadget)
  			     ? ecm_bind_config : geth_bind_config,
  			       gfs_hostaddr);
  }
  #endif
  
  #ifdef CONFIG_USB_FUNCTIONFS_GENERIC
  static int gfs_do_generic_config(struct usb_configuration *c)
  {
  	ENTER();
  
  	return __gfs_do_config(c, NULL, NULL);
  }
  #endif
  