[mirror_ubuntu-artful-kernel.git] / drivers / usb / gadget / function / f_serial.c

/*
 * f_serial.c - generic USB serial function driver
 *
 * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
 * Copyright (C) 2008 by David Brownell
 * Copyright (C) 2008 by Nokia Corporation
 *
 * This software is distributed under the terms of the GNU General
 * Public License ("GPL") as published by the Free Software Foundation,
 * either version 2 of that License or (at your option) any later version.
 */

#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>

#include "u_serial.h"
#include "gadget_chips.h"


/*
 * This function packages a simple "generic serial" port with no real
 * control mechanisms, just raw data transfer over two bulk endpoints.
 *
 * Because it's not standardized, this isn't as interoperable as the
 * CDC ACM driver.  However, for many purposes it's just as functional
 * if you can arrange appropriate host side drivers.
 */

struct f_gser {
	struct gserial			port;
	u8				data_id;
	u8				port_num;
};

static inline struct f_gser *func_to_gser(struct usb_function *f)
{
	return container_of(f, struct f_gser, port.func);
}

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

/* interface descriptor: */

static struct usb_interface_descriptor gser_interface_desc = {
	.bLength =		USB_DT_INTERFACE_SIZE,
	.bDescriptorType =	USB_DT_INTERFACE,
	/* .bInterfaceNumber = DYNAMIC */
	.bNumEndpoints =	2,
	.bInterfaceClass =	USB_CLASS_VENDOR_SPEC,
	.bInterfaceSubClass =	0,
	.bInterfaceProtocol =	0,
	/* .iInterface = DYNAMIC */
};

/* full speed support: */

static struct usb_endpoint_descriptor gser_fs_in_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,
	.bEndpointAddress =	USB_DIR_IN,
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
};

static struct usb_endpoint_descriptor gser_fs_out_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,
	.bEndpointAddress =	USB_DIR_OUT,
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
};

static struct usb_descriptor_header *gser_fs_function[] = {
	(struct usb_descriptor_header *) &gser_interface_desc,
	(struct usb_descriptor_header *) &gser_fs_in_desc,
	(struct usb_descriptor_header *) &gser_fs_out_desc,
	NULL,
};

/* high speed support: */

static struct usb_endpoint_descriptor gser_hs_in_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	.wMaxPacketSize =	cpu_to_le16(512),
};

static struct usb_endpoint_descriptor gser_hs_out_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	.wMaxPacketSize =	cpu_to_le16(512),
};

static struct usb_descriptor_header *gser_hs_function[] = {
	(struct usb_descriptor_header *) &gser_interface_desc,
	(struct usb_descriptor_header *) &gser_hs_in_desc,
	(struct usb_descriptor_header *) &gser_hs_out_desc,
	NULL,
};

static struct usb_endpoint_descriptor gser_ss_in_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	.wMaxPacketSize =	cpu_to_le16(1024),
};

static struct usb_endpoint_descriptor gser_ss_out_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	.wMaxPacketSize =	cpu_to_le16(1024),
};

static struct usb_ss_ep_comp_descriptor gser_ss_bulk_comp_desc = {
	.bLength =              sizeof gser_ss_bulk_comp_desc,
	.bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
};

static struct usb_descriptor_header *gser_ss_function[] = {
	(struct usb_descriptor_header *) &gser_interface_desc,
	(struct usb_descriptor_header *) &gser_ss_in_desc,
	(struct usb_descriptor_header *) &gser_ss_bulk_comp_desc,
	(struct usb_descriptor_header *) &gser_ss_out_desc,
	(struct usb_descriptor_header *) &gser_ss_bulk_comp_desc,
	NULL,
};

/* string descriptors: */

static struct usb_string gser_string_defs[] = {
	[0].s = "Generic Serial",
	{  } /* end of list */
};

static struct usb_gadget_strings gser_string_table = {
	.language =		0x0409,	/* en-us */
	.strings =		gser_string_defs,
};

