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
13#include <linux/slab.h>
14#include <linux/kernel.h>
15#include <linux/module.h>
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
31struct f_gser {
32	struct gserial			port;
33	u8				data_id;
34	u8				port_num;
35};
36
37static 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
46static struct usb_interface_descriptor gser_interface_desc = {
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
59static struct usb_endpoint_descriptor gser_fs_in_desc = {
60	.bLength =		USB_DT_ENDPOINT_SIZE,
61	.bDescriptorType =	USB_DT_ENDPOINT,
62	.bEndpointAddress =	USB_DIR_IN,
63	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
64};
65
66static struct usb_endpoint_descriptor gser_fs_out_desc = {
67	.bLength =		USB_DT_ENDPOINT_SIZE,
68	.bDescriptorType =	USB_DT_ENDPOINT,
69	.bEndpointAddress =	USB_DIR_OUT,
70	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
71};
72
73static struct usb_descriptor_header *gser_fs_function[] = {
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
82static struct usb_endpoint_descriptor gser_hs_in_desc = {
83	.bLength =		USB_DT_ENDPOINT_SIZE,
84	.bDescriptorType =	USB_DT_ENDPOINT,
85	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
86	.wMaxPacketSize =	cpu_to_le16(512),
87};
88
89static struct usb_endpoint_descriptor gser_hs_out_desc = {
90	.bLength =		USB_DT_ENDPOINT_SIZE,
91	.bDescriptorType =	USB_DT_ENDPOINT,
92	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
93	.wMaxPacketSize =	cpu_to_le16(512),
94};
95
96static struct usb_descriptor_header *gser_hs_function[] = {
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
103static struct usb_endpoint_descriptor gser_ss_in_desc = {
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
110static struct usb_endpoint_descriptor gser_ss_out_desc = {
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
117static struct usb_ss_ep_comp_descriptor gser_ss_bulk_comp_desc = {
118	.bLength =              sizeof gser_ss_bulk_comp_desc,
119	.bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
120};
121
122static struct usb_descriptor_header *gser_ss_function[] = {
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
131/* string descriptors: */
132
133static struct usb_string gser_string_defs[] = {
134	[0].s = "Generic Serial",
135	{  } /* end of list */
136};
137
138static struct usb_gadget_strings gser_string_table = {
139	.language =		0x0409,	/* en-us */
140	.strings =		gser_string_defs,
141};
142
143static struct usb_gadget_strings *gser_strings[] = {
144	&gser_string_table,
145	NULL,
146};
147
148/*-------------------------------------------------------------------------*/
149
150static 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		dev_dbg(&cdev->gadget->dev,
159			"reset generic ttyGS%d\n", gser->port_num);
160		gserial_disconnect(&gser->port);
161	}
162	if (!gser->port.in->desc || !gser->port.out->desc) {
163		dev_dbg(&cdev->gadget->dev,
164			"activate generic ttyGS%d\n", gser->port_num);
165		if (config_ep_by_speed(cdev->gadget, f, gser->port.in) ||
166		    config_ep_by_speed(cdev->gadget, f, gser->port.out)) {
167			gser->port.in->desc = NULL;
168			gser->port.out->desc = NULL;
169			return -EINVAL;
170		}
171	}
172	gserial_connect(&gser->port, gser->port_num);
173	return 0;
174}
175
176static void gser_disable(struct usb_function *f)
177{
178	struct f_gser	*gser = func_to_gser(f);
179	struct usb_composite_dev *cdev = f->config->cdev;
180
181	dev_dbg(&cdev->gadget->dev,
182		"generic ttyGS%d deactivated\n", gser->port_num);
183	gserial_disconnect(&gser->port);
184}
185
186/*-------------------------------------------------------------------------*/
187
188/* serial function driver setup/binding */
189
190static int gser_bind(struct usb_configuration *c, struct usb_function *f)
191{
192	struct usb_composite_dev *cdev = c->cdev;
193	struct f_gser		*gser = func_to_gser(f);
194	int			status;
195	struct usb_ep		*ep;
196
197	/* REVISIT might want instance-specific strings to help
198	 * distinguish instances ...
199	 */
200
201	/* maybe allocate device-global string ID */
202	if (gser_string_defs[0].id == 0) {
203		status = usb_string_id(c->cdev);
204		if (status < 0)
205			return status;
206		gser_string_defs[0].id = status;
207	}
208
209	/* allocate instance-specific interface IDs */
210	status = usb_interface_id(c, f);
211	if (status < 0)
212		goto fail;
213	gser->data_id = status;
214	gser_interface_desc.bInterfaceNumber = status;
215
216	status = -ENODEV;
217
218	/* allocate instance-specific endpoints */
219	ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_in_desc);
220	if (!ep)
221		goto fail;
222	gser->port.in = ep;
223	ep->driver_data = cdev;	/* claim */
224
225	ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_out_desc);
226	if (!ep)
227		goto fail;
228	gser->port.out = ep;
229	ep->driver_data = cdev;	/* claim */
230
231	/* support all relevant hardware speeds... we expect that when
232	 * hardware is dual speed, all bulk-capable endpoints work at
233	 * both speeds
234	 */
235	gser_hs_in_desc.bEndpointAddress = gser_fs_in_desc.bEndpointAddress;
236	gser_hs_out_desc.bEndpointAddress = gser_fs_out_desc.bEndpointAddress;
237
238	gser_ss_in_desc.bEndpointAddress = gser_fs_in_desc.bEndpointAddress;
239	gser_ss_out_desc.bEndpointAddress = gser_fs_out_desc.bEndpointAddress;
240
241	status = usb_assign_descriptors(f, gser_fs_function, gser_hs_function,
242			gser_ss_function);
243	if (status)
244		goto fail;
245	dev_dbg(&cdev->gadget->dev, "generic ttyGS%d: %s speed IN/%s OUT/%s\n",
246		gser->port_num,
247		gadget_is_superspeed(c->cdev->gadget) ? "super" :
248		gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
249		gser->port.in->name, gser->port.out->name);
250	return 0;
251
252fail:
253	/* we might as well release our claims on endpoints */
254	if (gser->port.out)
255		gser->port.out->driver_data = NULL;
256	if (gser->port.in)
257		gser->port.in->driver_data = NULL;
258
259	ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
260
261	return status;
262}
263
264static inline struct f_serial_opts *to_f_serial_opts(struct config_item *item)
265{
266	return container_of(to_config_group(item), struct f_serial_opts,
267			    func_inst.group);
268}
269
270CONFIGFS_ATTR_STRUCT(f_serial_opts);
271static ssize_t f_serial_attr_show(struct config_item *item,
272				  struct configfs_attribute *attr,
273				  char *page)
274{
275	struct f_serial_opts *opts = to_f_serial_opts(item);
276	struct f_serial_opts_attribute *f_serial_opts_attr =
277		container_of(attr, struct f_serial_opts_attribute, attr);
278	ssize_t ret = 0;
279
280	if (f_serial_opts_attr->show)
281		ret = f_serial_opts_attr->show(opts, page);
282
283	return ret;
284}
285
286static void serial_attr_release(struct config_item *item)
287{
288	struct f_serial_opts *opts = to_f_serial_opts(item);
289
290	usb_put_function_instance(&opts->func_inst);
291}
292
293static struct configfs_item_operations serial_item_ops = {
294	.release	= serial_attr_release,
295	.show_attribute = f_serial_attr_show,
296};
297
298static ssize_t f_serial_port_num_show(struct f_serial_opts *opts, char *page)
299{
300	return sprintf(page, "%u\n", opts->port_num);
301}
302
303static struct f_serial_opts_attribute f_serial_port_num =
304	__CONFIGFS_ATTR_RO(port_num, f_serial_port_num_show);
305
306static struct configfs_attribute *acm_attrs[] = {
307	&f_serial_port_num.attr,
308	NULL,
309};
310
311static struct config_item_type serial_func_type = {
312	.ct_item_ops	= &serial_item_ops,
313	.ct_attrs	= acm_attrs,
314	.ct_owner	= THIS_MODULE,
315};
316
317static void gser_free_inst(struct usb_function_instance *f)
318{
319	struct f_serial_opts *opts;
320
321	opts = container_of(f, struct f_serial_opts, func_inst);
322	gserial_free_line(opts->port_num);
323	kfree(opts);
324}
325
326static struct usb_function_instance *gser_alloc_inst(void)
327{
328	struct f_serial_opts *opts;
329	int ret;
330
331	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
332	if (!opts)
333		return ERR_PTR(-ENOMEM);
334
335	opts->func_inst.free_func_inst = gser_free_inst;
336	ret = gserial_alloc_line(&opts->port_num);
337	if (ret) {
338		kfree(opts);
339		return ERR_PTR(ret);
340	}
341	config_group_init_type_name(&opts->func_inst.group, "",
342				    &serial_func_type);
343
344	return &opts->func_inst;
345}
346
347static void gser_free(struct usb_function *f)
348{
349	struct f_gser *serial;
350
351	serial = func_to_gser(f);
352	kfree(serial);
353}
354
355static void gser_unbind(struct usb_configuration *c, struct usb_function *f)
356{
357	usb_free_all_descriptors(f);
358}
359
360static struct usb_function *gser_alloc(struct usb_function_instance *fi)
361{
362	struct f_gser	*gser;
363	struct f_serial_opts *opts;
364
365	/* allocate and initialize one new instance */
366	gser = kzalloc(sizeof(*gser), GFP_KERNEL);
367	if (!gser)
368		return ERR_PTR(-ENOMEM);
369
370	opts = container_of(fi, struct f_serial_opts, func_inst);
371
372	gser->port_num = opts->port_num;
373
374	gser->port.func.name = "gser";
375	gser->port.func.strings = gser_strings;
376	gser->port.func.bind = gser_bind;
377	gser->port.func.unbind = gser_unbind;
378	gser->port.func.set_alt = gser_set_alt;
379	gser->port.func.disable = gser_disable;
380	gser->port.func.free_func = gser_free;
381
382	return &gser->port.func;
383}
384
385DECLARE_USB_FUNCTION_INIT(gser, gser_alloc_inst, gser_alloc);
386MODULE_LICENSE("GPL");
387MODULE_AUTHOR("Al Borchers");
388MODULE_AUTHOR("David Brownell");
389