2008-06-20 01:18:40 +00:00
|
|
|
/*
|
|
|
|
* f_acm.c -- USB CDC serial (ACM) function driver
|
|
|
|
*
|
|
|
|
* Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
|
|
|
|
* Copyright (C) 2008 by David Brownell
|
|
|
|
* Copyright (C) 2008 by Nokia Corporation
|
2009-10-28 15:57:30 +00:00
|
|
|
* Copyright (C) 2009 by Samsung Electronics
|
2012-01-13 14:05:16 +00:00
|
|
|
* Author: Michal Nazarewicz (mina86@mina86.com)
|
2008-06-20 01:18:40 +00:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* #define VERBOSE_DEBUG */
|
|
|
|
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2008-06-20 01:18:40 +00:00
|
|
|
#include <linux/kernel.h>
|
2012-12-23 20:10:07 +00:00
|
|
|
#include <linux/module.h>
|
2008-06-20 01:18:40 +00:00
|
|
|
#include <linux/device.h>
|
2012-12-23 20:10:07 +00:00
|
|
|
#include <linux/err.h>
|
2008-06-20 01:18:40 +00:00
|
|
|
|
|
|
|
#include "u_serial.h"
|
|
|
|
#include "gadget_chips.h"
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This CDC ACM function support just wraps control functions and
|
|
|
|
* notifications around the generic serial-over-usb code.
|
|
|
|
*
|
|
|
|
* Because CDC ACM is standardized by the USB-IF, many host operating
|
|
|
|
* systems have drivers for it. Accordingly, ACM is the preferred
|
|
|
|
* interop solution for serial-port type connections. The control
|
|
|
|
* models are often not necessary, and in any case don't do much in
|
|
|
|
* this bare-bones implementation.
|
|
|
|
*
|
|
|
|
* Note that even MS-Windows has some support for ACM. However, that
|
|
|
|
* support is somewhat broken because when you use ACM in a composite
|
|
|
|
* device, having multiple interfaces confuses the poor OS. It doesn't
|
|
|
|
* seem to understand CDC Union descriptors. The new "association"
|
|
|
|
* descriptors (roughly equivalent to CDC Unions) may sometimes help.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct f_acm {
|
|
|
|
struct gserial port;
|
|
|
|
u8 ctrl_id, data_id;
|
|
|
|
u8 port_num;
|
|
|
|
|
2008-08-07 01:49:57 +00:00
|
|
|
u8 pending;
|
|
|
|
|
|
|
|
/* lock is mostly for pending and notify_req ... they get accessed
|
|
|
|
* by callbacks both from tty (open/close/break) under its spinlock,
|
|
|
|
* and notify_req.complete() which can't use that lock.
|
|
|
|
*/
|
|
|
|
spinlock_t lock;
|
|
|
|
|
2008-06-20 01:18:40 +00:00
|
|
|
struct usb_ep *notify;
|
2008-08-07 01:49:57 +00:00
|
|
|
struct usb_request *notify_req;
|
2008-06-20 01:18:40 +00:00
|
|
|
|
|
|
|
struct usb_cdc_line_coding port_line_coding; /* 8-N-1 etc */
|
2008-08-07 01:49:57 +00:00
|
|
|
|
|
|
|
/* SetControlLineState request -- CDC 1.1 section 6.2.14 (INPUT) */
|
2008-06-20 01:18:40 +00:00
|
|
|
u16 port_handshake_bits;
|
2008-08-07 01:49:57 +00:00
|
|
|
#define ACM_CTRL_RTS (1 << 1) /* unused with full duplex */
|
|
|
|
#define ACM_CTRL_DTR (1 << 0) /* host is ready for data r/w */
|
|
|
|
|
|
|
|
/* SerialState notification -- CDC 1.1 section 6.3.5 (OUTPUT) */
|
|
|
|
u16 serial_state;
|
|
|
|
#define ACM_CTRL_OVERRUN (1 << 6)
|
|
|
|
#define ACM_CTRL_PARITY (1 << 5)
|
|
|
|
#define ACM_CTRL_FRAMING (1 << 4)
|
|
|
|
#define ACM_CTRL_RI (1 << 3)
|
|
|
|
#define ACM_CTRL_BRK (1 << 2)
|
|
|
|
#define ACM_CTRL_DSR (1 << 1)
|
|
|
|
#define ACM_CTRL_DCD (1 << 0)
|
2008-06-20 01:18:40 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline struct f_acm *func_to_acm(struct usb_function *f)
|
|
|
|
{
|
|
|
|
return container_of(f, struct f_acm, port.func);
|
|
|
|
}
|
|
|
|
|
2008-08-07 01:49:57 +00:00
|
|
|
static inline struct f_acm *port_to_acm(struct gserial *p)
|
|
|
|
{
|
|
|
|
return container_of(p, struct f_acm, port);
|
|
|
|
}
|
|
|
|
|
2008-06-20 01:18:40 +00:00
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* notification endpoint uses smallish and infrequent fixed-size messages */
|
|
|
|
|
2012-10-22 20:14:57 +00:00
|
|
|
#define GS_NOTIFY_INTERVAL_MS 32
|
2008-08-07 01:49:57 +00:00
|
|
|
#define GS_NOTIFY_MAXPACKET 10 /* notification + 2 bytes */
|
2008-06-20 01:18:40 +00:00
|
|
|
|
|
|
|
/* interface and class descriptors: */
|
|
|
|
|
2009-10-28 15:57:30 +00:00
|
|
|
static struct usb_interface_assoc_descriptor
|
|
|
|
acm_iad_descriptor = {
|
|
|
|
.bLength = sizeof acm_iad_descriptor,
|
|
|
|
.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
|
|
|
|
|
|
|
|
/* .bFirstInterface = DYNAMIC, */
|
|
|
|
.bInterfaceCount = 2, // control + data
|
|
|
|
.bFunctionClass = USB_CLASS_COMM,
|
|
|
|
.bFunctionSubClass = USB_CDC_SUBCLASS_ACM,
|
2010-09-10 17:35:03 +00:00
|
|
|
.bFunctionProtocol = USB_CDC_ACM_PROTO_AT_V25TER,
|
2009-10-28 15:57:30 +00:00
|
|
|
/* .iFunction = DYNAMIC */
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-05-05 10:53:13 +00:00
|
|
|
static struct usb_interface_descriptor acm_control_interface_desc = {
|
2008-06-20 01:18:40 +00:00
|
|
|
.bLength = USB_DT_INTERFACE_SIZE,
|
|
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
|
|
/* .bInterfaceNumber = DYNAMIC */
|
|
|
|
.bNumEndpoints = 1,
|
|
|
|
.bInterfaceClass = USB_CLASS_COMM,
|
|
|
|
.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
|
|
|
|
.bInterfaceProtocol = USB_CDC_ACM_PROTO_AT_V25TER,
|
|
|
|
/* .iInterface = DYNAMIC */
|
|
|
|
};
|
|
|
|
|
2010-05-05 10:53:13 +00:00
|
|
|
static struct usb_interface_descriptor acm_data_interface_desc = {
|
2008-06-20 01:18:40 +00:00
|
|
|
.bLength = USB_DT_INTERFACE_SIZE,
|
|
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
|
|
/* .bInterfaceNumber = DYNAMIC */
|
|
|
|
.bNumEndpoints = 2,
|
|
|
|
.bInterfaceClass = USB_CLASS_CDC_DATA,
|
|
|
|
.bInterfaceSubClass = 0,
|
|
|
|
.bInterfaceProtocol = 0,
|
|
|
|
/* .iInterface = DYNAMIC */
|
|
|
|
};
|
|
|
|
|
2010-05-05 10:53:13 +00:00
|
|
|
static struct usb_cdc_header_desc acm_header_desc = {
|
2008-06-20 01:18:40 +00:00
|
|
|
.bLength = sizeof(acm_header_desc),
|
|
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
|
|
|
.bDescriptorSubType = USB_CDC_HEADER_TYPE,
|
2009-02-11 22:11:36 +00:00
|
|
|
.bcdCDC = cpu_to_le16(0x0110),
|
2008-06-20 01:18:40 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct usb_cdc_call_mgmt_descriptor
|
2010-05-05 10:53:13 +00:00
|
|
|
acm_call_mgmt_descriptor = {
|
2008-06-20 01:18:40 +00:00
|
|
|
.bLength = sizeof(acm_call_mgmt_descriptor),
|
|
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
|
|
|
.bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE,
|
|
|
|
.bmCapabilities = 0,
|
|
|
|
/* .bDataInterface = DYNAMIC */
|
|
|
|
};
|
|
|
|
|
2010-05-05 10:53:13 +00:00
|
|
|
static struct usb_cdc_acm_descriptor acm_descriptor = {
|
2008-06-20 01:18:40 +00:00
|
|
|
.bLength = sizeof(acm_descriptor),
|
|
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
|
|
|
.bDescriptorSubType = USB_CDC_ACM_TYPE,
|
2008-08-07 01:49:57 +00:00
|
|
|
.bmCapabilities = USB_CDC_CAP_LINE,
|
2008-06-20 01:18:40 +00:00
|
|
|
};
|
|
|
|
|
2010-05-05 10:53:13 +00:00
|
|
|
static struct usb_cdc_union_desc acm_union_desc = {
|
2008-06-20 01:18:40 +00:00
|
|
|
.bLength = sizeof(acm_union_desc),
|
|
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
|
|
|
.bDescriptorSubType = USB_CDC_UNION_TYPE,
|
|
|
|
/* .bMasterInterface0 = DYNAMIC */
|
|
|
|
/* .bSlaveInterface0 = DYNAMIC */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* full speed support: */
|
|
|
|
|
2010-05-05 10:53:13 +00:00
|
|
|
static struct usb_endpoint_descriptor acm_fs_notify_desc = {
|
2008-06-20 01:18:40 +00:00
|
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_IN,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_INT,
|
2009-02-11 22:11:36 +00:00
|
|
|
.wMaxPacketSize = cpu_to_le16(GS_NOTIFY_MAXPACKET),
|
2012-10-22 20:14:57 +00:00
|
|
|
.bInterval = GS_NOTIFY_INTERVAL_MS,
|
2008-06-20 01:18:40 +00:00
|
|
|
};
|
|
|
|
|
2010-05-05 10:53:13 +00:00
|
|
|
static struct usb_endpoint_descriptor acm_fs_in_desc = {
|
2008-06-20 01:18:40 +00:00
|
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_IN,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
|
|
};
|
|
|
|
|
2010-05-05 10:53:13 +00:00
|
|
|
static struct usb_endpoint_descriptor acm_fs_out_desc = {
|
2008-06-20 01:18:40 +00:00
|
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_OUT,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
|
|
};
|
|
|
|
|
2010-05-05 10:53:13 +00:00
|
|
|
static struct usb_descriptor_header *acm_fs_function[] = {
|
2009-10-28 15:57:30 +00:00
|
|
|
(struct usb_descriptor_header *) &acm_iad_descriptor,
|
2008-06-20 01:18:40 +00:00
|
|
|
(struct usb_descriptor_header *) &acm_control_interface_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_header_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
|
|
|
|
(struct usb_descriptor_header *) &acm_descriptor,
|
|
|
|
(struct usb_descriptor_header *) &acm_union_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_fs_notify_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_data_interface_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_fs_in_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_fs_out_desc,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* high speed support: */
|
2010-05-05 10:53:13 +00:00
|
|
|
static struct usb_endpoint_descriptor acm_hs_notify_desc = {
|
2008-06-20 01:18:40 +00:00
|
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_IN,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_INT,
|
2009-02-11 22:11:36 +00:00
|
|
|
.wMaxPacketSize = cpu_to_le16(GS_NOTIFY_MAXPACKET),
|
2012-10-22 20:14:57 +00:00
|
|
|
.bInterval = USB_MS_TO_HS_INTERVAL(GS_NOTIFY_INTERVAL_MS),
|
2008-06-20 01:18:40 +00:00
|
|
|
};
|
|
|
|
|
2010-05-05 10:53:13 +00:00
|
|
|
static struct usb_endpoint_descriptor acm_hs_in_desc = {
|
2008-06-20 01:18:40 +00:00
|
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
2009-02-11 22:11:36 +00:00
|
|
|
.wMaxPacketSize = cpu_to_le16(512),
|
2008-06-20 01:18:40 +00:00
|
|
|
};
|
|
|
|
|
2010-05-05 10:53:13 +00:00
|
|
|
static struct usb_endpoint_descriptor acm_hs_out_desc = {
|
2008-06-20 01:18:40 +00:00
|
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
2009-02-11 22:11:36 +00:00
|
|
|
.wMaxPacketSize = cpu_to_le16(512),
|
2008-06-20 01:18:40 +00:00
|
|
|
};
|
|
|
|
|
2010-05-05 10:53:13 +00:00
|
|
|
static struct usb_descriptor_header *acm_hs_function[] = {
|
2009-10-28 15:57:30 +00:00
|
|
|
(struct usb_descriptor_header *) &acm_iad_descriptor,
|
2008-06-20 01:18:40 +00:00
|
|
|
(struct usb_descriptor_header *) &acm_control_interface_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_header_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
|
|
|
|
(struct usb_descriptor_header *) &acm_descriptor,
|
|
|
|
(struct usb_descriptor_header *) &acm_union_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_hs_notify_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_data_interface_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_hs_in_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_hs_out_desc,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2012-02-06 17:46:36 +00:00
|
|
|
static struct usb_endpoint_descriptor acm_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 acm_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 acm_ss_bulk_comp_desc = {
|
|
|
|
.bLength = sizeof acm_ss_bulk_comp_desc,
|
|
|
|
.bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct usb_descriptor_header *acm_ss_function[] = {
|
|
|
|
(struct usb_descriptor_header *) &acm_iad_descriptor,
|
|
|
|
(struct usb_descriptor_header *) &acm_control_interface_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_header_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
|
|
|
|
(struct usb_descriptor_header *) &acm_descriptor,
|
|
|
|
(struct usb_descriptor_header *) &acm_union_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_hs_notify_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_ss_bulk_comp_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_data_interface_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_ss_in_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_ss_bulk_comp_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_ss_out_desc,
|
|
|
|
(struct usb_descriptor_header *) &acm_ss_bulk_comp_desc,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2008-06-20 01:18:40 +00:00
|
|
|
/* string descriptors: */
|
|
|
|
|
|
|
|
#define ACM_CTRL_IDX 0
|
|
|
|
#define ACM_DATA_IDX 1
|
2009-10-28 15:57:30 +00:00
|
|
|
#define ACM_IAD_IDX 2
|
2008-06-20 01:18:40 +00:00
|
|
|
|
|
|
|
/* static strings, in UTF-8 */
|
|
|
|
static struct usb_string acm_string_defs[] = {
|
|
|
|
[ACM_CTRL_IDX].s = "CDC Abstract Control Model (ACM)",
|
|
|
|
[ACM_DATA_IDX].s = "CDC ACM Data",
|
2009-10-28 15:57:30 +00:00
|
|
|
[ACM_IAD_IDX ].s = "CDC Serial",
|
2008-06-20 01:18:40 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct usb_gadget_strings acm_string_table = {
|
|
|
|
.language = 0x0409, /* en-us */
|
|
|
|
.strings = acm_string_defs,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct usb_gadget_strings *acm_strings[] = {
|
|
|
|
&acm_string_table,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* ACM control ... data handling is delegated to tty library code.
|
|
|
|
* The main task of this function is to activate and deactivate
|
|
|
|
* that code based on device state; track parameters like line
|
|
|
|
* speed, handshake state, and so on; and issue notifications.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void acm_complete_set_line_coding(struct usb_ep *ep,
|
|
|
|
struct usb_request *req)
|
|
|
|
{
|
|
|
|
struct f_acm *acm = ep->driver_data;
|
|
|
|
struct usb_composite_dev *cdev = acm->port.func.config->cdev;
|
|
|
|
|
|
|
|
if (req->status != 0) {
|
|
|
|
DBG(cdev, "acm ttyGS%d completion, err %d\n",
|
|
|
|
acm->port_num, req->status);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* normal completion */
|
|
|
|
if (req->actual != sizeof(acm->port_line_coding)) {
|
|
|
|
DBG(cdev, "acm ttyGS%d short resp, len %d\n",
|
|
|
|
acm->port_num, req->actual);
|
|
|
|
usb_ep_set_halt(ep);
|
|
|
|
} else {
|
|
|
|
struct usb_cdc_line_coding *value = req->buf;
|
|
|
|
|
|
|
|
/* REVISIT: we currently just remember this data.
|
|
|
|
* If we change that, (a) validate it first, then
|
|
|
|
* (b) update whatever hardware needs updating,
|
|
|
|
* (c) worry about locking. This is information on
|
|
|
|
* the order of 9600-8-N-1 ... most of which means
|
|
|
|
* nothing unless we control a real RS232 line.
|
|
|
|
*/
|
|
|
|
acm->port_line_coding = *value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
|
|
|
|
{
|
|
|
|
struct f_acm *acm = func_to_acm(f);
|
|
|
|
struct usb_composite_dev *cdev = f->config->cdev;
|
|
|
|
struct usb_request *req = cdev->req;
|
|
|
|
int value = -EOPNOTSUPP;
|
|
|
|
u16 w_index = le16_to_cpu(ctrl->wIndex);
|
|
|
|
u16 w_value = le16_to_cpu(ctrl->wValue);
|
|
|
|
u16 w_length = le16_to_cpu(ctrl->wLength);
|
|
|
|
|
|
|
|
/* composite driver infrastructure handles everything except
|
|
|
|
* CDC class messages; interface activation uses set_alt().
|
2008-08-07 01:49:57 +00:00
|
|
|
*
|
|
|
|
* Note CDC spec table 4 lists the ACM request profile. It requires
|
|
|
|
* encapsulated command support ... we don't handle any, and respond
|
|
|
|
* to them by stalling. Options include get/set/clear comm features
|
|
|
|
* (not that useful) and SEND_BREAK.
|
2008-06-20 01:18:40 +00:00
|
|
|
*/
|
|
|
|
switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
|
|
|
|
|
|
|
|
/* SET_LINE_CODING ... just read and save what the host sends */
|
|
|
|
case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
|
|
|
|
| USB_CDC_REQ_SET_LINE_CODING:
|
|
|
|
if (w_length != sizeof(struct usb_cdc_line_coding)
|
|
|
|
|| w_index != acm->ctrl_id)
|
|
|
|
goto invalid;
|
|
|
|
|
|
|
|
value = w_length;
|
|
|
|
cdev->gadget->ep0->driver_data = acm;
|
|
|
|
req->complete = acm_complete_set_line_coding;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* GET_LINE_CODING ... return what host sent, or initial value */
|
|
|
|
case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
|
|
|
|
| USB_CDC_REQ_GET_LINE_CODING:
|
|
|
|
if (w_index != acm->ctrl_id)
|
|
|
|
goto invalid;
|
|
|
|
|
|
|
|
value = min_t(unsigned, w_length,
|
|
|
|
sizeof(struct usb_cdc_line_coding));
|
|
|
|
memcpy(req->buf, &acm->port_line_coding, value);
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* SET_CONTROL_LINE_STATE ... save what the host sent */
|
|
|
|
case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
|
|
|
|
| USB_CDC_REQ_SET_CONTROL_LINE_STATE:
|
|
|
|
if (w_index != acm->ctrl_id)
|
|
|
|
goto invalid;
|
|
|
|
|
|
|
|
value = 0;
|
|
|
|
|
|
|
|
/* FIXME we should not allow data to flow until the
|
2008-08-07 01:49:57 +00:00
|
|
|
* host sets the ACM_CTRL_DTR bit; and when it clears
|
2008-06-20 01:18:40 +00:00
|
|
|
* that bit, we should return to that no-flow state.
|
|
|
|
*/
|
|
|
|
acm->port_handshake_bits = w_value;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
invalid:
|
|
|
|
VDBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
|
|
|
|
ctrl->bRequestType, ctrl->bRequest,
|
|
|
|
w_value, w_index, w_length);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* respond with data transfer or status phase? */
|
|
|
|
if (value >= 0) {
|
|
|
|
DBG(cdev, "acm ttyGS%d req%02x.%02x v%04x i%04x l%d\n",
|
|
|
|
acm->port_num, ctrl->bRequestType, ctrl->bRequest,
|
|
|
|
w_value, w_index, w_length);
|
|
|
|
req->zero = 0;
|
|
|
|
req->length = value;
|
|
|
|
value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
|
|
|
|
if (value < 0)
|
|
|
|
ERROR(cdev, "acm response on ttyGS%d, err %d\n",
|
|
|
|
acm->port_num, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* device either stalls (value < 0) or reports success */
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
|
|
|
|
{
|
|
|
|
struct f_acm *acm = func_to_acm(f);
|
|
|
|
struct usb_composite_dev *cdev = f->config->cdev;
|
|
|
|
|
|
|
|
/* we know alt == 0, so this is an activation or a reset */
|
|
|
|
|
|
|
|
if (intf == acm->ctrl_id) {
|
|
|
|
if (acm->notify->driver_data) {
|
|
|
|
VDBG(cdev, "reset acm control interface %d\n", intf);
|
|
|
|
usb_ep_disable(acm->notify);
|
|
|
|
} else {
|
|
|
|
VDBG(cdev, "init acm ctrl interface %d\n", intf);
|
2011-06-28 13:33:50 +00:00
|
|
|
if (config_ep_by_speed(cdev->gadget, f, acm->notify))
|
|
|
|
return -EINVAL;
|
2008-06-20 01:18:40 +00:00
|
|
|
}
|
2011-06-28 13:33:48 +00:00
|
|
|
usb_ep_enable(acm->notify);
|
2008-06-20 01:18:40 +00:00
|
|
|
acm->notify->driver_data = acm;
|
|
|
|
|
|
|
|
} else if (intf == acm->data_id) {
|
|
|
|
if (acm->port.in->driver_data) {
|
|
|
|
DBG(cdev, "reset acm ttyGS%d\n", acm->port_num);
|
|
|
|
gserial_disconnect(&acm->port);
|
2011-06-28 13:33:50 +00:00
|
|
|
}
|
|
|
|
if (!acm->port.in->desc || !acm->port.out->desc) {
|
2008-06-20 01:18:40 +00:00
|
|
|
DBG(cdev, "activate acm ttyGS%d\n", acm->port_num);
|
2011-06-28 13:33:50 +00:00
|
|
|
if (config_ep_by_speed(cdev->gadget, f,
|
|
|
|
acm->port.in) ||
|
|
|
|
config_ep_by_speed(cdev->gadget, f,
|
|
|
|
acm->port.out)) {
|
|
|
|
acm->port.in->desc = NULL;
|
|
|
|
acm->port.out->desc = NULL;
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2008-06-20 01:18:40 +00:00
|
|
|
}
|
|
|
|
gserial_connect(&acm->port, acm->port_num);
|
|
|
|
|
|
|
|
} else
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acm_disable(struct usb_function *f)
|
|
|
|
{
|
|
|
|
struct f_acm *acm = func_to_acm(f);
|
|
|
|
struct usb_composite_dev *cdev = f->config->cdev;
|
|
|
|
|
|
|
|
DBG(cdev, "acm ttyGS%d deactivated\n", acm->port_num);
|
|
|
|
gserial_disconnect(&acm->port);
|
|
|
|
usb_ep_disable(acm->notify);
|
|
|
|
acm->notify->driver_data = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2008-08-07 01:49:57 +00:00
|
|
|
/**
|
|
|
|
* acm_cdc_notify - issue CDC notification to host
|
|
|
|
* @acm: wraps host to be notified
|
|
|
|
* @type: notification type
|
|
|
|
* @value: Refer to cdc specs, wValue field.
|
|
|
|
* @data: data to be sent
|
|
|
|
* @length: size of data
|
|
|
|
* Context: irqs blocked, acm->lock held, acm_notify_req non-null
|
|
|
|
*
|
tree-wide: fix assorted typos all over the place
That is "success", "unknown", "through", "performance", "[re|un]mapping"
, "access", "default", "reasonable", "[con]currently", "temperature"
, "channel", "[un]used", "application", "example","hierarchy", "therefore"
, "[over|under]flow", "contiguous", "threshold", "enough" and others.
Signed-off-by: André Goddard Rosa <andre.goddard@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2009-11-14 15:09:05 +00:00
|
|
|
* Returns zero on success or a negative errno.
|
2008-08-07 01:49:57 +00:00
|
|
|
*
|
|
|
|
* See section 6.3.5 of the CDC 1.1 specification for information
|
|
|
|
* about the only notification we issue: SerialState change.
|
|
|
|
*/
|
|
|
|
static int acm_cdc_notify(struct f_acm *acm, u8 type, u16 value,
|
|
|
|
void *data, unsigned length)
|
|
|
|
{
|
|
|
|
struct usb_ep *ep = acm->notify;
|
|
|
|
struct usb_request *req;
|
|
|
|
struct usb_cdc_notification *notify;
|
|
|
|
const unsigned len = sizeof(*notify) + length;
|
|
|
|
void *buf;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
req = acm->notify_req;
|
|
|
|
acm->notify_req = NULL;
|
|
|
|
acm->pending = false;
|
|
|
|
|
|
|
|
req->length = len;
|
|
|
|
notify = req->buf;
|
|
|
|
buf = notify + 1;
|
|
|
|
|
|
|
|
notify->bmRequestType = USB_DIR_IN | USB_TYPE_CLASS
|
|
|
|
| USB_RECIP_INTERFACE;
|
|
|
|
notify->bNotificationType = type;
|
|
|
|
notify->wValue = cpu_to_le16(value);
|
|
|
|
notify->wIndex = cpu_to_le16(acm->ctrl_id);
|
|
|
|
notify->wLength = cpu_to_le16(length);
|
|
|
|
memcpy(buf, data, length);
|
|
|
|
|
2008-11-12 19:35:13 +00:00
|
|
|
/* ep_queue() can complete immediately if it fills the fifo... */
|
|
|
|
spin_unlock(&acm->lock);
|
2008-08-07 01:49:57 +00:00
|
|
|
status = usb_ep_queue(ep, req, GFP_ATOMIC);
|
2008-11-12 19:35:13 +00:00
|
|
|
spin_lock(&acm->lock);
|
|
|
|
|
2008-08-07 01:49:57 +00:00
|
|
|
if (status < 0) {
|
|
|
|
ERROR(acm->port.func.config->cdev,
|
|
|
|
"acm ttyGS%d can't notify serial state, %d\n",
|
|
|
|
acm->port_num, status);
|
|
|
|
acm->notify_req = req;
|
|
|
|
}
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acm_notify_serial_state(struct f_acm *acm)
|
|
|
|
{
|
|
|
|
struct usb_composite_dev *cdev = acm->port.func.config->cdev;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
spin_lock(&acm->lock);
|
|
|
|
if (acm->notify_req) {
|
|
|
|
DBG(cdev, "acm ttyGS%d serial state %04x\n",
|
|
|
|
acm->port_num, acm->serial_state);
|
|
|
|
status = acm_cdc_notify(acm, USB_CDC_NOTIFY_SERIAL_STATE,
|
|
|
|
0, &acm->serial_state, sizeof(acm->serial_state));
|
|
|
|
} else {
|
|
|
|
acm->pending = true;
|
|
|
|
status = 0;
|
|
|
|
}
|
|
|
|
spin_unlock(&acm->lock);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acm_cdc_notify_complete(struct usb_ep *ep, struct usb_request *req)
|
|
|
|
{
|
|
|
|
struct f_acm *acm = req->context;
|
|
|
|
u8 doit = false;
|
|
|
|
|
|
|
|
/* on this call path we do NOT hold the port spinlock,
|
|
|
|
* which is why ACM needs its own spinlock
|
|
|
|
*/
|
|
|
|
spin_lock(&acm->lock);
|
|
|
|
if (req->status != -ESHUTDOWN)
|
|
|
|
doit = acm->pending;
|
|
|
|
acm->notify_req = req;
|
|
|
|
spin_unlock(&acm->lock);
|
|
|
|
|
|
|
|
if (doit)
|
|
|
|
acm_notify_serial_state(acm);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* connect == the TTY link is open */
|
|
|
|
|
|
|
|
static void acm_connect(struct gserial *port)
|
|
|
|
{
|
|
|
|
struct f_acm *acm = port_to_acm(port);
|
|
|
|
|
|
|
|
acm->serial_state |= ACM_CTRL_DSR | ACM_CTRL_DCD;
|
|
|
|
acm_notify_serial_state(acm);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acm_disconnect(struct gserial *port)
|
|
|
|
{
|
|
|
|
struct f_acm *acm = port_to_acm(port);
|
|
|
|
|
|
|
|
acm->serial_state &= ~(ACM_CTRL_DSR | ACM_CTRL_DCD);
|
|
|
|
acm_notify_serial_state(acm);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acm_send_break(struct gserial *port, int duration)
|
|
|
|
{
|
|
|
|
struct f_acm *acm = port_to_acm(port);
|
|
|
|
u16 state;
|
|
|
|
|
|
|
|
state = acm->serial_state;
|
|
|
|
state &= ~ACM_CTRL_BRK;
|
|
|
|
if (duration)
|
|
|
|
state |= ACM_CTRL_BRK;
|
|
|
|
|
|
|
|
acm->serial_state = state;
|
|
|
|
return acm_notify_serial_state(acm);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2008-06-20 01:18:40 +00:00
|
|
|
/* ACM function driver setup/binding */
|
2010-05-05 10:53:13 +00:00
|
|
|
static int
|
2008-06-20 01:18:40 +00:00
|
|
|
acm_bind(struct usb_configuration *c, struct usb_function *f)
|
|
|
|
{
|
|
|
|
struct usb_composite_dev *cdev = c->cdev;
|
|
|
|
struct f_acm *acm = func_to_acm(f);
|
2012-12-23 20:10:23 +00:00
|
|
|
struct usb_string *us;
|
2008-06-20 01:18:40 +00:00
|
|
|
int status;
|
|
|
|
struct usb_ep *ep;
|
|
|
|
|
2012-12-23 20:10:07 +00:00
|
|
|
/* REVISIT might want instance-specific strings to help
|
|
|
|
* distinguish instances ...
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* maybe allocate device-global string IDs, and patch descriptors */
|
2012-12-23 20:10:23 +00:00
|
|
|
us = usb_gstrings_attach(cdev, acm_strings,
|
|
|
|
ARRAY_SIZE(acm_string_defs));
|
|
|
|
if (IS_ERR(us))
|
|
|
|
return PTR_ERR(us);
|
|
|
|
acm_control_interface_desc.iInterface = us[ACM_CTRL_IDX].id;
|
|
|
|
acm_data_interface_desc.iInterface = us[ACM_DATA_IDX].id;
|
|
|
|
acm_iad_descriptor.iFunction = us[ACM_IAD_IDX].id;
|
2012-12-23 20:10:07 +00:00
|
|
|
|
2008-06-20 01:18:40 +00:00
|
|
|
/* allocate instance-specific interface IDs, and patch descriptors */
|
|
|
|
status = usb_interface_id(c, f);
|
|
|
|
if (status < 0)
|
|
|
|
goto fail;
|
|
|
|
acm->ctrl_id = status;
|
2009-10-28 15:57:30 +00:00
|
|
|
acm_iad_descriptor.bFirstInterface = status;
|
2008-06-20 01:18:40 +00:00
|
|
|
|
|
|
|
acm_control_interface_desc.bInterfaceNumber = status;
|
|
|
|
acm_union_desc .bMasterInterface0 = status;
|
|
|
|
|
|
|
|
status = usb_interface_id(c, f);
|
|
|
|
if (status < 0)
|
|
|
|
goto fail;
|
|
|
|
acm->data_id = status;
|
|
|
|
|
|
|
|
acm_data_interface_desc.bInterfaceNumber = status;
|
|
|
|
acm_union_desc.bSlaveInterface0 = status;
|
|
|
|
acm_call_mgmt_descriptor.bDataInterface = status;
|
|
|
|
|
|
|
|
status = -ENODEV;
|
|
|
|
|
|
|
|
/* allocate instance-specific endpoints */
|
|
|
|
ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_in_desc);
|
|
|
|
if (!ep)
|
|
|
|
goto fail;
|
|
|
|
acm->port.in = ep;
|
|
|
|
ep->driver_data = cdev; /* claim */
|
|
|
|
|
|
|
|
ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_out_desc);
|
|
|
|
if (!ep)
|
|
|
|
goto fail;
|
|
|
|
acm->port.out = ep;
|
|
|
|
ep->driver_data = cdev; /* claim */
|
|
|
|
|
|
|
|
ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_notify_desc);
|
|
|
|
if (!ep)
|
|
|
|
goto fail;
|
|
|
|
acm->notify = ep;
|
|
|
|
ep->driver_data = cdev; /* claim */
|
|
|
|
|
2008-08-07 01:49:57 +00:00
|
|
|
/* allocate notification */
|
|
|
|
acm->notify_req = gs_alloc_req(ep,
|
|
|
|
sizeof(struct usb_cdc_notification) + 2,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!acm->notify_req)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
acm->notify_req->complete = acm_cdc_notify_complete;
|
|
|
|
acm->notify_req->context = acm;
|
|
|
|
|
2008-06-20 01:18:40 +00:00
|
|
|
/* support all relevant hardware speeds... we expect that when
|
|
|
|
* hardware is dual speed, all bulk-capable endpoints work at
|
|
|
|
* both speeds
|
|
|
|
*/
|
2012-10-22 20:15:06 +00:00
|
|
|
acm_hs_in_desc.bEndpointAddress = acm_fs_in_desc.bEndpointAddress;
|
|
|
|
acm_hs_out_desc.bEndpointAddress = acm_fs_out_desc.bEndpointAddress;
|
|
|
|
acm_hs_notify_desc.bEndpointAddress =
|
|
|
|
acm_fs_notify_desc.bEndpointAddress;
|
|
|
|
|
|
|
|
acm_ss_in_desc.bEndpointAddress = acm_fs_in_desc.bEndpointAddress;
|
|
|
|
acm_ss_out_desc.bEndpointAddress = acm_fs_out_desc.bEndpointAddress;
|
|
|
|
|
|
|
|
status = usb_assign_descriptors(f, acm_fs_function, acm_hs_function,
|
|
|
|
acm_ss_function);
|
|
|
|
if (status)
|
|
|
|
goto fail;
|
2008-06-20 01:18:40 +00:00
|
|
|
|
|
|
|
DBG(cdev, "acm ttyGS%d: %s speed IN/%s OUT/%s NOTIFY/%s\n",
|
|
|
|
acm->port_num,
|
2012-02-06 17:46:36 +00:00
|
|
|
gadget_is_superspeed(c->cdev->gadget) ? "super" :
|
2008-06-20 01:18:40 +00:00
|
|
|
gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
|
|
|
|
acm->port.in->name, acm->port.out->name,
|
|
|
|
acm->notify->name);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
2008-08-07 01:49:57 +00:00
|
|
|
if (acm->notify_req)
|
|
|
|
gs_free_req(acm->notify, acm->notify_req);
|
|
|
|
|
2008-06-20 01:18:40 +00:00
|
|
|
/* we might as well release our claims on endpoints */
|
|
|
|
if (acm->notify)
|
|
|
|
acm->notify->driver_data = NULL;
|
|
|
|
if (acm->port.out)
|
|
|
|
acm->port.out->driver_data = NULL;
|
|
|
|
if (acm->port.in)
|
|
|
|
acm->port.in->driver_data = NULL;
|
|
|
|
|
|
|
|
ERROR(cdev, "%s/%p: can't bind, err %d\n", f->name, f, status);
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2012-12-23 20:10:07 +00:00
|
|
|
static struct f_acm *acm_alloc_basic_func(void)
|
|
|
|
{
|
|
|
|
struct f_acm *acm;
|
|
|
|
|
|
|
|
acm = kzalloc(sizeof(*acm), GFP_KERNEL);
|
|
|
|
if (!acm)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
spin_lock_init(&acm->lock);
|
|
|
|
|
|
|
|
acm->port.connect = acm_connect;
|
|
|
|
acm->port.disconnect = acm_disconnect;
|
|
|
|
acm->port.send_break = acm_send_break;
|
|
|
|
|
|
|
|
acm->port.func.name = "acm";
|
|
|
|
/* descriptors are per-instance copies */
|
|
|
|
acm->port.func.bind = acm_bind;
|
|
|
|
acm->port.func.set_alt = acm_set_alt;
|
|
|
|
acm->port.func.setup = acm_setup;
|
|
|
|
acm->port.func.disable = acm_disable;
|
|
|
|
|
|
|
|
return acm;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef USB_FACM_INCLUDED
|
2008-06-20 01:18:40 +00:00
|
|
|
static void
|
2012-12-23 20:10:07 +00:00
|
|
|
acm_old_unbind(struct usb_configuration *c, struct usb_function *f)
|
2008-06-20 01:18:40 +00:00
|
|
|
{
|
2008-08-07 01:49:57 +00:00
|
|
|
struct f_acm *acm = func_to_acm(f);
|
|
|
|
|
2012-10-22 20:15:06 +00:00
|
|
|
usb_free_all_descriptors(f);
|
2012-12-23 20:10:07 +00:00
|
|
|
if (acm->notify_req)
|
|
|
|
gs_free_req(acm->notify, acm->notify_req);
|
2008-08-07 01:49:57 +00:00
|
|
|
kfree(acm);
|
2008-06-20 01:18:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acm_bind_config - add a CDC ACM function to a configuration
|
|
|
|
* @c: the configuration to support the CDC ACM instance
|
|
|
|
* @port_num: /dev/ttyGS* port this interface will use
|
|
|
|
* Context: single threaded during gadget setup
|
|
|
|
*
|
|
|
|
* Returns zero on success, else negative errno.
|
|
|
|
*
|
|
|
|
*/
|
2010-05-05 10:53:13 +00:00
|
|
|
int acm_bind_config(struct usb_configuration *c, u8 port_num)
|
2008-06-20 01:18:40 +00:00
|
|
|
{
|
|
|
|
struct f_acm *acm;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
/* allocate and initialize one new instance */
|
2012-12-23 20:10:07 +00:00
|
|
|
acm = acm_alloc_basic_func();
|
2008-06-20 01:18:40 +00:00
|
|
|
if (!acm)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
acm->port_num = port_num;
|
2012-12-23 20:10:07 +00:00
|
|
|
acm->port.func.unbind = acm_old_unbind;
|
2008-06-20 01:18:40 +00:00
|
|
|
|
|
|
|
status = usb_add_function(c, &acm->port.func);
|
|
|
|
if (status)
|
|
|
|
kfree(acm);
|
|
|
|
return status;
|
|
|
|
}
|
2012-12-23 20:10:07 +00:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
static void acm_unbind(struct usb_configuration *c, struct usb_function *f)
|
|
|
|
{
|
|
|
|
struct f_acm *acm = func_to_acm(f);
|
|
|
|
|
|
|
|
acm_string_defs[0].id = 0;
|
|
|
|
usb_free_all_descriptors(f);
|
|
|
|
if (acm->notify_req)
|
|
|
|
gs_free_req(acm->notify, acm->notify_req);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acm_free_func(struct usb_function *f)
|
|
|
|
{
|
|
|
|
struct f_acm *acm = func_to_acm(f);
|
|
|
|
|
|
|
|
kfree(acm);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct usb_function *acm_alloc_func(struct usb_function_instance *fi)
|
|
|
|
{
|
|
|
|
struct f_serial_opts *opts;
|
|
|
|
struct f_acm *acm;
|
|
|
|
|
|
|
|
acm = acm_alloc_basic_func();
|
|
|
|
if (!acm)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
opts = container_of(fi, struct f_serial_opts, func_inst);
|
|
|
|
acm->port_num = opts->port_num;
|
|
|
|
acm->port.func.unbind = acm_unbind;
|
|
|
|
acm->port.func.free_func = acm_free_func;
|
|
|
|
|
|
|
|
return &acm->port.func;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acm_free_instance(struct usb_function_instance *fi)
|
|
|
|
{
|
|
|
|
struct f_serial_opts *opts;
|
|
|
|
|
|
|
|
opts = container_of(fi, struct f_serial_opts, func_inst);
|
|
|
|
kfree(opts);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct usb_function_instance *acm_alloc_instance(void)
|
|
|
|
{
|
|
|
|
struct f_serial_opts *opts;
|
|
|
|
|
|
|
|
opts = kzalloc(sizeof(*opts), GFP_KERNEL);
|
|
|
|
if (!opts)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
opts->func_inst.free_func_inst = acm_free_instance;
|
|
|
|
return &opts->func_inst;
|
|
|
|
}
|
|
|
|
DECLARE_USB_FUNCTION_INIT(acm, acm_alloc_instance, acm_alloc_func);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
#endif
|