static struct usb_gadget_strings *gser_strings[] = {
	&gser_string_table,
	NULL,
};

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

static int gser_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
{
	struct f_gser		*gser = func_to_gser(f);
	struct usb_composite_dev *cdev = f->config->cdev;

	/* we know alt == 0, so this is an activation or a reset */

	if (gser->port.in->driver_data) {
		DBG(cdev, "reset generic ttyGS%d\n", gser->port_num);
		gserial_disconnect(&gser->port);
	}
	if (!gser->port.in->desc || !gser->port.out->desc) {
		DBG(cdev, "activate generic ttyGS%d\n", gser->port_num);
		if (config_ep_by_speed(cdev->gadget, f, gser->port.in) ||
		    config_ep_by_speed(cdev->gadget, f, gser->port.out)) {
			gser->port.in->desc = NULL;
			gser->port.out->desc = NULL;
			return -EINVAL;
		}
	}
	gserial_connect(&gser->port, gser->port_num);
	return 0;
}

static void gser_disable(struct usb_function *f)
{
	struct f_gser	*gser = func_to_gser(f);
	struct usb_composite_dev *cdev = f->config->cdev;

	DBG(cdev, "generic ttyGS%d deactivated\n", gser->port_num);
	gserial_disconnect(&gser->port);
}

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

/* serial function driver setup/binding */

static int gser_bind(struct usb_configuration *c, struct usb_function *f)
{
	struct usb_composite_dev *cdev = c->cdev;
	struct f_gser		*gser = func_to_gser(f);
	int			status;
	struct usb_ep		*ep;

	/* REVISIT might want instance-specific strings to help
	 * distinguish instances ...
	 */

	/* maybe allocate device-global string ID */
	if (gser_string_defs[0].id == 0) {
		status = usb_string_id(c->cdev);
		if (status < 0)
			return status;
		gser_string_defs[0].id = status;
	}

	/* allocate instance-specific interface IDs */
	status = usb_interface_id(c, f);
	if (status < 0)
		goto fail;
	gser->data_id = status;
	gser_interface_desc.bInterfaceNumber = status;

	status = -ENODEV;

	/* allocate instance-specific endpoints */
	ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_in_desc);
	if (!ep)
		goto fail;
	gser->port.in = ep;
	ep->driver_data = cdev;	/* claim */

	ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_out_desc);
	if (!ep)
		goto fail;
	gser->port.out = ep;
	ep->driver_data = cdev;	/* claim */

	/* support all relevant hardware speeds... we expect that when
	 * hardware is dual speed, all bulk-capable endpoints work at
	 * both speeds
	 */
	gser_hs_in_desc.bEndpointAddress = gser_fs_in_desc.bEndpointAddress;
	gser_hs_out_desc.bEndpointAddress = gser_fs_out_desc.bEndpointAddress;

	gser_ss_in_desc.bEndpointAddress = gser_fs_in_desc.bEndpointAddress;
	gser_ss_out_desc.bEndpointAddress = gser_fs_out_desc.bEndpointAddress;

	status = usb_assign_descriptors(f, gser_fs_function, gser_hs_function,
			gser_ss_function);
	if (status)
		goto fail;
	DBG(cdev, "generic ttyGS%d: %s speed IN/%s OUT/%s\n",
			gser->port_num,
			gadget_is_superspeed(c->cdev->gadget) ? "super" :
			gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
			gser->port.in->name, gser->port.out->name);
	return 0;

fail:
	/* we might as well release our claims on endpoints */
	if (gser->port.out)
		gser->port.out->driver_data = NULL;
	if (gser->port.in)
		gser->port.in->driver_data = NULL;

	ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);

	return status;
}

static inline struct f_serial_opts *to_f_serial_opts(struct config_item *item)
{
	return container_of(to_config_group(item), struct f_serial_opts,
			    func_inst.group);
}

