From 00a2430ff07d4e0e0e7e24e02fd8adede333b797 Mon Sep 17 00:00:00 2001 From: Andrzej Pietrasiewicz Date: Tue, 15 Jul 2014 13:09:46 +0200 Subject: usb: gadget: Gadget directory cleanup - group usb functions The drivers/usb/gadget directory contains many files. Files which are related can be distributed into separate directories. This patch moves the USB functions implementations into a separate directory. Signed-off-by: Andrzej Pietrasiewicz Signed-off-by: Felipe Balbi --- drivers/usb/gadget/Makefile | 30 +- drivers/usb/gadget/f_acm.c | 848 ------ drivers/usb/gadget/f_ecm.c | 973 ------- drivers/usb/gadget/f_eem.c | 660 ----- drivers/usb/gadget/f_fs.c | 3347 --------------------- drivers/usb/gadget/f_hid.c | 763 ----- drivers/usb/gadget/f_loopback.c | 571 ---- drivers/usb/gadget/f_mass_storage.c | 3668 ------------------------ drivers/usb/gadget/f_mass_storage.h | 166 -- drivers/usb/gadget/f_midi.c | 986 ------- drivers/usb/gadget/f_ncm.c | 1622 ----------- drivers/usb/gadget/f_obex.c | 533 ---- drivers/usb/gadget/f_phonet.c | 758 ----- drivers/usb/gadget/f_rndis.c | 1029 ------- drivers/usb/gadget/f_serial.c | 385 --- drivers/usb/gadget/f_sourcesink.c | 1247 -------- drivers/usb/gadget/f_subset.c | 519 ---- drivers/usb/gadget/f_uac1.c | 768 ----- drivers/usb/gadget/f_uac2.c | 1354 --------- drivers/usb/gadget/f_uvc.c | 836 ------ drivers/usb/gadget/f_uvc.h | 27 - drivers/usb/gadget/function/Makefile | 34 + drivers/usb/gadget/function/f_acm.c | 848 ++++++ drivers/usb/gadget/function/f_ecm.c | 973 +++++++ drivers/usb/gadget/function/f_eem.c | 660 +++++ drivers/usb/gadget/function/f_fs.c | 3347 +++++++++++++++++++++ drivers/usb/gadget/function/f_hid.c | 763 +++++ drivers/usb/gadget/function/f_loopback.c | 571 ++++ drivers/usb/gadget/function/f_mass_storage.c | 3668 ++++++++++++++++++++++++ drivers/usb/gadget/function/f_mass_storage.h | 166 ++ drivers/usb/gadget/function/f_midi.c | 986 +++++++ drivers/usb/gadget/function/f_ncm.c | 1622 +++++++++++ drivers/usb/gadget/function/f_obex.c | 533 ++++ drivers/usb/gadget/function/f_phonet.c | 758 +++++ drivers/usb/gadget/function/f_rndis.c | 1029 +++++++ drivers/usb/gadget/function/f_serial.c | 385 +++ drivers/usb/gadget/function/f_sourcesink.c | 1247 ++++++++ drivers/usb/gadget/function/f_subset.c | 519 ++++ drivers/usb/gadget/function/f_uac1.c | 768 +++++ drivers/usb/gadget/function/f_uac2.c | 1354 +++++++++ drivers/usb/gadget/function/f_uvc.c | 836 ++++++ drivers/usb/gadget/function/f_uvc.h | 27 + drivers/usb/gadget/function/g_zero.h | 67 + drivers/usb/gadget/function/ndis.h | 47 + drivers/usb/gadget/function/rndis.c | 1190 ++++++++ drivers/usb/gadget/function/rndis.h | 220 ++ drivers/usb/gadget/function/storage_common.c | 504 ++++ drivers/usb/gadget/function/storage_common.h | 225 ++ drivers/usb/gadget/function/u_ecm.h | 36 + drivers/usb/gadget/function/u_eem.h | 36 + drivers/usb/gadget/function/u_ether.c | 1179 ++++++++ drivers/usb/gadget/function/u_ether.h | 272 ++ drivers/usb/gadget/function/u_ether_configfs.h | 164 ++ drivers/usb/gadget/function/u_fs.h | 270 ++ drivers/usb/gadget/function/u_gether.h | 36 + drivers/usb/gadget/function/u_ncm.h | 36 + drivers/usb/gadget/function/u_phonet.h | 29 + drivers/usb/gadget/function/u_rndis.h | 46 + drivers/usb/gadget/function/u_serial.c | 1347 +++++++++ drivers/usb/gadget/function/u_serial.h | 71 + drivers/usb/gadget/function/u_uac1.c | 330 +++ drivers/usb/gadget/function/u_uac1.h | 56 + drivers/usb/gadget/function/uvc.h | 202 ++ drivers/usb/gadget/function/uvc_queue.c | 407 +++ drivers/usb/gadget/function/uvc_queue.h | 63 + drivers/usb/gadget/function/uvc_v4l2.c | 365 +++ drivers/usb/gadget/function/uvc_video.c | 394 +++ drivers/usb/gadget/g_zero.h | 67 - drivers/usb/gadget/legacy/Makefile | 1 + drivers/usb/gadget/ndis.h | 47 - drivers/usb/gadget/rndis.c | 1190 -------- drivers/usb/gadget/rndis.h | 220 -- drivers/usb/gadget/storage_common.c | 504 ---- drivers/usb/gadget/storage_common.h | 225 -- drivers/usb/gadget/u_ecm.h | 36 - drivers/usb/gadget/u_eem.h | 36 - drivers/usb/gadget/u_ether.c | 1179 -------- drivers/usb/gadget/u_ether.h | 272 -- drivers/usb/gadget/u_ether_configfs.h | 164 -- drivers/usb/gadget/u_fs.h | 270 -- drivers/usb/gadget/u_gether.h | 36 - drivers/usb/gadget/u_ncm.h | 36 - drivers/usb/gadget/u_phonet.h | 29 - drivers/usb/gadget/u_rndis.h | 46 - drivers/usb/gadget/u_serial.c | 1347 --------- drivers/usb/gadget/u_serial.h | 71 - drivers/usb/gadget/u_uac1.c | 330 --- drivers/usb/gadget/u_uac1.h | 56 - drivers/usb/gadget/uvc.h | 202 -- drivers/usb/gadget/uvc_queue.c | 407 --- drivers/usb/gadget/uvc_queue.h | 63 - drivers/usb/gadget/uvc_v4l2.c | 365 --- drivers/usb/gadget/uvc_video.c | 394 --- 93 files changed, 28688 insertions(+), 28681 deletions(-) delete mode 100644 drivers/usb/gadget/f_acm.c delete mode 100644 drivers/usb/gadget/f_ecm.c delete mode 100644 drivers/usb/gadget/f_eem.c delete mode 100644 drivers/usb/gadget/f_fs.c delete mode 100644 drivers/usb/gadget/f_hid.c delete mode 100644 drivers/usb/gadget/f_loopback.c delete mode 100644 drivers/usb/gadget/f_mass_storage.c delete mode 100644 drivers/usb/gadget/f_mass_storage.h delete mode 100644 drivers/usb/gadget/f_midi.c delete mode 100644 drivers/usb/gadget/f_ncm.c delete mode 100644 drivers/usb/gadget/f_obex.c delete mode 100644 drivers/usb/gadget/f_phonet.c delete mode 100644 drivers/usb/gadget/f_rndis.c delete mode 100644 drivers/usb/gadget/f_serial.c delete mode 100644 drivers/usb/gadget/f_sourcesink.c delete mode 100644 drivers/usb/gadget/f_subset.c delete mode 100644 drivers/usb/gadget/f_uac1.c delete mode 100644 drivers/usb/gadget/f_uac2.c delete mode 100644 drivers/usb/gadget/f_uvc.c delete mode 100644 drivers/usb/gadget/f_uvc.h create mode 100644 drivers/usb/gadget/function/Makefile create mode 100644 drivers/usb/gadget/function/f_acm.c create mode 100644 drivers/usb/gadget/function/f_ecm.c create mode 100644 drivers/usb/gadget/function/f_eem.c create mode 100644 drivers/usb/gadget/function/f_fs.c create mode 100644 drivers/usb/gadget/function/f_hid.c create mode 100644 drivers/usb/gadget/function/f_loopback.c create mode 100644 drivers/usb/gadget/function/f_mass_storage.c create mode 100644 drivers/usb/gadget/function/f_mass_storage.h create mode 100644 drivers/usb/gadget/function/f_midi.c create mode 100644 drivers/usb/gadget/function/f_ncm.c create mode 100644 drivers/usb/gadget/function/f_obex.c create mode 100644 drivers/usb/gadget/function/f_phonet.c create mode 100644 drivers/usb/gadget/function/f_rndis.c create mode 100644 drivers/usb/gadget/function/f_serial.c create mode 100644 drivers/usb/gadget/function/f_sourcesink.c create mode 100644 drivers/usb/gadget/function/f_subset.c create mode 100644 drivers/usb/gadget/function/f_uac1.c create mode 100644 drivers/usb/gadget/function/f_uac2.c create mode 100644 drivers/usb/gadget/function/f_uvc.c create mode 100644 drivers/usb/gadget/function/f_uvc.h create mode 100644 drivers/usb/gadget/function/g_zero.h create mode 100644 drivers/usb/gadget/function/ndis.h create mode 100644 drivers/usb/gadget/function/rndis.c create mode 100644 drivers/usb/gadget/function/rndis.h create mode 100644 drivers/usb/gadget/function/storage_common.c create mode 100644 drivers/usb/gadget/function/storage_common.h create mode 100644 drivers/usb/gadget/function/u_ecm.h create mode 100644 drivers/usb/gadget/function/u_eem.h create mode 100644 drivers/usb/gadget/function/u_ether.c create mode 100644 drivers/usb/gadget/function/u_ether.h create mode 100644 drivers/usb/gadget/function/u_ether_configfs.h create mode 100644 drivers/usb/gadget/function/u_fs.h create mode 100644 drivers/usb/gadget/function/u_gether.h create mode 100644 drivers/usb/gadget/function/u_ncm.h create mode 100644 drivers/usb/gadget/function/u_phonet.h create mode 100644 drivers/usb/gadget/function/u_rndis.h create mode 100644 drivers/usb/gadget/function/u_serial.c create mode 100644 drivers/usb/gadget/function/u_serial.h create mode 100644 drivers/usb/gadget/function/u_uac1.c create mode 100644 drivers/usb/gadget/function/u_uac1.h create mode 100644 drivers/usb/gadget/function/uvc.h create mode 100644 drivers/usb/gadget/function/uvc_queue.c create mode 100644 drivers/usb/gadget/function/uvc_queue.h create mode 100644 drivers/usb/gadget/function/uvc_v4l2.c create mode 100644 drivers/usb/gadget/function/uvc_video.c delete mode 100644 drivers/usb/gadget/g_zero.h delete mode 100644 drivers/usb/gadget/ndis.h delete mode 100644 drivers/usb/gadget/rndis.c delete mode 100644 drivers/usb/gadget/rndis.h delete mode 100644 drivers/usb/gadget/storage_common.c delete mode 100644 drivers/usb/gadget/storage_common.h delete mode 100644 drivers/usb/gadget/u_ecm.h delete mode 100644 drivers/usb/gadget/u_eem.h delete mode 100644 drivers/usb/gadget/u_ether.c delete mode 100644 drivers/usb/gadget/u_ether.h delete mode 100644 drivers/usb/gadget/u_ether_configfs.h delete mode 100644 drivers/usb/gadget/u_fs.h delete mode 100644 drivers/usb/gadget/u_gether.h delete mode 100644 drivers/usb/gadget/u_ncm.h delete mode 100644 drivers/usb/gadget/u_phonet.h delete mode 100644 drivers/usb/gadget/u_rndis.h delete mode 100644 drivers/usb/gadget/u_serial.c delete mode 100644 drivers/usb/gadget/u_serial.h delete mode 100644 drivers/usb/gadget/u_uac1.c delete mode 100644 drivers/usb/gadget/u_uac1.h delete mode 100644 drivers/usb/gadget/uvc.h delete mode 100644 drivers/usb/gadget/uvc_queue.c delete mode 100644 drivers/usb/gadget/uvc_queue.h delete mode 100644 drivers/usb/gadget/uvc_v4l2.c delete mode 100644 drivers/usb/gadget/uvc_video.c diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile index c144102ea793..a186afeaa700 100644 --- a/drivers/usb/gadget/Makefile +++ b/drivers/usb/gadget/Makefile @@ -9,32 +9,4 @@ obj-$(CONFIG_USB_LIBCOMPOSITE) += libcomposite.o libcomposite-y := usbstring.o config.o epautoconf.o libcomposite-y += composite.o functions.o configfs.o u_f.o -# USB Functions -usb_f_acm-y := f_acm.o -obj-$(CONFIG_USB_F_ACM) += usb_f_acm.o -usb_f_ss_lb-y := f_loopback.o f_sourcesink.o -obj-$(CONFIG_USB_F_SS_LB) += usb_f_ss_lb.o -obj-$(CONFIG_USB_U_SERIAL) += u_serial.o -usb_f_serial-y := f_serial.o -obj-$(CONFIG_USB_F_SERIAL) += usb_f_serial.o -usb_f_obex-y := f_obex.o -obj-$(CONFIG_USB_F_OBEX) += usb_f_obex.o -obj-$(CONFIG_USB_U_ETHER) += u_ether.o -usb_f_ncm-y := f_ncm.o -obj-$(CONFIG_USB_F_NCM) += usb_f_ncm.o -usb_f_ecm-y := f_ecm.o -obj-$(CONFIG_USB_F_ECM) += usb_f_ecm.o -usb_f_phonet-y := f_phonet.o -obj-$(CONFIG_USB_F_PHONET) += usb_f_phonet.o -usb_f_eem-y := f_eem.o -obj-$(CONFIG_USB_F_EEM) += usb_f_eem.o -usb_f_ecm_subset-y := f_subset.o -obj-$(CONFIG_USB_F_SUBSET) += usb_f_ecm_subset.o -usb_f_rndis-y := f_rndis.o rndis.o -obj-$(CONFIG_USB_F_RNDIS) += usb_f_rndis.o -usb_f_mass_storage-y := f_mass_storage.o storage_common.o -obj-$(CONFIG_USB_F_MASS_STORAGE)+= usb_f_mass_storage.o -usb_f_fs-y := f_fs.o -obj-$(CONFIG_USB_F_FS) += usb_f_fs.o - -obj-$(CONFIG_USB_GADGET) += udc/ legacy/ +obj-$(CONFIG_USB_GADGET) += udc/ function/ legacy/ diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c deleted file mode 100644 index ab1065afbbd0..000000000000 --- a/drivers/usb/gadget/f_acm.c +++ /dev/null @@ -1,848 +0,0 @@ -/* - * 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 - * Copyright (C) 2009 by Samsung Electronics - * Author: Michal Nazarewicz (mina86@mina86.com) - * - * 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 -#include -#include -#include -#include - -#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; - - 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; - - struct usb_ep *notify; - struct usb_request *notify_req; - - struct usb_cdc_line_coding port_line_coding; /* 8-N-1 etc */ - - /* SetControlLineState request -- CDC 1.1 section 6.2.14 (INPUT) */ - u16 port_handshake_bits; -#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) -}; - -static inline struct f_acm *func_to_acm(struct usb_function *f) -{ - return container_of(f, struct f_acm, port.func); -} - -static inline struct f_acm *port_to_acm(struct gserial *p) -{ - return container_of(p, struct f_acm, port); -} - -/*-------------------------------------------------------------------------*/ - -/* notification endpoint uses smallish and infrequent fixed-size messages */ - -#define GS_NOTIFY_INTERVAL_MS 32 -#define GS_NOTIFY_MAXPACKET 10 /* notification + 2 bytes */ - -/* interface and class descriptors: */ - -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, - .bFunctionProtocol = USB_CDC_ACM_PROTO_AT_V25TER, - /* .iFunction = DYNAMIC */ -}; - - -static struct usb_interface_descriptor acm_control_interface_desc = { - .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 */ -}; - -static struct usb_interface_descriptor acm_data_interface_desc = { - .bLength = USB_DT_INTERFACE_SIZE, - .bDescriptorType = USB_DT_INTERFACE, - /* .bInterfaceNumber = DYNAMIC */ - .bNumEndpoints = 2, - .bInterfaceClass = USB_CLASS_CDC_DATA, - .bInterfaceSubClass = 0, - .bInterfaceProtocol = 0, - /* .iInterface = DYNAMIC */ -}; - -static struct usb_cdc_header_desc acm_header_desc = { - .bLength = sizeof(acm_header_desc), - .bDescriptorType = USB_DT_CS_INTERFACE, - .bDescriptorSubType = USB_CDC_HEADER_TYPE, - .bcdCDC = cpu_to_le16(0x0110), -}; - -static struct usb_cdc_call_mgmt_descriptor -acm_call_mgmt_descriptor = { - .bLength = sizeof(acm_call_mgmt_descriptor), - .bDescriptorType = USB_DT_CS_INTERFACE, - .bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE, - .bmCapabilities = 0, - /* .bDataInterface = DYNAMIC */ -}; - -static struct usb_cdc_acm_descriptor acm_descriptor = { - .bLength = sizeof(acm_descriptor), - .bDescriptorType = USB_DT_CS_INTERFACE, - .bDescriptorSubType = USB_CDC_ACM_TYPE, - .bmCapabilities = USB_CDC_CAP_LINE, -}; - -static struct usb_cdc_union_desc acm_union_desc = { - .bLength = sizeof(acm_union_desc), - .bDescriptorType = USB_DT_CS_INTERFACE, - .bDescriptorSubType = USB_CDC_UNION_TYPE, - /* .bMasterInterface0 = DYNAMIC */ - /* .bSlaveInterface0 = DYNAMIC */ -}; - -/* full speed support: */ - -static struct usb_endpoint_descriptor acm_fs_notify_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - .bEndpointAddress = USB_DIR_IN, - .bmAttributes = USB_ENDPOINT_XFER_INT, - .wMaxPacketSize = cpu_to_le16(GS_NOTIFY_MAXPACKET), - .bInterval = GS_NOTIFY_INTERVAL_MS, -}; - -static struct usb_endpoint_descriptor acm_fs_in_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - .bEndpointAddress = USB_DIR_IN, - .bmAttributes = USB_ENDPOINT_XFER_BULK, -}; - -static struct usb_endpoint_descriptor acm_fs_out_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - .bEndpointAddress = USB_DIR_OUT, - .bmAttributes = USB_ENDPOINT_XFER_BULK, -}; - -static struct usb_descriptor_header *acm_fs_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_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: */ -static struct usb_endpoint_descriptor acm_hs_notify_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - .bEndpointAddress = USB_DIR_IN, - .bmAttributes = USB_ENDPOINT_XFER_INT, - .wMaxPacketSize = cpu_to_le16(GS_NOTIFY_MAXPACKET), - .bInterval = USB_MS_TO_HS_INTERVAL(GS_NOTIFY_INTERVAL_MS), -}; - -static struct usb_endpoint_descriptor acm_hs_in_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - .bmAttributes = USB_ENDPOINT_XFER_BULK, - .wMaxPacketSize = cpu_to_le16(512), -}; - -static struct usb_endpoint_descriptor acm_hs_out_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - .bmAttributes = USB_ENDPOINT_XFER_BULK, - .wMaxPacketSize = cpu_to_le16(512), -}; - -static struct usb_descriptor_header *acm_hs_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_data_interface_desc, - (struct usb_descriptor_header *) &acm_hs_in_desc, - (struct usb_descriptor_header *) &acm_hs_out_desc, - NULL, -}; - -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, -}; - -/* string descriptors: */ - -#define ACM_CTRL_IDX 0 -#define ACM_DATA_IDX 1 -#define ACM_IAD_IDX 2 - -/* 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", - [ACM_IAD_IDX ].s = "CDC Serial", - { } /* end of list */ -}; - -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(). - * - * 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. - */ - 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 - * host sets the ACM_CTRL_DTR bit; and when it clears - * 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); - if (config_ep_by_speed(cdev->gadget, f, acm->notify)) - return -EINVAL; - } - usb_ep_enable(acm->notify); - 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); - } - if (!acm->port.in->desc || !acm->port.out->desc) { - DBG(cdev, "activate acm ttyGS%d\n", acm->port_num); - 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; - } - } - 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; -} - -/*-------------------------------------------------------------------------*/ - -/** - * 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 - * - * Returns zero on success or a negative errno. - * - * 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); - - /* ep_queue() can complete immediately if it fills the fifo... */ - spin_unlock(&acm->lock); - status = usb_ep_queue(ep, req, GFP_ATOMIC); - spin_lock(&acm->lock); - - 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); -} - -/*-------------------------------------------------------------------------*/ - -/* ACM function driver setup/binding */ -static int -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); - struct usb_string *us; - int status; - struct usb_ep *ep; - - /* REVISIT might want instance-specific strings to help - * distinguish instances ... - */ - - /* maybe allocate device-global string IDs, and patch descriptors */ - 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; - - /* allocate instance-specific interface IDs, and patch descriptors */ - status = usb_interface_id(c, f); - if (status < 0) - goto fail; - acm->ctrl_id = status; - acm_iad_descriptor.bFirstInterface = status; - - 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 */ - - /* 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; - - /* support all relevant hardware speeds... we expect that when - * hardware is dual speed, all bulk-capable endpoints work at - * both speeds - */ - 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; - - DBG(cdev, "acm ttyGS%d: %s speed IN/%s OUT/%s NOTIFY/%s\n", - acm->port_num, - gadget_is_superspeed(c->cdev->gadget) ? "super" : - gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full", - acm->port.in->name, acm->port.out->name, - acm->notify->name); - return 0; - -fail: - if (acm->notify_req) - gs_free_req(acm->notify, acm->notify_req); - - /* 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; -} - -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 = kzalloc(sizeof(*acm), GFP_KERNEL); - if (!acm) - return ERR_PTR(-ENOMEM); - - 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"; - acm->port.func.strings = acm_strings; - /* 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; - - 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 inline struct f_serial_opts *to_f_serial_opts(struct config_item *item) -{ - return container_of(to_config_group(item), struct f_serial_opts, - func_inst.group); -} - -CONFIGFS_ATTR_STRUCT(f_serial_opts); -static ssize_t f_acm_attr_show(struct config_item *item, - struct configfs_attribute *attr, - char *page) -{ - struct f_serial_opts *opts = to_f_serial_opts(item); - struct f_serial_opts_attribute *f_serial_opts_attr = - container_of(attr, struct f_serial_opts_attribute, attr); - ssize_t ret = 0; - - if (f_serial_opts_attr->show) - ret = f_serial_opts_attr->show(opts, page); - return ret; -} - -static void acm_attr_release(struct config_item *item) -{ - struct f_serial_opts *opts = to_f_serial_opts(item); - - usb_put_function_instance(&opts->func_inst); -} - -static struct configfs_item_operations acm_item_ops = { - .release = acm_attr_release, - .show_attribute = f_acm_attr_show, -}; - -static ssize_t f_acm_port_num_show(struct f_serial_opts *opts, char *page) -{ - return sprintf(page, "%u\n", opts->port_num); -} - -static struct f_serial_opts_attribute f_acm_port_num = - __CONFIGFS_ATTR_RO(port_num, f_acm_port_num_show); - - -static struct configfs_attribute *acm_attrs[] = { - &f_acm_port_num.attr, - NULL, -}; - -static struct config_item_type acm_func_type = { - .ct_item_ops = &acm_item_ops, - .ct_attrs = acm_attrs, - .ct_owner = THIS_MODULE, -}; - -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); - gserial_free_line(opts->port_num); - kfree(opts); -} - -static struct usb_function_instance *acm_alloc_instance(void) -{ - struct f_serial_opts *opts; - int ret; - - opts = kzalloc(sizeof(*opts), GFP_KERNEL); - if (!opts) - return ERR_PTR(-ENOMEM); - opts->func_inst.free_func_inst = acm_free_instance; - ret = gserial_alloc_line(&opts->port_num); - if (ret) { - kfree(opts); - return ERR_PTR(ret); - } - config_group_init_type_name(&opts->func_inst.group, "", - &acm_func_type); - return &opts->func_inst; -} -DECLARE_USB_FUNCTION_INIT(acm, acm_alloc_instance, acm_alloc_func); -MODULE_LICENSE("GPL"); diff --git a/drivers/usb/gadget/f_ecm.c b/drivers/usb/gadget/f_ecm.c deleted file mode 100644 index 798760fa7e70..000000000000 --- a/drivers/usb/gadget/f_ecm.c +++ /dev/null @@ -1,973 +0,0 @@ -/* - * f_ecm.c -- USB CDC Ethernet (ECM) link function driver - * - * Copyright (C) 2003-2005,2008 David Brownell - * Copyright (C) 2008 Nokia Corporation - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - */ - -/* #define VERBOSE_DEBUG */ - -#include -#include -#include -#include -#include - -#include "u_ether.h" -#include "u_ether_configfs.h" -#include "u_ecm.h" - - -/* - * This function is a "CDC Ethernet Networking Control Model" (CDC ECM) - * Ethernet link. The data transfer model is simple (packets sent and - * received over bulk endpoints using normal short packet termination), - * and the control model exposes various data and optional notifications. - * - * ECM is well standardized and (except for Microsoft) supported by most - * operating systems with USB host support. It's the preferred interop - * solution for Ethernet over USB, at least for firmware based solutions. - * (Hardware solutions tend to be more minimalist.) A newer and simpler - * "Ethernet Emulation Model" (CDC EEM) hasn't yet caught on. - * - * Note that ECM requires the use of "alternate settings" for its data - * interface. This means that the set_alt() method has real work to do, - * and also means that a get_alt() method is required. - */ - - -enum ecm_notify_state { - ECM_NOTIFY_NONE, /* don't notify */ - ECM_NOTIFY_CONNECT, /* issue CONNECT next */ - ECM_NOTIFY_SPEED, /* issue SPEED_CHANGE next */ -}; - -struct f_ecm { - struct gether port; - u8 ctrl_id, data_id; - - char ethaddr[14]; - - struct usb_ep *notify; - struct usb_request *notify_req; - u8 notify_state; - bool is_open; - - /* FIXME is_open needs some irq-ish locking - * ... possibly the same as port.ioport - */ -}; - -static inline struct f_ecm *func_to_ecm(struct usb_function *f) -{ - return container_of(f, struct f_ecm, port.func); -} - -/* peak (theoretical) bulk transfer rate in bits-per-second */ -static inline unsigned ecm_bitrate(struct usb_gadget *g) -{ - if (gadget_is_superspeed(g) && g->speed == USB_SPEED_SUPER) - return 13 * 1024 * 8 * 1000 * 8; - else if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH) - return 13 * 512 * 8 * 1000 * 8; - else - return 19 * 64 * 1 * 1000 * 8; -} - -/*-------------------------------------------------------------------------*/ - -/* - * Include the status endpoint if we can, even though it's optional. - * - * Use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one - * packet, to simplify cancellation; and a big transfer interval, to - * waste less bandwidth. - * - * Some drivers (like Linux 2.4 cdc-ether!) "need" it to exist even - * if they ignore the connect/disconnect notifications that real aether - * can provide. More advanced cdc configurations might want to support - * encapsulated commands (vendor-specific, using control-OUT). - */ - -#define ECM_STATUS_INTERVAL_MS 32 -#define ECM_STATUS_BYTECOUNT 16 /* 8 byte header + data */ - - -/* interface descriptor: */ - -static struct usb_interface_assoc_descriptor -ecm_iad_descriptor = { - .bLength = sizeof ecm_iad_descriptor, - .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION, - - /* .bFirstInterface = DYNAMIC, */ - .bInterfaceCount = 2, /* control + data */ - .bFunctionClass = USB_CLASS_COMM, - .bFunctionSubClass = USB_CDC_SUBCLASS_ETHERNET, - .bFunctionProtocol = USB_CDC_PROTO_NONE, - /* .iFunction = DYNAMIC */ -}; - - -static struct usb_interface_descriptor ecm_control_intf = { - .bLength = sizeof ecm_control_intf, - .bDescriptorType = USB_DT_INTERFACE, - - /* .bInterfaceNumber = DYNAMIC */ - /* status endpoint is optional; this could be patched later */ - .bNumEndpoints = 1, - .bInterfaceClass = USB_CLASS_COMM, - .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET, - .bInterfaceProtocol = USB_CDC_PROTO_NONE, - /* .iInterface = DYNAMIC */ -}; - -static struct usb_cdc_header_desc ecm_header_desc = { - .bLength = sizeof ecm_header_desc, - .bDescriptorType = USB_DT_CS_INTERFACE, - .bDescriptorSubType = USB_CDC_HEADER_TYPE, - - .bcdCDC = cpu_to_le16(0x0110), -}; - -static struct usb_cdc_union_desc ecm_union_desc = { - .bLength = sizeof(ecm_union_desc), - .bDescriptorType = USB_DT_CS_INTERFACE, - .bDescriptorSubType = USB_CDC_UNION_TYPE, - /* .bMasterInterface0 = DYNAMIC */ - /* .bSlaveInterface0 = DYNAMIC */ -}; - -static struct usb_cdc_ether_desc ecm_desc = { - .bLength = sizeof ecm_desc, - .bDescriptorType = USB_DT_CS_INTERFACE, - .bDescriptorSubType = USB_CDC_ETHERNET_TYPE, - - /* this descriptor actually adds value, surprise! */ - /* .iMACAddress = DYNAMIC */ - .bmEthernetStatistics = cpu_to_le32(0), /* no statistics */ - .wMaxSegmentSize = cpu_to_le16(ETH_FRAME_LEN), - .wNumberMCFilters = cpu_to_le16(0), - .bNumberPowerFilters = 0, -}; - -/* the default data interface has no endpoints ... */ - -static struct usb_interface_descriptor ecm_data_nop_intf = { - .bLength = sizeof ecm_data_nop_intf, - .bDescriptorType = USB_DT_INTERFACE, - - .bInterfaceNumber = 1, - .bAlternateSetting = 0, - .bNumEndpoints = 0, - .bInterfaceClass = USB_CLASS_CDC_DATA, - .bInterfaceSubClass = 0, - .bInterfaceProtocol = 0, - /* .iInterface = DYNAMIC */ -}; - -/* ... but the "real" data interface has two bulk endpoints */ - -static struct usb_interface_descriptor ecm_data_intf = { - .bLength = sizeof ecm_data_intf, - .bDescriptorType = USB_DT_INTERFACE, - - .bInterfaceNumber = 1, - .bAlternateSetting = 1, - .bNumEndpoints = 2, - .bInterfaceClass = USB_CLASS_CDC_DATA, - .bInterfaceSubClass = 0, - .bInterfaceProtocol = 0, - /* .iInterface = DYNAMIC */ -}; - -/* full speed support: */ - -static struct usb_endpoint_descriptor fs_ecm_notify_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - - .bEndpointAddress = USB_DIR_IN, - .bmAttributes = USB_ENDPOINT_XFER_INT, - .wMaxPacketSize = cpu_to_le16(ECM_STATUS_BYTECOUNT), - .bInterval = ECM_STATUS_INTERVAL_MS, -}; - -static struct usb_endpoint_descriptor fs_ecm_in_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - - .bEndpointAddress = USB_DIR_IN, - .bmAttributes = USB_ENDPOINT_XFER_BULK, -}; - -static struct usb_endpoint_descriptor fs_ecm_out_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - - .bEndpointAddress = USB_DIR_OUT, - .bmAttributes = USB_ENDPOINT_XFER_BULK, -}; - -static struct usb_descriptor_header *ecm_fs_function[] = { - /* CDC ECM control descriptors */ - (struct usb_descriptor_header *) &ecm_iad_descriptor, - (struct usb_descriptor_header *) &ecm_control_intf, - (struct usb_descriptor_header *) &ecm_header_desc, - (struct usb_descriptor_header *) &ecm_union_desc, - (struct usb_descriptor_header *) &ecm_desc, - - /* NOTE: status endpoint might need to be removed */ - (struct usb_descriptor_header *) &fs_ecm_notify_desc, - - /* data interface, altsettings 0 and 1 */ - (struct usb_descriptor_header *) &ecm_data_nop_intf, - (struct usb_descriptor_header *) &ecm_data_intf, - (struct usb_descriptor_header *) &fs_ecm_in_desc, - (struct usb_descriptor_header *) &fs_ecm_out_desc, - NULL, -}; - -/* high speed support: */ - -static struct usb_endpoint_descriptor hs_ecm_notify_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - - .bEndpointAddress = USB_DIR_IN, - .bmAttributes = USB_ENDPOINT_XFER_INT, - .wMaxPacketSize = cpu_to_le16(ECM_STATUS_BYTECOUNT), - .bInterval = USB_MS_TO_HS_INTERVAL(ECM_STATUS_INTERVAL_MS), -}; - -static struct usb_endpoint_descriptor hs_ecm_in_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - - .bEndpointAddress = USB_DIR_IN, - .bmAttributes = USB_ENDPOINT_XFER_BULK, - .wMaxPacketSize = cpu_to_le16(512), -}; - -static struct usb_endpoint_descriptor hs_ecm_out_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - - .bEndpointAddress = USB_DIR_OUT, - .bmAttributes = USB_ENDPOINT_XFER_BULK, - .wMaxPacketSize = cpu_to_le16(512), -}; - -static struct usb_descriptor_header *ecm_hs_function[] = { - /* CDC ECM control descriptors */ - (struct usb_descriptor_header *) &ecm_iad_descriptor, - (struct usb_descriptor_header *) &ecm_control_intf, - (struct usb_descriptor_header *) &ecm_header_desc, - (struct usb_descriptor_header *) &ecm_union_desc, - (struct usb_descriptor_header *) &ecm_desc, - - /* NOTE: status endpoint might need to be removed */ - (struct usb_descriptor_header *) &hs_ecm_notify_desc, - - /* data interface, altsettings 0 and 1 */ - (struct usb_descriptor_header *) &ecm_data_nop_intf, - (struct usb_descriptor_header *) &ecm_data_intf, - (struct usb_descriptor_header *) &hs_ecm_in_desc, - (struct usb_descriptor_header *) &hs_ecm_out_desc, - NULL, -}; - -/* super speed support: */ - -static struct usb_endpoint_descriptor ss_ecm_notify_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - - .bEndpointAddress = USB_DIR_IN, - .bmAttributes = USB_ENDPOINT_XFER_INT, - .wMaxPacketSize = cpu_to_le16(ECM_STATUS_BYTECOUNT), - .bInterval = USB_MS_TO_HS_INTERVAL(ECM_STATUS_INTERVAL_MS), -}; - -static struct usb_ss_ep_comp_descriptor ss_ecm_intr_comp_desc = { - .bLength = sizeof ss_ecm_intr_comp_desc, - .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, - - /* the following 3 values can be tweaked if necessary */ - /* .bMaxBurst = 0, */ - /* .bmAttributes = 0, */ - .wBytesPerInterval = cpu_to_le16(ECM_STATUS_BYTECOUNT), -}; - -static struct usb_endpoint_descriptor ss_ecm_in_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - - .bEndpointAddress = USB_DIR_IN, - .bmAttributes = USB_ENDPOINT_XFER_BULK, - .wMaxPacketSize = cpu_to_le16(1024), -}; - -static struct usb_endpoint_descriptor ss_ecm_out_desc = { - .bLength = USB_DT_ENDPOINT_SIZE, - .bDescriptorType = USB_DT_ENDPOINT, - - .bEndpointAddress = USB_DIR_OUT, - .bmAttributes = USB_ENDPOINT_XFER_BULK, - .wMaxPacketSize = cpu_to_le16(1024), -}; - -static struct usb_ss_ep_comp_descriptor ss_ecm_bulk_comp_desc = { - .bLength = sizeof ss_ecm_bulk_comp_desc, - .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, - - /* the following 2 values can be tweaked if necessary */ - /* .bMaxBurst = 0, */ - /* .bmAttributes = 0, */ -}; - -static struct usb_descriptor_header *ecm_ss_function[] = { - /* CDC ECM control descriptors */ - (struct usb_descriptor_header *) &ecm_iad_descriptor, - (struct usb_descriptor_header *) &ecm_control_intf, - (struct usb_descriptor_header *) &ecm_header_desc, - (struct usb_descriptor_header *) &ecm_union_desc, - (struct usb_descriptor_header *) &ecm_desc, - - /* NOTE: status endpoint might need to be removed */ - (struct usb_descriptor_header *) &ss_ecm_notify_desc, - (struct usb_descriptor_header *) &ss_ecm_intr_comp_desc, - - /* data interface, altsettings 0 and 1 */ - (struct usb_descriptor_header *) &ecm_data_nop_intf, - (struct usb_descriptor_header *) &ecm_data_intf, - (struct usb_descriptor_header *) &ss_ecm_in_desc, - (struct usb_descriptor_header *) &ss_ecm_bulk_comp_desc, - (struct usb_descriptor_header *) &ss_ecm_out_desc, - (struct usb_descriptor_header *) &ss_ecm_bulk_comp_desc, - NULL, -}; - -/* string descriptors: */ - -static struct usb_string ecm_string_defs[] = { - [0].s = "CDC Ethernet Control Model (ECM)", - [1].s = "", - [2].s = "CDC Ethernet Data", - [3].s = "CDC ECM", - { } /* end of list */ -}; - -static struct usb_gadget_strings ecm_string_table = { - .language = 0x0409, /* en-us */ - .strings = ecm_string_defs, -}; - -static struct usb_gadget_strings *ecm_strings[] = { - &ecm_string_table, - NULL, -}; - -/*-------------------------------------------------------------------------*/ - -static void ecm_do_notify(struct f_ecm *ecm) -{ - struct usb_request *req = ecm->notify_req; - struct usb_cdc_notification *event; - struct usb_composite_dev *cdev = ecm->port.func.config->cdev; - __le32 *data; - int status; - - /* notification already in flight? */ - if (!req) - return; - - event = req->buf; - switch (ecm->notify_state) { - case ECM_NOTIFY_NONE: - return; - - case ECM_NOTIFY_CONNECT: - event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION; - if (ecm->is_open) - event->wValue = cpu_to_le16(1); - else - event->wValue = cpu_to_le16(0); - event->wLength = 0; - req->length = sizeof *event; - - DBG(cdev, "notify connect %s\n", - ecm->is_open ? "true" : "false"); - ecm->notify_state = ECM_NOTIFY_SPEED; - break; - - case ECM_NOTIFY_SPEED: - event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE; - event->wValue = cpu_to_le16(0); - event->wLength = cpu_to_le16(8); - req->length = ECM_STATUS_BYTECOUNT; - - /* SPEED_CHANGE data is up/down speeds in bits/sec */ - data = req->buf + sizeof *event; - data[0] = cpu_to_le32(ecm_bitrate(cdev->gadget)); - data[1] = data[0]; - - DBG(cdev, "notify speed %d\n", ecm_bitrate(cdev->gadget)); - ecm->notify_state = ECM_NOTIFY_NONE; - break; - } - event->bmRequestType = 0xA1; - event->wIndex = cpu_to_le16(ecm->ctrl_id); - - ecm->notify_req = NULL; - status = usb_ep_queue(ecm->notify, req, GFP_ATOMIC); - if (status < 0) { - ecm->notify_req = req; - DBG(cdev, "notify --> %d\n", status); - } -} - -static void ecm_notify(struct f_ecm *ecm) -{ - /* NOTE on most versions of Linux, host side cdc-ethernet - * won't listen for notifications until its netdevice opens. - * The first notification then sits in the FIFO for a long - * time, and the second one is queued. - */ - ecm->notify_state = ECM_NOTIFY_CONNECT; - ecm_do_notify(ecm); -} - -static void ecm_notify_complete(struct usb_ep *ep, struct usb_request *req) -{ - struct f_ecm *ecm = req->context; - struct usb_composite_dev *cdev = ecm->port.func.config->cdev; - struct usb_cdc_notification *event = req->buf; - - switch (req->status) { - case 0: - /* no fault */ - break; - case -ECONNRESET: - case -ESHUTDOWN: - ecm->notify_state = ECM_NOTIFY_NONE; - break; - default: - DBG(cdev, "event %02x --> %d\n", - event->bNotificationType, req->status); - break; - } - ecm->notify_req = req; - ecm_do_notify(ecm); -} - -static int ecm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl) -{ - struct f_ecm *ecm = func_to_ecm(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(). - */ - switch ((ctrl->bRequestType << 8) | ctrl->bRequest) { - case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8) - | USB_CDC_SET_ETHERNET_PACKET_FILTER: - /* see 6.2.30: no data, wIndex = interface, - * wValue = packet filter bitmap - */ - if (w_length != 0 || w_index != ecm->ctrl_id) - goto invalid; - DBG(cdev, "packet filter %02x\n", w_value); - /* REVISIT locking of cdc_filter. This assumes the UDC - * driver won't have a concurrent packet TX irq running on - * another CPU; or that if it does, this write is atomic... - */ - ecm->port.cdc_filter = w_value; - value = 0; - break; - - /* and optionally: - * case USB_CDC_SEND_ENCAPSULATED_COMMAND: - * case USB_CDC_GET_ENCAPSULATED_RESPONSE: - * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS: - * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER: - * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER: - * case USB_CDC_GET_ETHERNET_STATISTIC: - */ - - default: -invalid: - DBG(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, "ecm req%02x.%02x v%04x i%04x l%d\n", - 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, "ecm req %02x.%02x response err %d\n", - ctrl->bRequestType, ctrl->bRequest, - value); - } - - /* device either stalls (value < 0) or reports success */ - return value; -} - - -static int ecm_set_alt(struct usb_function *f, unsigned intf, unsigned alt) -{ - struct f_ecm *ecm = func_to_ecm(f); - struct usb_composite_dev *cdev = f->config->cdev; - - /* Control interface has only altsetting 0 */ - if (intf == ecm->ctrl_id) { - if (alt != 0) - goto fail; - - if (ecm->notify->driver_data) { - VDBG(cdev, "reset ecm control %d\n", intf); - usb_ep_disable(ecm->notify); - } - if (!(ecm->notify->desc)) { - VDBG(cdev, "init ecm ctrl %d\n", intf); - if (config_ep_by_speed(cdev->gadget, f, ecm->notify)) - goto fail; - } - usb_ep_enable(ecm->notify); - ecm->notify->driver_data = ecm; - - /* Data interface has two altsettings, 0 and 1 */ - } else if (intf == ecm->data_id) { - if (alt > 1) - goto fail; - - if (ecm->port.in_ep->driver_data) { - DBG(cdev, "reset ecm\n"); - gether_disconnect(&ecm->port); - } - - if (!ecm->port.in_ep->desc || - !ecm->port.out_ep->desc) { - DBG(cdev, "init ecm\n"); - if (config_ep_by_speed(cdev->gadget, f, - ecm->port.in_ep) || - config_ep_by_speed(cdev->gadget, f, - ecm->port.out_ep)) { - ecm->port.in_ep->desc = NULL; - ecm->port.out_ep->desc = NULL; - goto fail; - } - } - - /* CDC Ethernet only sends data in non-default altsettings. - * Changing altsettings resets filters, statistics, etc. - */ - if (alt == 1) { - struct net_device *net; - - /* Enable zlps by default for ECM conformance; - * override for musb_hdrc (avoids txdma ovhead). - */ - ecm->port.is_zlp_ok = !(gadget_is_musbhdrc(cdev->gadget) - ); - ecm->port.cdc_filter = DEFAULT_FILTER; - DBG(cdev, "activate ecm\n"); - net = gether_connect(&ecm->port); - if (IS_ERR(net)) - return PTR_ERR(net); - } - - /* NOTE this can be a minor disagreement with the ECM spec, - * which says speed notifications will "always" follow - * connection notifications. But we allow one connect to - * follow another (if the first is in flight), and instead - * just guarantee that a speed notification is always sent. - */ - ecm_notify(ecm); - } else - goto fail; - - return 0; -fail: - return -EINVAL; -} - -/* Because the data interface supports multiple altsettings, - * this ECM function *MUST* implement a get_alt() method. - */ -static int ecm_get_alt(struct usb_function *f, unsigned intf) -{ - struct f_ecm *ecm = func_to_ecm(f); - - if (intf == ecm->ctrl_id) - return 0; - return ecm->port.in_ep->driver_data ? 1 : 0; -} - -static void ecm_disable(struct usb_function *f) -{ - struct f_ecm *ecm = func_to_ecm(f); - struct usb_composite_dev *cdev = f->config->cdev; - - DBG(cdev, "ecm deactivated\n"); - - if (ecm->port.in_ep->driver_data) - gether_disconnect(&ecm->port); - - if (ecm->notify->driver_data) { - usb_ep_disable(ecm->notify); - ecm->notify->driver_data = NULL; - ecm->notify->desc = NULL; - } -} - -/*-------------------------------------------------------------------------*/ - -/* - * Callbacks let us notify the host about connect/disconnect when the - * net device is opened or closed. - * - * For testing, note that link states on this side include both opened - * and closed variants of: - * - * - disconnected/unconfigured - * - configured but inactive (data alt 0) - * - configured and active (data alt 1) - * - * Each needs to be tested with unplug, rmmod, SET_CONFIGURATION, and - * SET_INTERFACE (altsetting). Remember also that "configured" doesn't - * imply the host is actually polling the notification endpoint, and - * likewise that "active" doesn't imply it's actually using the data - * endpoints for traffic. - */ - -static void ecm_open(struct gether *geth) -{ - struct f_ecm *ecm = func_to_ecm(&geth->func); - - DBG(ecm->port.func.config->cdev, "%s\n", __func__); - - ecm->is_open = true; - ecm_notify(ecm); -} - -static void ecm_close(struct gether *geth) -{ - struct f_ecm *ecm = func_to_ecm(&geth->func); - - DBG(ecm->port.func.config->cdev, "%s\n", __func__); - - ecm->is_open = false; - ecm_notify(ecm); -} - -/*-------------------------------------------------------------------------*/ - -/* ethernet function driver setup/binding */ - -static int -ecm_bind(struct usb_configuration *c, struct usb_function *f) -{ - struct usb_composite_dev *cdev = c->cdev; - struct f_ecm *ecm = func_to_ecm(f); - struct usb_string *us; - int status; - struct usb_ep *ep; - - struct f_ecm_opts *ecm_opts; - - if (!can_support_ecm(cdev->gadget)) - return -EINVAL; - - ecm_opts = container_of(f->fi, struct f_ecm_opts, func_inst); - - /* - * in drivers/usb/gadget/configfs.c:configfs_composite_bind() - * configurations are bound in sequence with list_for_each_entry, - * in each configuration its functions are bound in sequence - * with list_for_each_entry, so we assume no race condition - * with regard to ecm_opts->bound access - */ - if (!ecm_opts->bound) { - mutex_lock(&ecm_opts->lock); - gether_set_gadget(ecm_opts->net, cdev->gadget); - status = gether_register_netdev(ecm_opts->net); - mutex_unlock(&ecm_opts->lock); - if (status) - return status; - ecm_opts->bound = true; - } - - us = usb_gstrings_attach(cdev, ecm_strings, - ARRAY_SIZE(ecm_string_defs)); - if (IS_ERR(us)) - return PTR_ERR(us); - ecm_control_intf.iInterface = us[0].id; - ecm_data_intf.iInterface = us[2].id; - ecm_desc.iMACAddress = us[1].id; - ecm_iad_descriptor.iFunction = us[3].id; - - /* allocate instance-specific interface IDs */ - status = usb_interface_id(c, f); - if (status < 0) - goto fail; - ecm->ctrl_id = status; - ecm_iad_descriptor.bFirstInterface = status; - - ecm_control_intf.bInterfaceNumber = status; - ecm_union_desc.bMasterInterface0 = status; - - status = usb_interface_id(c, f); - if (status < 0) - goto fail; - ecm->data_id = status; - - ecm_data_nop_intf.bInterfaceNumber = status; - ecm_data_intf.bInterfaceNumber = status; - ecm_union_desc.bSlaveInterface0 = status; - - status = -ENODEV; - - /* allocate instance-specific endpoints */ - ep = usb_ep_autoconfig(cdev->gadget, &fs_ecm_in_desc); - if (!ep) - goto fail; - ecm->port.in_ep = ep; - ep->driver_data = cdev; /* claim */ - - ep = usb_ep_autoconfig(cdev->gadget, &fs_ecm_out_desc); - if (!ep) - goto fail; - ecm->port.out_ep = ep; - ep->driver_data = cdev; /* claim */ - - /* NOTE: a status/notification endpoint is *OPTIONAL* but we - * don't treat it that way. It's simpler, and some newer CDC - * profiles (wireless handsets) no longer treat it as optional. - */ - ep = usb_ep_autoconfig(cdev->gadget, &fs_ecm_notify_desc); - if (!ep) - goto fail; - ecm->notify = ep; - ep->driver_data = cdev; /* claim */ - - status = -ENOMEM; - - /* allocate notification request and buffer */ - ecm->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL); - if (!ecm->notify_req) - goto fail; - ecm->notify_req->buf = kmalloc(ECM_STATUS_BYTECOUNT, GFP_KERNEL); - if (!ecm->notify_req->buf) - goto fail; - ecm->notify_req->context = ecm; - ecm->notify_req->complete = ecm_notify_complete; - - /* support all relevant hardware speeds... we expect that when - * hardware is dual speed, all bulk-capable endpoints work at - * both speeds - */ - hs_ecm_in_desc.bEndpointAddress = fs_ecm_in_desc.bEndpointAddress; - hs_ecm_out_desc.bEndpointAddress = fs_ecm_out_desc.bEndpointAddress; - hs_ecm_notify_desc.bEndpointAddress = - fs_ecm_notify_desc.bEndpointAddress; - - ss_ecm_in_desc.bEndpointAddress = fs_ecm_in_desc.bEndpointAddress; - ss_ecm_out_desc.bEndpointAddress = fs_ecm_out_desc.bEndpointAddress; - ss_ecm_notify_desc.bEndpointAddress = - fs_ecm_notify_desc.bEndpointAddress; - - status = usb_assign_descriptors(f, ecm_fs_function, ecm_hs_function, - ecm_ss_function); - if (status) - goto fail; - - /* NOTE: all that is done without knowing or caring about - * the network link ... which is unavailable to this code - * until we're activated via set_alt(). - */ - - ecm->port.open = ecm_open; - ecm->port.close = ecm_close; - - DBG(cdev, "CDC Ethernet: %s speed IN/%s OUT/%s NOTIFY/%s\n", - gadget_is_superspeed(c->cdev->gadget) ? "super" : - gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full", - ecm->port.in_ep->name, ecm->port.out_ep->name, - ecm->notify->name); - return 0; - -fail: - if (ecm->notify_req) { - kfree(ecm->notify_req->buf); - usb_ep_free_request(ecm->notify, ecm->notify_req); - } - - /* we might as well release our claims on endpoints */ - if (ecm->notify) - ecm->notify->driver_data = NULL; - if (ecm->port.out_ep) - ecm->port.out_ep->driver_data = NULL; - if (ecm->port.in_ep) - ecm->port.in_ep->driver_data = NULL; - - ERROR(cdev, "%s: can't bind, err %d\n", f->name, status); - - return status; -} - -static inline struct f_ecm_opts *to_f_ecm_opts(struct config_item *item) -{ - return container_of(to_config_group(item), struct f_ecm_opts, - func_inst.group); -} - -/* f_ecm_item_ops */ -USB_ETHERNET_CONFIGFS_ITEM(ecm); - -/* f_ecm_opts_dev_addr */ -USB_ETHERNET_CONFIGFS_ITEM_ATTR_DEV_ADDR(ecm); - -/* f_ecm_opts_host_addr */ -USB_ETHERNET_CONFIGFS_ITEM_ATTR_HOST_ADDR(ecm); - -/* f_ecm_opts_qmult */ -USB_ETHERNET_CONFIGFS_ITEM_ATTR_QMULT(ecm); - -/* f_ecm_opts_ifname */ -USB_ETHERNET_CONFIGFS_ITEM_ATTR_IFNAME(ecm); - -static struct configfs_attribute *ecm_attrs[] = { - &f_ecm_opts_dev_addr.attr, - &f_ecm_opts_host_addr.attr, - &f_ecm_opts_qmult.attr, - &f_ecm_opts_ifname.attr, - NULL, -}; - -static struct config_item_type ecm_func_type = { - .ct_item_ops = &ecm_item_ops, - .ct_attrs = ecm_attrs, - .ct_owner = THIS_MODULE, -}; - -static void ecm_free_inst(struct usb_function_instance *f) -{ - struct f_ecm_opts *opts; - - opts = container_of(f, struct f_ecm_opts, func_inst); - if (opts->bound) - gether_cleanup(netdev_priv(opts->net)); - else - free_netdev(opts->net); - kfree(opts); -} - -static struct usb_function_instance *ecm_alloc_inst(void) -{ - struct f_ecm_opts *opts; - - opts = kzalloc(sizeof(*opts), GFP_KERNEL); - if (!opts) - return ERR_PTR(-ENOMEM); - mutex_init(&opts->lock); - opts->func_inst.free_func_inst = ecm_free_inst; - opts->net = gether_setup_default(); - if (IS_ERR(opts->