1 /*
2  * f_acm.c -- USB CDC serial (ACM) 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  * Copyright (C) 2009 by Samsung Electronics
8  * Author: Michal Nazarewicz (mina86@mina86.com)
9  *
10  * This software is distributed under the terms of the GNU General
11  * Public License ("GPL") as published by the Free Software Foundation,
12  * either version 2 of that License or (at your option) any later version.
13  */
14 
15 /* #define VERBOSE_DEBUG */
16 
17 #include <linux/slab.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/device.h>
21 #include <linux/err.h>
22 
23 #include "u_serial.h"
24 
25 
26 /*
27  * This CDC ACM function support just wraps control functions and
28  * notifications around the generic serial-over-usb code.
29  *
30  * Because CDC ACM is standardized by the USB-IF, many host operating
31  * systems have drivers for it.  Accordingly, ACM is the preferred
32  * interop solution for serial-port type connections.  The control
33  * models are often not necessary, and in any case don't do much in
34  * this bare-bones implementation.
35  *
36  * Note that even MS-Windows has some support for ACM.  However, that
37  * support is somewhat broken because when you use ACM in a composite
38  * device, having multiple interfaces confuses the poor OS.  It doesn't
39  * seem to understand CDC Union descriptors.  The new "association"
40  * descriptors (roughly equivalent to CDC Unions) may sometimes help.
41  */
42 
43 struct f_acm {
44 	struct gserial			port;
45 	u8				ctrl_id, data_id;
46 	u8				port_num;
47 
48 	u8				pending;
49 
50 	/* lock is mostly for pending and notify_req ... they get accessed
51 	 * by callbacks both from tty (open/close/break) under its spinlock,
52 	 * and notify_req.complete() which can't use that lock.
53 	 */
54 	spinlock_t			lock;
55 
56 	struct usb_ep			*notify;
57 	struct usb_request		*notify_req;
58 
59 	struct usb_cdc_line_coding	port_line_coding;	/* 8-N-1 etc */
60 
61 	/* SetControlLineState request -- CDC 1.1 section 6.2.14 (INPUT) */
62 	u16				port_handshake_bits;
63 #define ACM_CTRL_RTS	(1 << 1)	/* unused with full duplex */
64 #define ACM_CTRL_DTR	(1 << 0)	/* host is ready for data r/w */
65 
66 	/* SerialState notification -- CDC 1.1 section 6.3.5 (OUTPUT) */
67 	u16				serial_state;
68 #define ACM_CTRL_OVERRUN	(1 << 6)
69 #define ACM_CTRL_PARITY		(1 << 5)
70 #define ACM_CTRL_FRAMING	(1 << 4)
71 #define ACM_CTRL_RI		(1 << 3)
72 #define ACM_CTRL_BRK		(1 << 2)
73 #define ACM_CTRL_DSR		(1 << 1)
74 #define ACM_CTRL_DCD		(1 << 0)
75 };
76 
77 static inline struct f_acm *func_to_acm(struct usb_function *f)
78 {
79 	return container_of(f, struct f_acm, port.func);
80 }
81 
82 static inline struct f_acm *port_to_acm(struct gserial *p)
83 {
84 	return container_of(p, struct f_acm, port);
85 }
86 
87 /*-------------------------------------------------------------------------*/
88 
89 /* notification endpoint uses smallish and infrequent fixed-size messages */
90 
91 #define GS_NOTIFY_INTERVAL_MS		32
92 #define GS_NOTIFY_MAXPACKET		10	/* notification + 2 bytes */
93 
94 /* interface and class descriptors: */
95 
96 static struct usb_interface_assoc_descriptor
97 acm_iad_descriptor = {
98 	.bLength =		sizeof acm_iad_descriptor,
99 	.bDescriptorType =	USB_DT_INTERFACE_ASSOCIATION,
100 
101 	/* .bFirstInterface =	DYNAMIC, */
102 	.bInterfaceCount = 	2,	// control + data
103 	.bFunctionClass =	USB_CLASS_COMM,
104 	.bFunctionSubClass =	USB_CDC_SUBCLASS_ACM,
105 	.bFunctionProtocol =	USB_CDC_ACM_PROTO_AT_V25TER,
106 	/* .iFunction =		DYNAMIC */
107 };
108 
109 
110 static struct usb_interface_descriptor acm_control_interface_desc = {
111 	.bLength =		USB_DT_INTERFACE_SIZE,
112 	.bDescriptorType =	USB_DT_INTERFACE,
113 	/* .bInterfaceNumber = DYNAMIC */
114 	.bNumEndpoints =	1,
115 	.bInterfaceClass =	USB_CLASS_COMM,
116 	.bInterfaceSubClass =	USB_CDC_SUBCLASS_ACM,
117 	.bInterfaceProtocol =	USB_CDC_ACM_PROTO_AT_V25TER,
118 	/* .iInterface = DYNAMIC */
119 };
120 
121 static struct usb_interface_descriptor acm_data_interface_desc = {
122 	.bLength =		USB_DT_INTERFACE_SIZE,
123 	.bDescriptorType =	USB_DT_INTERFACE,
124 	/* .bInterfaceNumber = DYNAMIC */
125 	.bNumEndpoints =	2,
126 	.bInterfaceClass =	USB_CLASS_CDC_DATA,
127 	.bInterfaceSubClass =	0,
128 	.bInterfaceProtocol =	0,
129 	/* .iInterface = DYNAMIC */
130 };
131 
132 static struct usb_cdc_header_desc acm_header_desc = {
133 	.bLength =		sizeof(acm_header_desc),
134 	.bDescriptorType =	USB_DT_CS_INTERFACE,
135 	.bDescriptorSubType =	USB_CDC_HEADER_TYPE,
136 	.bcdCDC =		cpu_to_le16(0x0110),
137 };
138 
139 static struct usb_cdc_call_mgmt_descriptor
140 acm_call_mgmt_descriptor = {
141 	.bLength =		sizeof(acm_call_mgmt_descriptor),
142 	.bDescriptorType =	USB_DT_CS_INTERFACE,
143 	.bDescriptorSubType =	USB_CDC_CALL_MANAGEMENT_TYPE,
144 	.bmCapabilities =	0,
145 	/* .bDataInterface = DYNAMIC */
146 };
147 
148 static struct usb_cdc_acm_descriptor acm_descriptor = {
149 	.bLength =		sizeof(acm_descriptor),
150 	.bDescriptorType =	USB_DT_CS_INTERFACE,
151 	.bDescriptorSubType =	USB_CDC_ACM_TYPE,
152 	.bmCapabilities =	USB_CDC_CAP_LINE,
153 };
154 
155 static struct usb_cdc_union_desc acm_union_desc = {
156 	.bLength =		sizeof(acm_union_desc),
157 	.bDescriptorType =	USB_DT_CS_INTERFACE,
158 	.bDescriptorSubType =	USB_CDC_UNION_TYPE,
159 	/* .bMasterInterface0 =	DYNAMIC */
160 	/* .bSlaveInterface0 =	DYNAMIC */
161 };
162 
163 /* full speed support: */
164 
165 static struct usb_endpoint_descriptor acm_fs_notify_desc = {
166 	.bLength =		USB_DT_ENDPOINT_SIZE,
167 	.bDescriptorType =	USB_DT_ENDPOINT,
168 	.bEndpointAddress =	USB_DIR_IN,
169 	.bmAttributes =		USB_ENDPOINT_XFER_INT,
170 	.wMaxPacketSize =	cpu_to_le16(GS_NOTIFY_MAXPACKET),
171 	.bInterval =		GS_NOTIFY_INTERVAL_MS,
172 };
173 
174 static struct usb_endpoint_descriptor acm_fs_in_desc = {
175 	.bLength =		USB_DT_ENDPOINT_SIZE,
176 	.bDescriptorType =	USB_DT_ENDPOINT,
177 	.bEndpointAddress =	USB_DIR_IN,
178 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
179 };
180 
181 static struct usb_endpoint_descriptor acm_fs_out_desc = {
182 	.bLength =		USB_DT_ENDPOINT_SIZE,
183 	.bDescriptorType =	USB_DT_ENDPOINT,
184 	.bEndpointAddress =	USB_DIR_OUT,
185 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
186 };
187 
188 static struct usb_descriptor_header *acm_fs_function[] = {
189 	(struct usb_descriptor_header *) &acm_iad_descriptor,
190 	(struct usb_descriptor_header *) &acm_control_interface_desc,
191 	(struct usb_descriptor_header *) &acm_header_desc,
192 	(struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
193 	(struct usb_descriptor_header *) &acm_descriptor,
194 	(struct usb_descriptor_header *) &acm_union_desc,
195 	(struct usb_descriptor_header *) &acm_fs_notify_desc,
196 	(struct usb_descriptor_header *) &acm_data_interface_desc,
197 	(struct usb_descriptor_header *) &acm_fs_in_desc,
198 	(struct usb_descriptor_header *) &acm_fs_out_desc,
199 	NULL,
200 };
201 
202 /* high speed support: */
203 static struct usb_endpoint_descriptor acm_hs_notify_desc = {
204 	.bLength =		USB_DT_ENDPOINT_SIZE,
205 	.bDescriptorType =	USB_DT_ENDPOINT,
206 	.bEndpointAddress =	USB_DIR_IN,
207 	.bmAttributes =		USB_ENDPOINT_XFER_INT,
208 	.wMaxPacketSize =	cpu_to_le16(GS_NOTIFY_MAXPACKET),
209 	.bInterval =		USB_MS_TO_HS_INTERVAL(GS_NOTIFY_INTERVAL_MS),
210 };
211 
212 static struct usb_endpoint_descriptor acm_hs_in_desc = {
213 	.bLength =		USB_DT_ENDPOINT_SIZE,
214 	.bDescriptorType =	USB_DT_ENDPOINT,
215 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
216 	.wMaxPacketSize =	cpu_to_le16(512),
217 };
218 
219 static struct usb_endpoint_descriptor acm_hs_out_desc = {
220 	.bLength =		USB_DT_ENDPOINT_SIZE,
221 	.bDescriptorType =	USB_DT_ENDPOINT,
222 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
223 	.wMaxPacketSize =	cpu_to_le16(512),
224 };
225 
226 static struct usb_descriptor_header *acm_hs_function[] = {
227 	(struct usb_descriptor_header *) &acm_iad_descriptor,
228 	(struct usb_descriptor_header *) &acm_control_interface_desc,
229 	(struct usb_descriptor_header *) &acm_header_desc,
230 	(struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
231 	(struct usb_descriptor_header *) &acm_descriptor,
232 	(struct usb_descriptor_header *) &acm_union_desc,
233 	(struct usb_descriptor_header *) &acm_hs_notify_desc,
234 	(struct usb_descriptor_header *) &acm_data_interface_desc,
235 	(struct usb_descriptor_header *) &acm_hs_in_desc,
236 	(struct usb_descriptor_header *) &acm_hs_out_desc,
237 	NULL,
238 };
239 
240 static struct usb_endpoint_descriptor acm_ss_in_desc = {
241 	.bLength =		USB_DT_ENDPOINT_SIZE,
242 	.bDescriptorType =	USB_DT_ENDPOINT,
243 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
244 	.wMaxPacketSize =	cpu_to_le16(1024),
245 };
246 
247 static struct usb_endpoint_descriptor acm_ss_out_desc = {
248 	.bLength =		USB_DT_ENDPOINT_SIZE,
249 	.bDescriptorType =	USB_DT_ENDPOINT,
250 	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
251 	.wMaxPacketSize =	cpu_to_le16(1024),
252 };
253 
254 static struct usb_ss_ep_comp_descriptor acm_ss_bulk_comp_desc = {
255 	.bLength =              sizeof acm_ss_bulk_comp_desc,
256 	.bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
257 };
258 
259 static struct usb_descriptor_header *acm_ss_function[] = {
260 	(struct usb_descriptor_header *) &acm_iad_descriptor,
261 	(struct usb_descriptor_header *) &acm_control_interface_desc,
262 	(struct usb_descriptor_header *) &acm_header_desc,
263 	(struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
264 	(struct usb_descriptor_header *) &acm_descriptor,
265 	(struct usb_descriptor_header *) &acm_union_desc,
266 	(struct usb_descriptor_header *) &acm_hs_notify_desc,
267 	(struct usb_descriptor_header *) &acm_ss_bulk_comp_desc,
268 	(struct usb_descriptor_header *) &acm_data_interface_desc,
269 	(struct usb_descriptor_header *) &acm_ss_in_desc,
270 	(struct usb_descriptor_header *) &acm_ss_bulk_comp_desc,
271 	(struct usb_descriptor_header *) &acm_ss_out_desc,
272 	(struct usb_descriptor_header *) &acm_ss_bulk_comp_desc,
273 	NULL,
274 };
275 
276 /* string descriptors: */
277 
278 #define ACM_CTRL_IDX	0
279 #define ACM_DATA_IDX	1
280 #define ACM_IAD_IDX	2
281 
282 /* static strings, in UTF-8 */
283 static struct usb_string acm_string_defs[] = {
284 	[ACM_CTRL_IDX].s = "CDC Abstract Control Model (ACM)",
285 	[ACM_DATA_IDX].s = "CDC ACM Data",
286 	[ACM_IAD_IDX ].s = "CDC Serial",
287 	{  } /* end of list */
288 };
289 
290 static struct usb_gadget_strings acm_string_table = {
291 	.language =		0x0409,	/* en-us */
292 	.strings =		acm_string_defs,
293 };
294 
295 static struct usb_gadget_strings *acm_strings[] = {
296 	&acm_string_table,
297 	NULL,
298 };
299 
300 /*-------------------------------------------------------------------------*/
301 
302 /* ACM control ... data handling is delegated to tty library code.
303  * The main task of this function is to activate and deactivate
304  * that code based on device state; track parameters like line
305  * speed, handshake state, and so on; and issue notifications.
306  */
307 
308 static void acm_complete_set_line_coding(struct usb_ep *ep,
309 		struct usb_request *req)
310 {
311 	struct f_acm	*acm = ep->driver_data;
312 	struct usb_composite_dev *cdev = acm->port.func.config->cdev;
313 
314 	if (req->status != 0) {
315 		dev_dbg(&cdev->gadget->dev, "acm ttyGS%d completion, err %d\n",
316 			acm->port_num, req->status);
317 		return;
318 	}
319 
320 	/* normal completion */
321 	if (req->actual != sizeof(acm->port_line_coding)) {
322 		dev_dbg(&cdev->gadget->dev, "acm ttyGS%d short resp, len %d\n",
323 			acm->port_num, req->actual);
324 		usb_ep_set_halt(ep);
325 	} else {
326 		struct usb_cdc_line_coding	*value = req->buf;
327 
328 		/* REVISIT:  we currently just remember this data.
329 		 * If we change that, (a) validate it first, then
330 		 * (b) update whatever hardware needs updating,
331 		 * (c) worry about locking.  This is information on
332 		 * the order of 9600-8-N-1 ... most of which means
333 		 * nothing unless we control a real RS232 line.
334 		 */
335 		acm->port_line_coding = *value;
336 	}
337 }
338 
339 static int acm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
340 {
341 	struct f_acm		*acm = func_to_acm(f);
342 	struct usb_composite_dev *cdev = f->config->cdev;
343 	struct usb_request	*req = cdev->req;
344 	int			value = -EOPNOTSUPP;
345 	u16			w_index = le16_to_cpu(ctrl->wIndex);
346 	u16			w_value = le16_to_cpu(ctrl->wValue);
347 	u16			w_length = le16_to_cpu(ctrl->wLength);
348 
349 	/* composite driver infrastructure handles everything except
350 	 * CDC class messages; interface activation uses set_alt().
351 	 *
352 	 * Note CDC spec table 4 lists the ACM request profile.  It requires
353 	 * encapsulated command support ... we don't handle any, and respond
354 	 * to them by stalling.  Options include get/set/clear comm features
355 	 * (not that useful) and SEND_BREAK.
356 	 */
357 	switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
358 
359 	/* SET_LINE_CODING ... just read and save what the host sends */
360 	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
361 			| USB_CDC_REQ_SET_LINE_CODING:
362 		if (w_length != sizeof(struct usb_cdc_line_coding)
363 				|| w_index != acm->ctrl_id)
364 			goto invalid;
365 
366 		value = w_length;
367 		cdev->gadget->ep0->driver_data = acm;
368 		req->complete = acm_complete_set_line_coding;
369 		break;
370 
371 	/* GET_LINE_CODING ... return what host sent, or initial value */
372 	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
373 			| USB_CDC_REQ_GET_LINE_CODING:
374 		if (w_index != acm->ctrl_id)
375 			goto invalid;
376 
377 		value = min_t(unsigned, w_length,
378 				sizeof(struct usb_cdc_line_coding));
379 		memcpy(req->buf, &acm->port_line_coding, value);
380 		break;
381 
382 	/* SET_CONTROL_LINE_STATE ... save what the host sent */
383 	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
384 			| USB_CDC_REQ_SET_CONTROL_LINE_STATE:
385 		if (w_index != acm->ctrl_id)
386 			goto invalid;
387 
388 		value = 0;
389 
390 		/* FIXME we should not allow data to flow until the
391 		 * host sets the ACM_CTRL_DTR bit; and when it clears
392 		 * that bit, we should return to that no-flow state.
393 		 */
394 		acm->port_handshake_bits = w_value;
395 		break;
396 
397 	default:
398 invalid:
399 		dev_vdbg(&cdev->gadget->dev,
400 			 "invalid control req%02x.%02x v%04x i%04x l%d\n",
401 			 ctrl->bRequestType, ctrl->bRequest,
402 			 w_value, w_index, w_length);
403 	}
404 
405 	/* respond with data transfer or status phase? */
406 	if (value >= 0) {
407 		dev_dbg(&cdev->gadget->dev,
408 			"acm ttyGS%d req%02x.%02x v%04x i%04x l%d\n",
409 			acm->port_num, ctrl->bRequestType, ctrl->bRequest,
410 			w_value, w_index, w_length);
411 		req->zero = 0;
412 		req->length = value;
413 		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
414 		if (value < 0)
415 			ERROR(cdev, "acm response on ttyGS%d, err %d\n",
416 					acm->port_num, value);
417 	}
418 
419 	/* device either stalls (value < 0) or reports success */
420 	return value;
421 }
422 
423 static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
424 {
425 	struct f_acm		*acm = func_to_acm(f);
426 	struct usb_composite_dev *cdev = f->config->cdev;
427 
428 	/* we know alt == 0, so this is an activation or a reset */
429 
430 	if (intf == acm->ctrl_id) {
431 		dev_vdbg(&cdev->gadget->dev,
432 				"reset acm control interface %d\n", intf);
433 		usb_ep_disable(acm->notify);
434 
435 		if (!acm->notify->desc)
436 			if (config_ep_by_speed(cdev->gadget, f, acm->notify))
437 				return -EINVAL;
438 
439 		usb_ep_enable(acm->notify);
440 
441 	} else if (intf == acm->data_id) {
442 		if (acm->notify->enabled) {
443 			dev_dbg(&cdev->gadget->dev,
444 				"reset acm ttyGS%d\n", acm->port_num);
445 			gserial_disconnect(&acm->port);
446 		}
447 		if (!acm->port.in->desc || !acm->port.out->desc) {
448 			dev_dbg(&cdev->gadget->dev,
449 				"activate acm ttyGS%d\n", acm->port_num);
450 			if (config_ep_by_speed(cdev->gadget, f,
451 					       acm->port.in) ||
452 			    config_ep_by_speed(cdev->gadget, f,
453 					       acm->port.out)) {
454 				acm->port.in->desc = NULL;
455 				acm->port.out->desc = NULL;
456 				return -EINVAL;
457 			}
458 		}
459 		gserial_connect(&acm->port, acm->port_num);
460 
461 	} else
462 		return -EINVAL;
463 
464 	return 0;
465 }
466 
467 static void acm_disable(struct usb_function *f)
468 {
469 	struct f_acm	*acm = func_to_acm(f);
470 	struct usb_composite_dev *cdev = f->config->cdev;
471 
472 	dev_dbg(&cdev->gadget->dev, "acm ttyGS%d deactivated\n", acm->port_num);
473 	gserial_disconnect(&acm->port);
474 	usb_ep_disable(acm->notify);
475 }
476 
477 /*-------------------------------------------------------------------------*/
478 
479 /**
480  * acm_cdc_notify - issue CDC notification to host
481  * @acm: wraps host to be notified
482  * @type: notification type
483  * @value: Refer to cdc specs, wValue field.
484  * @data: data to be sent
485  * @length: size of data
486  * Context: irqs blocked, acm->lock held, acm_notify_req non-null
487  *
488  * Returns zero on success or a negative errno.
489  *
490  * See section 6.3.5 of the CDC 1.1 specification for information
491  * about the only notification we issue:  SerialState change.
492  */
493 static int acm_cdc_notify(struct f_acm *acm, u8 type, u16 value,
494 		void *data, unsigned length)
495 {
496 	struct usb_ep			*ep = acm->notify;
497 	struct usb_request		*req;
498 	struct usb_cdc_notification	*notify;
499 	const unsigned			len = sizeof(*notify) + length;
500 	void				*buf;
501 	int				status;
502 
503 	req = acm->notify_req;
504 	acm->notify_req = NULL;
505 	acm->pending = false;
506 
507 	req->length = len;
508 	notify = req->buf;
509 	buf = notify + 1;
510 
511 	notify->bmRequestType = USB_DIR_IN | USB_TYPE_CLASS
512 			| USB_RECIP_INTERFACE;
513 	notify->bNotificationType = type;
514 	notify->wValue = cpu_to_le16(value);
515 	notify->wIndex = cpu_to_le16(acm->ctrl_id);
516 	notify->wLength = cpu_to_le16(length);
517 	memcpy(buf, data, length);
518 
519 	/* ep_queue() can complete immediately if it fills the fifo... */
520 	spin_unlock(&acm->lock);
521 	status = usb_ep_queue(ep, req, GFP_ATOMIC);
522 	spin_lock(&acm->lock);
523 
524 	if (status < 0) {
525 		ERROR(acm->port.func.config->cdev,
526 				"acm ttyGS%d can't notify serial state, %d\n",
527 				acm->port_num, status);
528 		acm->notify_req = req;
529 	}
530 
531 	return status;
532 }
533 
534 static int acm_notify_serial_state(struct f_acm *acm)
535 {
536 	struct usb_composite_dev *cdev = acm->port.func.config->cdev;
537 	int			status;
538 
539 	spin_lock(&acm->lock);
540 	if (acm->notify_req) {
541 		dev_dbg(&cdev->gadget->dev, "acm ttyGS%d serial state %04x\n",
542 			acm->port_num, acm->serial_state);
543 		status = acm_cdc_notify(acm, USB_CDC_NOTIFY_SERIAL_STATE,
544 				0, &acm->serial_state, sizeof(acm->serial_state));
545 	} else {
546 		acm->pending = true;
547 		status = 0;
548 	}
549 	spin_unlock(&acm->lock);
550 	return status;
551 }
552 
553 static void acm_cdc_notify_complete(struct usb_ep *ep, struct usb_request *req)
554 {
555 	struct f_acm		*acm = req->context;
556 	u8			doit = false;
557 
558 	/* on this call path we do NOT hold the port spinlock,
559 	 * which is why ACM needs its own spinlock
560 	 */
561 	spin_lock(&acm->lock);
562 	if (req->status != -ESHUTDOWN)
563 		doit = acm->pending;
564 	acm->notify_req = req;
565 	spin_unlock(&acm->lock);
566 
567 	if (doit)
568 		acm_notify_serial_state(acm);
569 }
570 
571 /* connect == the TTY link is open */
572 
573 static void acm_connect(struct gserial *port)
574 {
575 	struct f_acm		*acm = port_to_acm(port);
576 
577 	acm->serial_state |= ACM_CTRL_DSR | ACM_CTRL_DCD;
578 	acm_notify_serial_state(acm);
579 }
580 
581 static void acm_disconnect(struct gserial *port)
582 {
583 	struct f_acm		*acm = port_to_acm(port);
584 
585 	acm->serial_state &= ~(ACM_CTRL_DSR | ACM_CTRL_DCD);
586 	acm_notify_serial_state(acm);
587 }
588 
589 static int acm_send_break(struct gserial *port, int duration)
590 {
591 	struct f_acm		*acm = port_to_acm(port);
592 	u16			state;
593 
594 	state = acm->serial_state;
595 	state &= ~ACM_CTRL_BRK;
596 	if (duration)
597 		state |= ACM_CTRL_BRK;
598 
599 	acm->serial_state = state;
600 	return acm_notify_serial_state(acm);
601 }
602 
603 /*-------------------------------------------------------------------------*/
604 
605 /* ACM function driver setup/binding */
606 static int
607 acm_bind(struct usb_configuration *c, struct usb_function *f)
608 {
609 	struct usb_composite_dev *cdev = c->cdev;
610 	struct f_acm		*acm = func_to_acm(f);
611 	struct usb_string	*us;
612 	int			status;
613 	struct usb_ep		*ep;
614 
615 	/* REVISIT might want instance-specific strings to help
616 	 * distinguish instances ...
617 	 */
618 
619 	/* maybe allocate device-global string IDs, and patch descriptors */
620 	us = usb_gstrings_attach(cdev, acm_strings,
621 			ARRAY_SIZE(acm_string_defs));
622 	if (IS_ERR(us))
623 		return PTR_ERR(us);
624 	acm_control_interface_desc.iInterface = us[ACM_CTRL_IDX].id;
625 	acm_data_interface_desc.iInterface = us[ACM_DATA_IDX].id;
626 	acm_iad_descriptor.iFunction = us[ACM_IAD_IDX].id;
627 
628 	/* allocate instance-specific interface IDs, and patch descriptors */
629 	status = usb_interface_id(c, f);
630 	if (status < 0)
631 		goto fail;
632 	acm->ctrl_id = status;
633 	acm_iad_descriptor.bFirstInterface = status;
634 
635 	acm_control_interface_desc.bInterfaceNumber = status;
636 	acm_union_desc .bMasterInterface0 = status;
637 
638 	status = usb_interface_id(c, f);
639 	if (status < 0)
640 		goto fail;
641 	acm->data_id = status;
642 
643 	acm_data_interface_desc.bInterfaceNumber = status;
644 	acm_union_desc.bSlaveInterface0 = status;
645 	acm_call_mgmt_descriptor.bDataInterface = status;
646 
647 	status = -ENODEV;
648 
649 	/* allocate instance-specific endpoints */
650 	ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_in_desc);
651 	if (!ep)
652 		goto fail;
653 	acm->port.in = ep;
654 
655 	ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_out_desc);
656 	if (!ep)
657 		goto fail;
658 	acm->port.out = ep;
659 
660 	ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_notify_desc);
661 	if (!ep)
662 		goto fail;
663 	acm->notify = ep;
664 
665 	/* allocate notification */
666 	acm->notify_req = gs_alloc_req(ep,
667 			sizeof(struct usb_cdc_notification) + 2,
668 			GFP_KERNEL);
669 	if (!acm->notify_req)
670 		goto fail;
671 
672 	acm->notify_req->complete = acm_cdc_notify_complete;
673 	acm->notify_req->context = acm;
674 
675 	/* support all relevant hardware speeds... we expect that when
676 	 * hardware is dual speed, all bulk-capable endpoints work at
677 	 * both speeds
678 	 */
679 	acm_hs_in_desc.bEndpointAddress = acm_fs_in_desc.bEndpointAddress;
680 	acm_hs_out_desc.bEndpointAddress = acm_fs_out_desc.bEndpointAddress;
681 	acm_hs_notify_desc.bEndpointAddress =
682 		acm_fs_notify_desc.bEndpointAddress;
683 
684 	acm_ss_in_desc.bEndpointAddress = acm_fs_in_desc.bEndpointAddress;
685 	acm_ss_out_desc.bEndpointAddress = acm_fs_out_desc.bEndpointAddress;
686 
687 	status = usb_assign_descriptors(f, acm_fs_function, acm_hs_function,
688 			acm_ss_function);
689 	if (status)
690 		goto fail;
691 
692 	dev_dbg(&cdev->gadget->dev,
693 		"acm ttyGS%d: %s speed IN/%s OUT/%s NOTIFY/%s\n",
694 		acm->port_num,
695 		gadget_is_superspeed(c->cdev->gadget) ? "super" :
696 		gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
697 		acm->port.in->name, acm->port.out->name,
698 		acm->notify->name);
699 	return 0;
700 
701 fail:
702 	if (acm->notify_req)
703 		gs_free_req(acm->notify, acm->notify_req);
704 
705 	ERROR(cdev, "%s/%p: can't bind, err %d\n", f->name, f, status);
706 
707 	return status;
708 }
709 
710 static void acm_unbind(struct usb_configuration *c, struct usb_function *f)
711 {
712 	struct f_acm		*acm = func_to_acm(f);
713 
714 	acm_string_defs[0].id = 0;
715 	usb_free_all_descriptors(f);
716 	if (acm->notify_req)
717 		gs_free_req(acm->notify, acm->notify_req);
718 }
719 
720 static void acm_free_func(struct usb_function *f)
721 {
722 	struct f_acm		*acm = func_to_acm(f);
723 
724 	kfree(acm);
725 }
726 
727 static struct usb_function *acm_alloc_func(struct usb_function_instance *fi)
728 {
729 	struct f_serial_opts *opts;
730 	struct f_acm *acm;
731 
732 	acm = kzalloc(sizeof(*acm), GFP_KERNEL);
733 	if (!acm)
734 		return ERR_PTR(-ENOMEM);
735 
736 	spin_lock_init(&acm->lock);
737 
738 	acm->port.connect = acm_connect;
739 	acm->port.disconnect = acm_disconnect;
740 	acm->port.send_break = acm_send_break;
741 
742 	acm->port.func.name = "acm";
743 	acm->port.func.strings = acm_strings;
744 	/* descriptors are per-instance copies */
745 	acm->port.func.bind = acm_bind;
746 	acm->port.func.set_alt = acm_set_alt;
747 	acm->port.func.setup = acm_setup;
748 	acm->port.func.disable = acm_disable;
749 
750 	opts = container_of(fi, struct f_serial_opts, func_inst);
751 	acm->port_num = opts->port_num;
752 	acm->port.func.unbind = acm_unbind;
753 	acm->port.func.free_func = acm_free_func;
754 
755 	return &acm->port.func;
756 }
757 
758 static inline struct f_serial_opts *to_f_serial_opts(struct config_item *item)
759 {
760 	return container_of(to_config_group(item), struct f_serial_opts,
761 			func_inst.group);
762 }
763 
764 static void acm_attr_release(struct config_item *item)
765 {
766 	struct f_serial_opts *opts = to_f_serial_opts(item);
767 
768 	usb_put_function_instance(&opts->func_inst);
769 }
770 
771 static struct configfs_item_operations acm_item_ops = {
772 	.release                = acm_attr_release,
773 };
774 
775 static ssize_t f_acm_port_num_show(struct config_item *item, char *page)
776 {
777 	return sprintf(page, "%u\n", to_f_serial_opts(item)->port_num);
778 }
779 
780 CONFIGFS_ATTR_RO(f_acm_port_, num);
781 
782 static struct configfs_attribute *acm_attrs[] = {
783 	&f_acm_port_attr_num,
784 	NULL,
785 };
786 
787 static struct config_item_type acm_func_type = {
788 	.ct_item_ops    = &acm_item_ops,
789 	.ct_attrs	= acm_attrs,
790 	.ct_owner       = THIS_MODULE,
791 };
792 
793 static void acm_free_instance(struct usb_function_instance *fi)
794 {
795 	struct f_serial_opts *opts;
796 
797 	opts = container_of(fi, struct f_serial_opts, func_inst);
798 	gserial_free_line(opts->port_num);
799 	kfree(opts);
800 }
801 
802 static struct usb_function_instance *acm_alloc_instance(void)
803 {
804 	struct f_serial_opts *opts;
805 	int ret;
806 
807 	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
808 	if (!opts)
809 		return ERR_PTR(-ENOMEM);
810 	opts->func_inst.free_func_inst = acm_free_instance;
811 	ret = gserial_alloc_line(&opts->port_num);
812 	if (ret) {
813 		kfree(opts);
814 		return ERR_PTR(ret);
815 	}
816 	config_group_init_type_name(&opts->func_inst.group, "",
817 			&acm_func_type);
818 	return &opts->func_inst;
819 }
820 DECLARE_USB_FUNCTION_INIT(acm, acm_alloc_instance, acm_alloc_func);
821 MODULE_LICENSE("GPL");
822