CONFIGFS_ATTR_STRUCT(f_serial_opts);
static ssize_t f_serial_attr_show(struct config_item *item,
				  struct configfs_attribute *attr,
				  char *page)
{
	struct f_serial_opts *opts = to_f_serial_opts(item);
	struct f_serial_opts_attribute *f_serial_opts_attr =
		container_of(attr, struct f_serial_opts_attribute, attr);
	ssize_t ret = 0;

	if (f_serial_opts_attr->show)
		ret = f_serial_opts_attr->show(opts, page);

	return ret;
}

static void serial_attr_release(struct config_item *item)
{
	struct f_serial_opts *opts = to_f_serial_opts(item);

	usb_put_function_instance(&opts->func_inst);
}

static struct configfs_item_operations serial_item_ops = {
	.release	= serial_attr_release,
	.show_attribute = f_serial_attr_show,
};

static ssize_t f_serial_port_num_show(struct f_serial_opts *opts, char *page)
{
	return sprintf(page, "%u\n", opts->port_num);
}

static struct f_serial_opts_attribute f_serial_port_num =
	__CONFIGFS_ATTR_RO(port_num, f_serial_port_num_show);

static struct configfs_attribute *acm_attrs[] = {
	&f_serial_port_num.attr,
	NULL,
};

static struct config_item_type serial_func_type = {
	.ct_item_ops	= &serial_item_ops,
	.ct_attrs	= acm_attrs,
	.ct_owner	= THIS_MODULE,
};

static void gser_free_inst(struct usb_function_instance *f)
{
	struct f_serial_opts *opts;

	opts = container_of(f, struct f_serial_opts, func_inst);
	gserial_free_line(opts->port_num);
	kfree(opts);
}

static struct usb_function_instance *gser_alloc_inst(void)
{
	struct f_serial_opts *opts;
	int ret;

	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
	if (!opts)
		return ERR_PTR(-ENOMEM);

	opts->func_inst.free_func_inst = gser_free_inst;
	ret = gserial_alloc_line(&opts->port_num);
	if (ret) {
		kfree(opts);
		return ERR_PTR(ret);
	}
	config_group_init_type_name(&opts->func_inst.group, "",
				    &serial_func_type);

	return &opts->func_inst;
}

static void gser_free(struct usb_function *f)
{
	struct f_gser *serial;

	serial = func_to_gser(f);
	kfree(serial);
}

static void gser_unbind(struct usb_configuration *c, struct usb_function *f)
{
	usb_free_all_descriptors(f);
}

static struct usb_function *gser_alloc(struct usb_function_instance *fi)
{
	struct f_gser	*gser;
	struct f_serial_opts *opts;

	/* allocate and initialize one new instance */
	gser = kzalloc(sizeof(*gser), GFP_KERNEL);
	if (!gser)
		return ERR_PTR(-ENOMEM);

	opts = container_of(fi, struct f_serial_opts, func_inst);

	gser->port_num = opts->port_num;

	gser->port.func.name = "gser";
	gser->port.func.strings = gser_strings;
	gser->port.func.bind = gser_bind;
	gser->port.func.unbind = gser_unbind;
	gser->port.func.set_alt = gser_set_alt;
	gser->port.func.disable = gser_disable;
	gser->port.func.free_func = gser_free;

	return &gser->port.func;
}

DECLARE_USB_FUNCTION_INIT(gser, gser_alloc_inst, gser_alloc);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Al Borchers");
MODULE_AUTHOR("David Brownell");
Commit	Line	Data
61d8baea DB	1	/*
	2	* f_serial.c - generic USB serial function driver
	3	*
	4	* Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
	5	* Copyright (C) 2008 by David Brownell
	6	* Copyright (C) 2008 by Nokia Corporation
	7	*
	8	* This software is distributed under the terms of the GNU General
	9	* Public License ("GPL") as published by the Free Software Foundation,
	10	* either version 2 of that License or (at your option) any later version.
	11	*/
	12
