2 * f_acm.c -- USB CDC serial (ACM) function driver
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)
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.
15 /* #define VERBOSE_DEBUG */
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>
27 * This CDC ACM function support just wraps control functions and
28 * notifications around the generic serial-over-usb code.
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.
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.
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.
56 struct usb_ep
*notify
;
57 struct usb_request
*notify_req
;
59 struct usb_cdc_line_coding port_line_coding
; /* 8-N-1 etc */
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 */
66 /* SerialState notification -- CDC 1.1 section 6.3.5 (OUTPUT) */
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)
77 static inline struct f_acm
*func_to_acm(struct usb_function
*f
)
79 return container_of(f
, struct f_acm
, port
.func
);
82 static inline struct f_acm
*port_to_acm(struct gserial
*p
)
84 return container_of(p
, struct f_acm
, port
);
87 /*-------------------------------------------------------------------------*/
89 /* notification endpoint uses smallish and infrequent fixed-size messages */
91 #define GS_NOTIFY_INTERVAL_MS 32
92 #define GS_NOTIFY_MAXPACKET 10 /* notification + 2 bytes */
94 /* interface and class descriptors: */
96 static struct usb_interface_assoc_descriptor
97 acm_iad_descriptor
= {
98 .bLength
= sizeof acm_iad_descriptor
,
99 .bDescriptorType
= USB_DT_INTERFACE_ASSOCIATION
,
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 */
110 static struct usb_interface_descriptor acm_control_interface_desc
= {
111 .bLength
= USB_DT_INTERFACE_SIZE
,
112 .bDescriptorType
= USB_DT_INTERFACE
,
113 /* .bInterfaceNumber = DYNAMIC */
115 .bInterfaceClass
= USB_CLASS_COMM
,
116 .bInterfaceSubClass
= USB_CDC_SUBCLASS_ACM
,
117 .bInterfaceProtocol
= USB_CDC_ACM_PROTO_AT_V25TER
,
118 /* .iInterface = DYNAMIC */
121 static struct usb_interface_descriptor acm_data_interface_desc
= {
122 .bLength
= USB_DT_INTERFACE_SIZE
,
123 .bDescriptorType
= USB_DT_INTERFACE
,
124 /* .bInterfaceNumber = DYNAMIC */
126 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
127 .bInterfaceSubClass
= 0,
128 .bInterfaceProtocol
= 0,
129 /* .iInterface = DYNAMIC */
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),
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
,
145 /* .bDataInterface = DYNAMIC */
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
,
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 */
163 /* full speed support: */
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
,
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
,
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
,
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
,
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
),
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),
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),
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
,
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),
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),
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
,
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
,
276 /* string descriptors: */
278 #define ACM_CTRL_IDX 0
279 #define ACM_DATA_IDX 1
280 #define ACM_IAD_IDX 2
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 */
290 static struct usb_gadget_strings acm_string_table
= {
291 .language
= 0x0409, /* en-us */
292 .strings
= acm_string_defs
,
295 static struct usb_gadget_strings
*acm_strings
[] = {
300 /*-------------------------------------------------------------------------*/
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.
308 static void acm_complete_set_line_coding(struct usb_ep
*ep
,
309 struct usb_request
*req
)
311 struct f_acm
*acm
= ep
->driver_data
;
312 struct usb_composite_dev
*cdev
= acm
->port
.func
.config
->cdev
;
314 if (req
->status
!= 0) {
315 dev_dbg(&cdev
->gadget
->dev
, "acm ttyGS%d completion, err %d\n",
316 acm
->port_num
, req
->status
);
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
);
326 struct usb_cdc_line_coding
*value
= req
->buf
;
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.
335 acm
->port_line_coding
= *value
;
339 static int acm_setup(struct usb_function
*f
, const struct usb_ctrlrequest
*ctrl
)
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
);
349 /* composite driver infrastructure handles everything except
350 * CDC class messages; interface activation uses set_alt().
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.
357 switch ((ctrl
->bRequestType
<< 8) | ctrl
->bRequest
) {
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
)
367 cdev
->gadget
->ep0
->driver_data
= acm
;
368 req
->complete
= acm_complete_set_line_coding
;
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
)
377 value
= min_t(unsigned, w_length
,
378 sizeof(struct usb_cdc_line_coding
));
379 memcpy(req
->buf
, &acm
->port_line_coding
, value
);
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
)
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.
394 acm
->port_handshake_bits
= w_value
;
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
);
405 /* respond with data transfer or status phase? */
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
);
413 value
= usb_ep_queue(cdev
->gadget
->ep0
, req
, GFP_ATOMIC
);
415 ERROR(cdev
, "acm response on ttyGS%d, err %d\n",
416 acm
->port_num
, value
);
419 /* device either stalls (value < 0) or reports success */
423 static int acm_set_alt(struct usb_function
*f
, unsigned intf
, unsigned alt
)
425 struct f_acm
*acm
= func_to_acm(f
);
426 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
428 /* we know alt == 0, so this is an activation or a reset */
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
);
435 if (!acm
->notify
->desc
)
436 if (config_ep_by_speed(cdev
->gadget
, f
, acm
->notify
))
439 usb_ep_enable(acm
->notify
);
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
);
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
,
452 config_ep_by_speed(cdev
->gadget
, f
,
454 acm
->port
.in
->desc
= NULL
;
455 acm
->port
.out
->desc
= NULL
;
459 gserial_connect(&acm
->port
, acm
->port_num
);
467 static void acm_disable(struct usb_function
*f
)
469 struct f_acm
*acm
= func_to_acm(f
);
470 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
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
);
477 /*-------------------------------------------------------------------------*/
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
488 * Returns zero on success or a negative errno.
490 * See section 6.3.5 of the CDC 1.1 specification for information
491 * about the only notification we issue: SerialState change.
493 static int acm_cdc_notify(struct f_acm
*acm
, u8 type
, u16 value
,
494 void *data
, unsigned length
)
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
;
503 req
= acm
->notify_req
;
504 acm
->notify_req
= NULL
;
505 acm
->pending
= false;
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
);
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
);
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
;
534 static int acm_notify_serial_state(struct f_acm
*acm
)
536 struct usb_composite_dev
*cdev
= acm
->port
.func
.config
->cdev
;
540 spin_lock(&acm
->lock
);
541 if (acm
->notify_req
) {
542 dev_dbg(&cdev
->gadget
->dev
, "acm ttyGS%d serial state %04x\n",
543 acm
->port_num
, acm
->serial_state
);
544 serial_state
= cpu_to_le16(acm
->serial_state
);
545 status
= acm_cdc_notify(acm
, USB_CDC_NOTIFY_SERIAL_STATE
,
546 0, &serial_state
, sizeof(acm
->serial_state
));
551 spin_unlock(&acm
->lock
);
555 static void acm_cdc_notify_complete(struct usb_ep
*ep
, struct usb_request
*req
)
557 struct f_acm
*acm
= req
->context
;
560 /* on this call path we do NOT hold the port spinlock,
561 * which is why ACM needs its own spinlock
563 spin_lock(&acm
->lock
);
564 if (req
->status
!= -ESHUTDOWN
)
566 acm
->notify_req
= req
;
567 spin_unlock(&acm
->lock
);
570 acm_notify_serial_state(acm
);
573 /* connect == the TTY link is open */
575 static void acm_connect(struct gserial
*port
)
577 struct f_acm
*acm
= port_to_acm(port
);
579 acm
->serial_state
|= ACM_CTRL_DSR
| ACM_CTRL_DCD
;
580 acm_notify_serial_state(acm
);
583 static void acm_disconnect(struct gserial
*port
)
585 struct f_acm
*acm
= port_to_acm(port
);
587 acm
->serial_state
&= ~(ACM_CTRL_DSR
| ACM_CTRL_DCD
);
588 acm_notify_serial_state(acm
);
591 static int acm_send_break(struct gserial
*port
, int duration
)
593 struct f_acm
*acm
= port_to_acm(port
);
596 state
= acm
->serial_state
;
597 state
&= ~ACM_CTRL_BRK
;
599 state
|= ACM_CTRL_BRK
;
601 acm
->serial_state
= state
;
602 return acm_notify_serial_state(acm
);
605 /*-------------------------------------------------------------------------*/
607 /* ACM function driver setup/binding */
609 acm_bind(struct usb_configuration
*c
, struct usb_function
*f
)
611 struct usb_composite_dev
*cdev
= c
->cdev
;
612 struct f_acm
*acm
= func_to_acm(f
);
613 struct usb_string
*us
;
617 /* REVISIT might want instance-specific strings to help
618 * distinguish instances ...
621 /* maybe allocate device-global string IDs, and patch descriptors */
622 us
= usb_gstrings_attach(cdev
, acm_strings
,
623 ARRAY_SIZE(acm_string_defs
));
626 acm_control_interface_desc
.iInterface
= us
[ACM_CTRL_IDX
].id
;
627 acm_data_interface_desc
.iInterface
= us
[ACM_DATA_IDX
].id
;
628 acm_iad_descriptor
.iFunction
= us
[ACM_IAD_IDX
].id
;
630 /* allocate instance-specific interface IDs, and patch descriptors */
631 status
= usb_interface_id(c
, f
);
634 acm
->ctrl_id
= status
;
635 acm_iad_descriptor
.bFirstInterface
= status
;
637 acm_control_interface_desc
.bInterfaceNumber
= status
;
638 acm_union_desc
.bMasterInterface0
= status
;
640 status
= usb_interface_id(c
, f
);
643 acm
->data_id
= status
;
645 acm_data_interface_desc
.bInterfaceNumber
= status
;
646 acm_union_desc
.bSlaveInterface0
= status
;
647 acm_call_mgmt_descriptor
.bDataInterface
= status
;
651 /* allocate instance-specific endpoints */
652 ep
= usb_ep_autoconfig(cdev
->gadget
, &acm_fs_in_desc
);
657 ep
= usb_ep_autoconfig(cdev
->gadget
, &acm_fs_out_desc
);
662 ep
= usb_ep_autoconfig(cdev
->gadget
, &acm_fs_notify_desc
);
667 /* allocate notification */
668 acm
->notify_req
= gs_alloc_req(ep
,
669 sizeof(struct usb_cdc_notification
) + 2,
671 if (!acm
->notify_req
)
674 acm
->notify_req
->complete
= acm_cdc_notify_complete
;
675 acm
->notify_req
->context
= acm
;
677 /* support all relevant hardware speeds... we expect that when
678 * hardware is dual speed, all bulk-capable endpoints work at
681 acm_hs_in_desc
.bEndpointAddress
= acm_fs_in_desc
.bEndpointAddress
;
682 acm_hs_out_desc
.bEndpointAddress
= acm_fs_out_desc
.bEndpointAddress
;
683 acm_hs_notify_desc
.bEndpointAddress
=
684 acm_fs_notify_desc
.bEndpointAddress
;
686 acm_ss_in_desc
.bEndpointAddress
= acm_fs_in_desc
.bEndpointAddress
;
687 acm_ss_out_desc
.bEndpointAddress
= acm_fs_out_desc
.bEndpointAddress
;
689 status
= usb_assign_descriptors(f
, acm_fs_function
, acm_hs_function
,
694 dev_dbg(&cdev
->gadget
->dev
,
695 "acm ttyGS%d: %s speed IN/%s OUT/%s NOTIFY/%s\n",
697 gadget_is_superspeed(c
->cdev
->gadget
) ? "super" :
698 gadget_is_dualspeed(c
->cdev
->gadget
) ? "dual" : "full",
699 acm
->port
.in
->name
, acm
->port
.out
->name
,
705 gs_free_req(acm
->notify
, acm
->notify_req
);
707 ERROR(cdev
, "%s/%p: can't bind, err %d\n", f
->name
, f
, status
);
712 static void acm_unbind(struct usb_configuration
*c
, struct usb_function
*f
)
714 struct f_acm
*acm
= func_to_acm(f
);
716 acm_string_defs
[0].id
= 0;
717 usb_free_all_descriptors(f
);
719 gs_free_req(acm
->notify
, acm
->notify_req
);
722 static void acm_free_func(struct usb_function
*f
)
724 struct f_acm
*acm
= func_to_acm(f
);
729 static struct usb_function
*acm_alloc_func(struct usb_function_instance
*fi
)
731 struct f_serial_opts
*opts
;
734 acm
= kzalloc(sizeof(*acm
), GFP_KERNEL
);
736 return ERR_PTR(-ENOMEM
);
738 spin_lock_init(&acm
->lock
);
740 acm
->port
.connect
= acm_connect
;
741 acm
->port
.disconnect
= acm_disconnect
;
742 acm
->port
.send_break
= acm_send_break
;
744 acm
->port
.func
.name
= "acm";
745 acm
->port
.func
.strings
= acm_strings
;
746 /* descriptors are per-instance copies */
747 acm
->port
.func
.bind
= acm_bind
;
748 acm
->port
.func
.set_alt
= acm_set_alt
;
749 acm
->port
.func
.setup
= acm_setup
;
750 acm
->port
.func
.disable
= acm_disable
;
752 opts
= container_of(fi
, struct f_serial_opts
, func_inst
);
753 acm
->port_num
= opts
->port_num
;
754 acm
->port
.func
.unbind
= acm_unbind
;
755 acm
->port
.func
.free_func
= acm_free_func
;
757 return &acm
->port
.func
;
760 static inline struct f_serial_opts
*to_f_serial_opts(struct config_item
*item
)
762 return container_of(to_config_group(item
), struct f_serial_opts
,
766 static void acm_attr_release(struct config_item
*item
)
768 struct f_serial_opts
*opts
= to_f_serial_opts(item
);
770 usb_put_function_instance(&opts
->func_inst
);
773 static struct configfs_item_operations acm_item_ops
= {
774 .release
= acm_attr_release
,
777 static ssize_t
f_acm_port_num_show(struct config_item
*item
, char *page
)
779 return sprintf(page
, "%u\n", to_f_serial_opts(item
)->port_num
);
782 CONFIGFS_ATTR_RO(f_acm_port_
, num
);
784 static struct configfs_attribute
*acm_attrs
[] = {
785 &f_acm_port_attr_num
,
789 static struct config_item_type acm_func_type
= {
790 .ct_item_ops
= &acm_item_ops
,
791 .ct_attrs
= acm_attrs
,
792 .ct_owner
= THIS_MODULE
,
795 static void acm_free_instance(struct usb_function_instance
*fi
)
797 struct f_serial_opts
*opts
;
799 opts
= container_of(fi
, struct f_serial_opts
, func_inst
);
800 gserial_free_line(opts
->port_num
);
804 static struct usb_function_instance
*acm_alloc_instance(void)
806 struct f_serial_opts
*opts
;
809 opts
= kzalloc(sizeof(*opts
), GFP_KERNEL
);
811 return ERR_PTR(-ENOMEM
);
812 opts
->func_inst
.free_func_inst
= acm_free_instance
;
813 ret
= gserial_alloc_line(&opts
->port_num
);
818 config_group_init_type_name(&opts
->func_inst
.group
, "",
820 return &opts
->func_inst
;
822 DECLARE_USB_FUNCTION_INIT(acm
, acm_alloc_instance
, acm_alloc_func
);
823 MODULE_LICENSE("GPL");