5a0e3ad6	13	#include <linux/slab.h>
61d8baea	14	#include <linux/kernel.h>
60540ea2	15	#include <linux/module.h>
61d8baea DB	16	#include <linux/device.h>
	17
	18	#include "u_serial.h"
	19	#include "gadget_chips.h"
	20
	21
	22	/*
	23	* This function packages a simple "generic serial" port with no real
	24	* control mechanisms, just raw data transfer over two bulk endpoints.
	25	*
	26	* Because it's not standardized, this isn't as interoperable as the
	27	* CDC ACM driver. However, for many purposes it's just as functional
	28	* if you can arrange appropriate host side drivers.
	29	*/
	30
61d8baea DB	31	struct f_gser {
	32	struct gserial port;
	33	u8 data_id;
	34	u8 port_num;
61d8baea DB	35	};
	36
	37	static inline struct f_gser func_to_gser(struct usb_function f)
	38	{
	39	return container_of(f, struct f_gser, port.func);
	40	}
	41
	42	/-------------------------------------------------------------------------/
	43
	44	/* interface descriptor: */
	45
60540ea2	46	static struct usb_interface_descriptor gser_interface_desc = {
61d8baea DB	47	.bLength = USB_DT_INTERFACE_SIZE,
	48	.bDescriptorType = USB_DT_INTERFACE,
	49	/* .bInterfaceNumber = DYNAMIC */
	50	.bNumEndpoints = 2,
	51	.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
	52	.bInterfaceSubClass = 0,
	53	.bInterfaceProtocol = 0,
	54	/* .iInterface = DYNAMIC */
	55	};
	56
	57	/* full speed support: */
	58
60540ea2	59	static struct usb_endpoint_descriptor gser_fs_in_desc = {
61d8baea DB	60	.bLength = USB_DT_ENDPOINT_SIZE,
	61	.bDescriptorType = USB_DT_ENDPOINT,
	62	.bEndpointAddress = USB_DIR_IN,
	63	.bmAttributes = USB_ENDPOINT_XFER_BULK,
	64	};
	65
60540ea2	66	static struct usb_endpoint_descriptor gser_fs_out_desc = {
61d8baea DB	67	.bLength = USB_DT_ENDPOINT_SIZE,
	68	.bDescriptorType = USB_DT_ENDPOINT,
	69	.bEndpointAddress = USB_DIR_OUT,
	70	.bmAttributes = USB_ENDPOINT_XFER_BULK,
	71	};
	72
60540ea2	73	static struct usb_descriptor_header *gser_fs_function[] = {
61d8baea DB	74	(struct usb_descriptor_header *) &gser_interface_desc,
	75	(struct usb_descriptor_header *) &gser_fs_in_desc,
	76	(struct usb_descriptor_header *) &gser_fs_out_desc,
	77	NULL,
	78	};
	79
	80	/* high speed support: */
	81
60540ea2	82	static struct usb_endpoint_descriptor gser_hs_in_desc = {
61d8baea DB	83	.bLength = USB_DT_ENDPOINT_SIZE,
	84	.bDescriptorType = USB_DT_ENDPOINT,
	85	.bmAttributes = USB_ENDPOINT_XFER_BULK,
551509d2	86	.wMaxPacketSize = cpu_to_le16(512),
61d8baea DB	87	};
61d8baea DB	88
60540ea2	89	static struct usb_endpoint_descriptor gser_hs_out_desc = {
61d8baea DB	90	.bLength = USB_DT_ENDPOINT_SIZE,
	91	.bDescriptorType = USB_DT_ENDPOINT,
	92	.bmAttributes = USB_ENDPOINT_XFER_BULK,
551509d2	93	.wMaxPacketSize = cpu_to_le16(512),
61d8baea DB	94	};
61d8baea DB	95
60540ea2	96	static struct usb_descriptor_header *gser_hs_function[] = {
61d8baea DB	97	(struct usb_descriptor_header *) &gser_interface_desc,
	98	(struct usb_descriptor_header *) &gser_hs_in_desc,
	99	(struct usb_descriptor_header *) &gser_hs_out_desc,
	100	NULL,
	101	};
	102
60540ea2	103	static struct usb_endpoint_descriptor gser_ss_in_desc = {
6fecfb05 SAS	104	.bLength = USB_DT_ENDPOINT_SIZE,
	105	.bDescriptorType = USB_DT_ENDPOINT,
	106	.bmAttributes = USB_ENDPOINT_XFER_BULK,
	107	.wMaxPacketSize = cpu_to_le16(1024),
	108	};
	109
60540ea2	110	static struct usb_endpoint_descriptor gser_ss_out_desc = {
6fecfb05 SAS	111	.bLength = USB_DT_ENDPOINT_SIZE,
	112	.bDescriptorType = USB_DT_ENDPOINT,
	113	.bmAttributes = USB_ENDPOINT_XFER_BULK,
	114	.wMaxPacketSize = cpu_to_le16(1024),
	115	};
	116
60540ea2	117	static struct usb_ss_ep_comp_descriptor gser_ss_bulk_comp_desc = {
6fecfb05 SAS	118	.bLength = sizeof gser_ss_bulk_comp_desc,
	119	.bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
	120	};
	121
60540ea2	122	static struct usb_descriptor_header *gser_ss_function[] = {
6fecfb05 SAS	123	(struct usb_descriptor_header *) &gser_interface_desc,
	124	(struct usb_descriptor_header *) &gser_ss_in_desc,
	125	(struct usb_descriptor_header *) &gser_ss_bulk_comp_desc,
	126	(struct usb_descriptor_header *) &gser_ss_out_desc,
	127	(struct usb_descriptor_header *) &gser_ss_bulk_comp_desc,
	128	NULL,
	129	};
	130
61d8baea DB	131	/* string descriptors: */
	132
	133	static struct usb_string gser_string_defs[] = {
	134	[0].s = "Generic Serial",
	135	{ } /* end of list */
	136	};
	137
	138	static struct usb_gadget_strings gser_string_table = {
	139	.language = 0x0409, /* en-us */
	140	.strings = gser_string_defs,
	141	};
	142
	143	static struct usb_gadget_strings *gser_strings[] = {
	144	&gser_string_table,
	145	NULL,
	146	};
	147
	148	/-------------------------------------------------------------------------/
	149
	150	static int gser_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
	151	{
	152	struct f_gser *gser = func_to_gser(f);
	153	struct usb_composite_dev *cdev = f->config->cdev;
	154
	155	/* we know alt == 0, so this is an activation or a reset */
	156
	157	if (gser->port.in->driver_data) {
	158	DBG(cdev, "reset generic ttyGS%d\n", gser->port_num);
	159	gserial_disconnect(&gser->port);
ea2a1df7 TB	160	}
ea2a1df7 TB	161	if (!gser->port.in->desc \|\| !gser->port.out->desc) {
61d8baea	162	DBG(cdev, "activate generic ttyGS%d\n", gser->port_num);
fef69644 RJ	163	if (config_ep_by_speed(cdev->gadget, f, gser->port.in) \|\|
fef69644 RJ	164	config_ep_by_speed(cdev->gadget, f, gser->port.out)) {
ea2a1df7 TB	165	gser->port.in->desc = NULL;
	166	gser->port.out->desc = NULL;
	167	return -EINVAL;
	168	}
61d8baea DB	169	}
	170	gserial_connect(&gser->port, gser->port_num);
	171	return 0;
	172	}
	173
	174	static void gser_disable(struct usb_function *f)
	175	{
	176	struct f_gser *gser = func_to_gser(f);
	177	struct usb_composite_dev *cdev = f->config->cdev;
	178
	179	DBG(cdev, "generic ttyGS%d deactivated\n", gser->port_num);
	180	gserial_disconnect(&gser->port);
	181	}
	182
	183	/-------------------------------------------------------------------------/
	184
	185	/* serial function driver setup/binding */
	186
60540ea2	187	static int gser_bind(struct usb_configuration c, struct usb_function f)
61d8baea DB	188	{
	189	struct usb_composite_dev *cdev = c->cdev;
	190	struct f_gser *gser = func_to_gser(f);
	191	int status;
	192	struct usb_ep *ep;
	193
60540ea2 AP	194	/* REVISIT might want instance-specific strings to help
	195	* distinguish instances ...
	196	*/
	197
	198	/* maybe allocate device-global string ID */
	199	if (gser_string_defs[0].id == 0) {
	200	status = usb_string_id(c->cdev);
	201	if (status < 0)
	202	return status;
	203	gser_string_defs[0].id = status;
	204	}
	205
61d8baea DB	206	/* allocate instance-specific interface IDs */
	207	status = usb_interface_id(c, f);
	208	if (status < 0)
	209	goto fail;
	210	gser->data_id = status;
	211	gser_interface_desc.bInterfaceNumber = status;
	212
	213	status = -ENODEV;
	214
	215	/* allocate instance-specific endpoints */
	216	ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_in_desc);
	217	if (!ep)
	218	goto fail;
	219	gser->port.in = ep;
	220	ep->driver_data = cdev; /* claim */
	221
	222	ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_out_desc);
	223	if (!ep)
	224	goto fail;
	225	gser->port.out = ep;
	226	ep->driver_data = cdev; /* claim */
	227
61d8baea DB	228	/* support all relevant hardware speeds... we expect that when
	229	* hardware is dual speed, all bulk-capable endpoints work at
	230	* both speeds
	231	*/
10287bae SAS	232	gser_hs_in_desc.bEndpointAddress = gser_fs_in_desc.bEndpointAddress;
10287bae SAS	233	gser_hs_out_desc.bEndpointAddress = gser_fs_out_desc.bEndpointAddress;
61d8baea	234
10287bae SAS	235	gser_ss_in_desc.bEndpointAddress = gser_fs_in_desc.bEndpointAddress;
	236	gser_ss_out_desc.bEndpointAddress = gser_fs_out_desc.bEndpointAddress;
	237
	238	status = usb_assign_descriptors(f, gser_fs_function, gser_hs_function,
	239	gser_ss_function);
	240	if (status)
	241	goto fail;
61d8baea DB	242	DBG(cdev, "generic ttyGS%d: %s speed IN/%s OUT/%s\n",
61d8baea DB	243	gser->port_num,
6fecfb05	244	gadget_is_superspeed(c->cdev->gadget) ? "super" :
61d8baea DB	245	gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
	246	gser->port.in->name, gser->port.out->name);
	247	return 0;
	248
	249	fail:
	250	/* we might as well release our claims on endpoints */
	251	if (gser->port.out)
	252	gser->port.out->driver_data = NULL;
	253	if (gser->port.in)
	254	gser->port.in->driver_data = NULL;
	255
	256	ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
	257
	258	return status;
	259	}
	260
0b6a1e6f AP	261	static inline struct f_serial_opts to_f_serial_opts(struct config_item item)
	262	{
	263	return container_of(to_config_group(item), struct f_serial_opts,
	264	func_inst.group);
	265	}
	266
	267	CONFIGFS_ATTR_STRUCT(f_serial_opts);
	268	static ssize_t f_serial_attr_show(struct config_item *item,
	269	struct configfs_attribute *attr,
	270	char *page)
	271	{
	272	struct f_serial_opts *opts = to_f_serial_opts(item);
	273	struct f_serial_opts_attribute *f_serial_opts_attr =
	274	container_of(attr, struct f_serial_opts_attribute, attr);
	275	ssize_t ret = 0;
	276
	277	if (f_serial_opts_attr->show)
	278	ret = f_serial_opts_attr->show(opts, page);
	279
	280	return ret;
	281	}
	282
	283	static void serial_attr_release(struct config_item *item)
	284	{
	285	struct f_serial_opts *opts = to_f_serial_opts(item);
	286
	287	usb_put_function_instance(&opts->func_inst);
	288	}
	289
	290	static struct configfs_item_operations serial_item_ops = {
	291	.release = serial_attr_release,
	292	.show_attribute = f_serial_attr_show,
	293	};
	294
	295	static ssize_t f_serial_port_num_show(struct f_serial_opts opts, char page)
	296	{
	297	return sprintf(page, "%u\n", opts->port_num);
	298	}
	299
	300	static struct f_serial_opts_attribute f_serial_port_num =
	301	__CONFIGFS_ATTR_RO(port_num, f_serial_port_num_show);
	302
	303	static struct configfs_attribute *acm_attrs[] = {
	304	&f_serial_port_num.attr,
	305	NULL,
	306	};
	307
	308	static struct config_item_type serial_func_type = {
	309	.ct_item_ops = &serial_item_ops,
	310	.ct_attrs = acm_attrs,
	311	.ct_owner = THIS_MODULE,
	312	};
	313
60540ea2 AP	314	static void gser_free_inst(struct usb_function_instance *f)
	315	{
	316	struct f_serial_opts *opts;
	317
	318	opts = container_of(f, struct f_serial_opts, func_inst);
	319	gserial_free_line(opts->port_num);
	320	kfree(opts);
	321	}
	322
	323	static struct usb_function_instance *gser_alloc_inst(void)
	324	{
	325	struct f_serial_opts *opts;
	326	int ret;
	327
	328	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
	329	if (!opts)
	330	return ERR_PTR(-ENOMEM);
	331
	332	opts->func_inst.free_func_inst = gser_free_inst;
	333	ret = gserial_alloc_line(&opts->port_num);
	334	if (ret) {
	335	kfree(opts);
	336	return ERR_PTR(ret);
	337	}
0b6a1e6f AP	338	config_group_init_type_name(&opts->func_inst.group, "",
0b6a1e6f AP	339	&serial_func_type);
60540ea2 AP	340
	341	return &opts->func_inst;
	342	}
	343
	344	static void gser_free(struct usb_function *f)
	345	{
	346	struct f_gser *serial;
	347
	348	serial = func_to_gser(f);
	349	kfree(serial);
	350	}
	351
	352	static void gser_unbind(struct usb_configuration c, struct usb_function f)
	353	{
	354	usb_free_all_descriptors(f);
	355	}
	356
b3d589f2	357	static struct usb_function gser_alloc(struct usb_function_instance fi)
60540ea2 AP	358	{
	359	struct f_gser *gser;
	360	struct f_serial_opts *opts;
	361
	362	/* allocate and initialize one new instance */
	363	gser = kzalloc(sizeof(*gser), GFP_KERNEL);
	364	if (!gser)
	365	return ERR_PTR(-ENOMEM);
	366
	367	opts = container_of(fi, struct f_serial_opts, func_inst);
	368
	369	gser->port_num = opts->port_num;
	370
	371	gser->port.func.name = "gser";
	372	gser->port.func.strings = gser_strings;
	373	gser->port.func.bind = gser_bind;
	374	gser->port.func.unbind = gser_unbind;
	375	gser->port.func.set_alt = gser_set_alt;
	376	gser->port.func.disable = gser_disable;
	377	gser->port.func.free_func = gser_free;
	378
	379	return &gser->port.func;
	380	}
	381
	382	DECLARE_USB_FUNCTION_INIT(gser, gser_alloc_inst, gser_alloc);
	383	MODULE_LICENSE("GPL");
	384	MODULE_AUTHOR("Al Borchers");
	385	MODULE_AUTHOR("David Brownell");