/* * f_serial.c - generic USB serial function driver * * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com) * Copyright (C) 2008 by David Brownell * Copyright (C) 2008 by Nokia Corporation * * 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. */ #include #include #include #include #include "u_serial.h" #include "gadget_chips.h" /* * This function packages a simple "generic serial" port with no real * control mechanisms, just raw data transfer over two bulk endpoints. * * Because it's not standardized, this isn't as interoperable as the * CDC ACM driver. However, for many purposes it's just as functional * if you can arrange appropriate host side drivers. */ #define GSERIAL_NO_PORTS 3 struct f_gser { struct gserial port; u8 data_id; u8 port_num; u8 online; enum transport_type transport; #ifdef CONFIG_MODEM_SUPPORT u8 pending; spinlock_t lock; struct usb_ep *notify; struct usb_request *notify_req; struct usb_cdc_line_coding port_line_coding; /* SetControlLineState request */ 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 */ 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) #endif }; static unsigned int no_tty_ports; static unsigned int no_sdio_ports; static unsigned int no_smd_ports; static unsigned int no_hsic_sports; static unsigned int no_hsuart_sports; static unsigned int nr_ports; static struct port_info { enum transport_type transport; unsigned port_num; unsigned client_port_num; } gserial_ports[GSERIAL_NO_PORTS]; static inline bool is_transport_sdio(enum transport_type t) { if (t == USB_GADGET_XPORT_SDIO) return 1; return 0; } static inline struct f_gser *func_to_gser(struct usb_function *f) { return container_of(f, struct f_gser, port.func); } #ifdef CONFIG_MODEM_SUPPORT static inline struct f_gser *port_to_gser(struct gserial *p) { return container_of(p, struct f_gser, port); } #define GS_LOG2_NOTIFY_INTERVAL 5 /* 1 << 5 == 32 msec */ #define GS_NOTIFY_MAXPACKET 10 /* notification + 2 bytes */ #endif /*-------------------------------------------------------------------------*/ /* interface descriptor: */ static struct usb_interface_descriptor gser_interface_desc = { .bLength = USB_DT_INTERFACE_SIZE, .bDescriptorType = USB_DT_INTERFACE, /* .bInterfaceNumber = DYNAMIC */ #ifdef CONFIG_MODEM_SUPPORT .bNumEndpoints = 3, #else .bNumEndpoints = 2, #endif .bInterfaceClass = USB_CLASS_VENDOR_SPEC, .bInterfaceSubClass = 0, .bInterfaceProtocol = 0, /* .iInterface = DYNAMIC */ }; #ifdef CONFIG_MODEM_SUPPORT static struct usb_cdc_header_desc gser_header_desc = { .bLength = sizeof(gser_header_desc), .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubType = USB_CDC_HEADER_TYPE, .bcdCDC = __constant_cpu_to_le16(0x0110), }; static struct usb_cdc_call_mgmt_descriptor gser_call_mgmt_descriptor = { .bLength = sizeof(gser_call_mgmt_descriptor), .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE, .bmCapabilities = 0, /* .bDataInterface = DYNAMIC */ }; static struct usb_cdc_acm_descriptor gser_descriptor = { .bLength = sizeof(gser_descriptor), .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubType = USB_CDC_ACM_TYPE, .bmCapabilities = USB_CDC_CAP_LINE, }; static struct usb_cdc_union_desc gser_union_desc = { .bLength = sizeof(gser_union_desc), .bDescriptorType = USB_DT_CS_INTERFACE, .bDescriptorSubType = USB_CDC_UNION_TYPE, /* .bMasterInterface0 = DYNAMIC */ /* .bSlaveInterface0 = DYNAMIC */ }; #endif /* full speed support: */ #ifdef CONFIG_MODEM_SUPPORT static struct usb_endpoint_descriptor gser_fs_notify_desc = { .bLength = USB_DT_ENDPOINT_SIZE, .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = USB_DIR_IN, .bmAttributes = USB_ENDPOINT_XFER_INT, .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET), .bInterval = 1 << GS_LOG2_NOTIFY_INTERVAL, }; #endif static struct usb_endpoint_descriptor gser_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 gser_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 *gser_fs_function[] = { (struct usb_descriptor_header *) &gser_interface_desc, #ifdef CONFIG_MODEM_SUPPORT (struct usb_descriptor_header *) &gser_header_desc, (struct usb_descriptor_header *) &gser_call_mgmt_descriptor, (struct usb_descriptor_header *) &gser_descriptor, (struct usb_descriptor_header *) &gser_union_desc, (struct usb_descriptor_header *) &gser_fs_notify_desc, #endif (struct usb_descriptor_header *) &gser_fs_in_desc, (struct usb_descriptor_header *) &gser_fs_out_desc, NULL, }; /* high speed support: */ #ifdef CONFIG_MODEM_SUPPORT static struct usb_endpoint_descriptor gser_hs_notify_desc = { .bLength = USB_DT_ENDPOINT_SIZE, .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = USB_DIR_IN, .bmAttributes = USB_ENDPOINT_XFER_INT, .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET), .bInterval = GS_LOG2_NOTIFY_INTERVAL+4, }; #endif static struct usb_endpoint_descriptor gser_hs_in_desc = { .bLength = USB_DT_ENDPOINT_SIZE, .bDescriptorType = USB_DT_ENDPOINT, .bmAttributes = USB_ENDPOINT_XFER_BULK, .wMaxPacketSize = __constant_cpu_to_le16(512), }; static struct usb_endpoint_descriptor gser_hs_out_desc = { .bLength = USB_DT_ENDPOINT_SIZE, .bDescriptorType = USB_DT_ENDPOINT, .bmAttributes = USB_ENDPOINT_XFER_BULK, .wMaxPacketSize = __constant_cpu_to_le16(512), }; static struct usb_descriptor_header *gser_hs_function[] = { (struct usb_descriptor_header *) &gser_interface_desc, #ifdef CONFIG_MODEM_SUPPORT (struct usb_descriptor_header *) &gser_header_desc, (struct usb_descriptor_header *) &gser_call_mgmt_descriptor, (struct usb_descriptor_header *) &gser_descriptor, (struct usb_descriptor_header *) &gser_union_desc, (struct usb_descriptor_header *) &gser_hs_notify_desc, #endif (struct usb_descriptor_header *) &gser_hs_in_desc, (struct usb_descriptor_header *) &gser_hs_out_desc, NULL, }; static struct usb_endpoint_descriptor gser_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 gser_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 gser_ss_bulk_comp_desc = { .bLength = sizeof gser_ss_bulk_comp_desc, .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, }; #ifdef CONFIG_MODEM_SUPPORT static struct usb_endpoint_descriptor gser_ss_notify_desc = { .bLength = USB_DT_ENDPOINT_SIZE, .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = USB_DIR_IN, .bmAttributes = USB_ENDPOINT_XFER_INT, .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET), .bInterval = GS_LOG2_NOTIFY_INTERVAL+4, }; static struct usb_ss_ep_comp_descriptor gser_ss_notify_comp_desc = { .bLength = sizeof gser_ss_notify_comp_desc, .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, /* the following 2 values can be tweaked if necessary */ /* .bMaxBurst = 0, */ /* .bmAttributes = 0, */ .wBytesPerInterval = cpu_to_le16(GS_NOTIFY_MAXPACKET), }; #endif static struct usb_descriptor_header *gser_ss_function[] = { (struct usb_descriptor_header *) &gser_interface_desc, #ifdef CONFIG_MODEM_SUPPORT (struct usb_descriptor_header *) &gser_header_desc, (struct usb_descriptor_header *) &gser_call_mgmt_descriptor, (struct usb_descriptor_header *) &gser_descriptor, (struct usb_descriptor_header *) &gser_union_desc, (struct usb_descriptor_header *) &gser_ss_notify_desc, (struct usb_descriptor_header *) &gser_ss_notify_comp_desc, #endif (struct usb_descriptor_header *) &gser_ss_in_desc, (struct usb_descriptor_header *) &gser_ss_bulk_comp_desc, (struct usb_descriptor_header *) &gser_ss_out_desc, (struct usb_descriptor_header *) &gser_ss_bulk_comp_desc, NULL, }; /* string descriptors: */ static struct usb_string gser_string_defs[] = { [0].s = "Generic Serial", { } /* end of list */ }; static struct usb_gadget_strings gser_string_table = { .language = 0x0409, /* en-us */ .strings = gser_string_defs, }; static struct usb_gadget_strings *gser_strings[] = { &gser_string_table, NULL, }; static int gport_setup(struct usb_configuration *c) { int ret = 0; int port_idx; int i; pr_debug("%s: no_tty_ports: %u no_sdio_ports: %u" " no_smd_ports: %u no_hsic_sports: %u no_hsuart_ports: %u nr_ports: %u\n", __func__, no_tty_ports, no_sdio_ports, no_smd_ports, no_hsic_sports, no_hsuart_sports, nr_ports); if (no_tty_ports) ret = gserial_setup(c->cdev->gadget, no_tty_ports); if (no_sdio_ports) ret = gsdio_setup(c->cdev->gadget, no_sdio_ports); if (no_smd_ports) ret = gsmd_setup(c->cdev->gadget, no_smd_ports); if (no_hsic_sports) { port_idx = ghsic_data_setup(no_hsic_sports, USB_GADGET_SERIAL); if (port_idx < 0) return port_idx; for (i = 0; i < nr_ports; i++) { if (gserial_ports[i].transport == USB_GADGET_XPORT_HSIC) { gserial_ports[i].client_port_num = port_idx; port_idx++; } } /*clinet port num is same for data setup and ctrl setup*/ ret = ghsic_ctrl_setup(no_hsic_sports, USB_GADGET_SERIAL); if (ret < 0) return ret; } if (no_hsuart_sports) { port_idx = ghsuart_data_setup(no_hsuart_sports, USB_GADGET_SERIAL); if (port_idx < 0) return port_idx; for (i = 0; i < nr_ports; i++) { if (gserial_ports[i].transport == USB_GADGET_XPORT_HSUART) { gserial_ports[i].client_port_num = port_idx; port_idx++; } } } return ret; } static int gport_connect(struct f_gser *gser) { unsigned port_num; int ret; pr_debug("%s: transport: %s f_gser: %p gserial: %p port_num: %d\n", __func__, xport_to_str(gser->transport), gser, &gser->port, gser->port_num); port_num = gserial_ports[gser->port_num].client_port_num; switch (gser->transport) { case USB_GADGET_XPORT_TTY: gserial_connect(&gser->port, port_num); break; case USB_GADGET_XPORT_SDIO: gsdio_connect(&gser->port, port_num); break; case USB_GADGET_XPORT_SMD: gsmd_connect(&gser->port, port_num); break; case USB_GADGET_XPORT_HSIC: ret = ghsic_ctrl_connect(&gser->port, port_num); if (ret) { pr_err("%s: ghsic_ctrl_connect failed: err:%d\n", __func__, ret); return ret; } ret = ghsic_data_connect(&gser->port, port_num); if (ret) { pr_err("%s: ghsic_data_connect failed: err:%d\n", __func__, ret); ghsic_ctrl_disconnect(&gser->port, port_num); return ret; } break; case USB_GADGET_XPORT_HSUART: ret = ghsuart_data_connect(&gser->port, port_num); if (ret) { pr_err("%s: ghsuart_data_connect failed: err:%d\n", __func__, ret); return ret; } break; default: pr_err("%s: Un-supported transport: %s\n", __func__, xport_to_str(gser->transport)); return -ENODEV; } return 0; } static int gport_disconnect(struct f_gser *gser) { unsigned port_num; pr_debug("%s: transport: %s f_gser: %p gserial: %p port_num: %d\n", __func__, xport_to_str(gser->transport), gser, &gser->port, gser->port_num); port_num = gserial_ports[gser->port_num].client_port_num; switch (gser->transport) { case USB_GADGET_XPORT_TTY: gserial_disconnect(&gser->port); break; case USB_GADGET_XPORT_SDIO: gsdio_disconnect(&gser->port, port_num); break; case USB_GADGET_XPORT_SMD: gsmd_disconnect(&gser->port, port_num); break; case USB_GADGET_XPORT_HSIC: ghsic_ctrl_disconnect(&gser->port, port_num); ghsic_data_disconnect(&gser->port, port_num); break; case USB_GADGET_XPORT_HSUART: ghsuart_data_disconnect(&gser->port, port_num); break; default: pr_err("%s: Un-supported transport:%s\n", __func__, xport_to_str(gser->transport)); return -ENODEV; } return 0; } #ifdef CONFIG_MODEM_SUPPORT static void gser_complete_set_line_coding(struct usb_ep *ep, struct usb_request *req) { struct f_gser *gser = ep->driver_data; struct usb_composite_dev *cdev = gser->port.func.config->cdev; if (req->status != 0) { DBG(cdev, "gser ttyGS%d completion, err %d\n", gser->port_num, req->status); return; } /* normal completion */ if (req->actual != sizeof(gser->port_line_coding)) { DBG(cdev, "gser ttyGS%d short resp, len %d\n", gser->port_num, req->actual); usb_ep_set_halt(ep); } else { struct usb_cdc_line_coding *value = req->buf; gser->port_line_coding = *value; } } /*-------------------------------------------------------------------------*/ static int gser_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl) { struct f_gser *gser = func_to_gser(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); 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)) goto invalid; value = w_length; cdev->gadget->ep0->driver_data = gser; req->complete = gser_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: value = min_t(unsigned, w_length, sizeof(struct usb_cdc_line_coding)); memcpy(req->buf, &gser->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: value = 0; gser->port_handshake_bits = w_value; if (gser->port.notify_modem) { unsigned port_num = gserial_ports[gser->port_num].client_port_num; gser->port.notify_modem(&gser->port, port_num, w_value); } break; 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, "gser ttyGS%d req%02x.%02x v%04x i%04x l%d\n", gser->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, "gser response on ttyGS%d, err %d\n", gser->port_num, value); } /* device either stalls (value < 0) or reports success */ return value; } #endif static int gser_set_alt(struct usb_function *f, unsigned intf, unsigned alt) { struct f_gser *gser = func_to_gser(f); struct usb_composite_dev *cdev = f->config->cdev; int rc = 0; /* we know alt == 0, so this is an activation or a reset */ #ifdef CONFIG_MODEM_SUPPORT if (gser->notify->driver_data) { DBG(cdev, "reset generic ctl ttyGS%d\n", gser->port_num); usb_ep_disable(gser->notify); } if (!gser->notify->desc) { if (config_ep_by_speed(cdev->gadget, f, gser->notify)) { gser->notify->desc = NULL; return -EINVAL; } } rc = usb_ep_enable(gser->notify); if (rc) { ERROR(cdev, "can't enable %s, result %d\n", gser->notify->name, rc); return rc; } gser->notify->driver_data = gser; #endif if (gser->port.in->driver_data) { DBG(cdev, "reset generic data ttyGS%d\n", gser->port_num); gport_disconnect(gser); } if (!gser->port.in->desc || !gser->port.out->desc) { DBG(cdev, "activate generic ttyGS%d\n", gser->port_num); if (config_ep_by_speed(cdev->gadget, f, gser->port.in) || config_ep_by_speed(cdev->gadget, f, gser->port.out)) { gser->port.in->desc = NULL; gser->port.out->desc = NULL; return -EINVAL; } } gport_connect(gser); gser->online = 1; return rc; } static void gser_disable(struct usb_function *f) { struct f_gser *gser = func_to_gser(f); struct usb_composite_dev *cdev = f->config->cdev; DBG(cdev, "generic ttyGS%d deactivated\n", gser->port_num); gport_disconnect(gser); #ifdef CONFIG_MODEM_SUPPORT usb_ep_fifo_flush(gser->notify); usb_ep_disable(gser->notify); gser->notify->driver_data = NULL; #endif gser->online = 0; } #ifdef CONFIG_MODEM_SUPPORT static int gser_notify(struct f_gser *gser, u8 type, u16 value, void *data, unsigned length) { struct usb_ep *ep = gser->notify; struct usb_request *req; struct usb_cdc_notification *notify; const unsigned len = sizeof(*notify) + length; void *buf; int status; struct usb_composite_dev *cdev = gser->port.func.config->cdev; req = gser->notify_req; gser->notify_req = NULL; gser->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(gser->data_id); notify->wLength = cpu_to_le16(length); memcpy(buf, data, length); status = usb_ep_queue(ep, req, GFP_ATOMIC); if (status < 0) { ERROR(cdev, "gser ttyGS%d can't notify serial state, %d\n", gser->port_num, status); gser->notify_req = req; } return status; } static int gser_notify_serial_state(struct f_gser *gser) { int status; unsigned long flags; struct usb_composite_dev *cdev = gser->port.func.config->cdev; spin_lock_irqsave(&gser->lock, flags); if (gser->notify_req) { DBG(cdev, "gser ttyGS%d serial state %04x\n", gser->port_num, gser->serial_state); status = gser_notify(gser, USB_CDC_NOTIFY_SERIAL_STATE, 0, &gser->serial_state, sizeof(gser->serial_state)); } else { gser->pending = true; status = 0; } spin_unlock_irqrestore(&gser->lock, flags); return status; } static void gser_notify_complete(struct usb_ep *ep, struct usb_request *req) { struct f_gser *gser = req->context; u8 doit = false; unsigned long flags; /* on this call path we do NOT hold the port spinlock, * which is why ACM needs its own spinlock */ spin_lock_irqsave(&gser->lock, flags); if (req->status != -ESHUTDOWN) doit = gser->pending; gser->notify_req = req; spin_unlock_irqrestore(&gser->lock, flags); if (doit && gser->online) gser_notify_serial_state(gser); } static void gser_connect(struct gserial *port) { struct f_gser *gser = port_to_gser(port); gser->serial_state |= ACM_CTRL_DSR | ACM_CTRL_DCD; gser_notify_serial_state(gser); } unsigned int gser_get_dtr(struct gserial *port) { struct f_gser *gser = port_to_gser(port); if (gser->port_handshake_bits & ACM_CTRL_DTR) return 1; else return 0; } unsigned int gser_get_rts(struct gserial *port) { struct f_gser *gser = port_to_gser(port); if (gser->port_handshake_bits & ACM_CTRL_RTS) return 1; else return 0; } unsigned int gser_send_carrier_detect(struct gserial *port, unsigned int yes) { struct f_gser *gser = port_to_gser(port); u16 state; state = gser->serial_state; state &= ~ACM_CTRL_DCD; if (yes) state |= ACM_CTRL_DCD; gser->serial_state = state; return gser_notify_serial_state(gser); } unsigned int gser_send_ring_indicator(struct gserial *port, unsigned int yes) { struct f_gser *gser = port_to_gser(port); u16 state; state = gser->serial_state; state &= ~ACM_CTRL_RI; if (yes) state |= ACM_CTRL_RI; gser->serial_state = state; return gser_notify_serial_state(gser); } static void gser_disconnect(struct gserial *port) { struct f_gser *gser = port_to_gser(port); gser->serial_state &= ~(ACM_CTRL_DSR | ACM_CTRL_DCD); gser_notify_serial_state(gser); } static int gser_send_break(struct gserial *port, int duration) { struct f_gser *gser = port_to_gser(port); u16 state; state = gser->serial_state; state &= ~ACM_CTRL_BRK; if (duration) state |= ACM_CTRL_BRK; gser->serial_state = state; return gser_notify_serial_state(gser); } static int gser_send_modem_ctrl_bits(struct gserial *port, int ctrl_bits) { struct f_gser *gser = port_to_gser(port); gser->serial_state = ctrl_bits; return gser_notify_serial_state(gser); } #endif /*-------------------------------------------------------------------------*/ /* serial function driver setup/binding */ static int gser_bind(struct usb_configuration *c, struct usb_function *f) { struct usb_composite_dev *cdev = c->cdev; struct f_gser *gser = func_to_gser(f); int status; struct usb_ep *ep; /* allocate instance-specific interface IDs */ status = usb_interface_id(c, f); if (status < 0) goto fail; gser->data_id = status; gser_interface_desc.bInterfaceNumber = status; status = -ENODEV; /* allocate instance-specific endpoints */ ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_in_desc); if (!ep) goto fail; gser->port.in = ep; ep->driver_data = cdev; /* claim */ ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_out_desc); if (!ep) goto fail; gser->port.out = ep; ep->driver_data = cdev; /* claim */ #ifdef CONFIG_MODEM_SUPPORT ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_notify_desc); if (!ep) goto fail; gser->notify = ep; ep->driver_data = cdev; /* claim */ /* allocate notification */ gser->notify_req = gs_alloc_req(ep, sizeof(struct usb_cdc_notification) + 2, GFP_KERNEL); if (!gser->notify_req) goto fail; gser->notify_req->complete = gser_notify_complete; gser->notify_req->context = gser; #endif /* copy descriptors, and track endpoint copies */ f->descriptors = usb_copy_descriptors(gser_fs_function); if (!f->descriptors) goto fail; /* support all relevant hardware speeds... we expect that when * hardware is dual speed, all bulk-capable endpoints work at * both speeds */ if (gadget_is_dualspeed(c->cdev->gadget)) { gser_hs_in_desc.bEndpointAddress = gser_fs_in_desc.bEndpointAddress; gser_hs_out_desc.bEndpointAddress = gser_fs_out_desc.bEndpointAddress; #ifdef CONFIG_MODEM_SUPPORT gser_hs_notify_desc.bEndpointAddress = gser_fs_notify_desc.bEndpointAddress; #endif /* copy descriptors, and track endpoint copies */ f->hs_descriptors = usb_copy_descriptors(gser_hs_function); if (!f->hs_descriptors) goto fail; } if (gadget_is_superspeed(c->cdev->gadget)) { gser_ss_in_desc.bEndpointAddress = gser_fs_in_desc.bEndpointAddress; gser_ss_out_desc.bEndpointAddress = gser_fs_out_desc.bEndpointAddress; #ifdef CONFIG_MODEM_SUPPORT gser_ss_notify_desc.bEndpointAddress = gser_fs_notify_desc.bEndpointAddress; #endif /* copy descriptors, and track endpoint copies */ f->ss_descriptors = usb_copy_descriptors(gser_ss_function); if (!f->ss_descriptors) goto fail; } DBG(cdev, "generic ttyGS%d: %s speed IN/%s OUT/%s\n", gser->port_num, gadget_is_superspeed(c->cdev->gadget) ? "super" : gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full", gser->port.in->name, gser->port.out->name); return 0; fail: if (f->ss_descriptors) usb_free_descriptors(f->ss_descriptors); if (f->hs_descriptors) usb_free_descriptors(f->hs_descriptors); if (f->descriptors) usb_free_descriptors(f->descriptors); #ifdef CONFIG_MODEM_SUPPORT if (gser->notify_req) gs_free_req(gser->notify, gser->notify_req); /* we might as well release our claims on endpoints */ if (gser->notify) gser->notify->driver_data = NULL; #endif /* we might as well release our claims on endpoints */ if (gser->port.out) gser->port.out->driver_data = NULL; if (gser->port.in) gser->port.in->driver_data = NULL; ERROR(cdev, "%s: can't bind, err %d\n", f->name, status); return status; } static void gser_unbind(struct usb_configuration *c, struct usb_function *f) { #ifdef CONFIG_MODEM_SUPPORT struct f_gser *gser = func_to_gser(f); #endif if (gadget_is_dualspeed(c->cdev->gadget)) usb_free_descriptors(f->hs_descriptors); if (gadget_is_superspeed(c->cdev->gadget)) usb_free_descriptors(f->ss_descriptors); usb_free_descriptors(f->descriptors); #ifdef CONFIG_MODEM_SUPPORT gs_free_req(gser->notify, gser->notify_req); #endif kfree(func_to_gser(f)); } /** * gser_bind_config - add a generic serial function to a configuration * @c: the configuration to support the serial instance * @port_num: /dev/ttyGS* port this interface will use * Context: single threaded during gadget setup * * Returns zero on success, else negative errno. * * Caller must have called @gserial_setup() with enough ports to * handle all the ones it binds. Caller is also responsible * for calling @gserial_cleanup() before module unload. */ int gser_bind_config(struct usb_configuration *c, u8 port_num) { struct f_gser *gser; int status; /* REVISIT might want instance-specific strings to help * distinguish instances ... */ /* maybe allocate device-global string ID */ if (gser_string_defs[0].id == 0) { status = usb_string_id(c->cdev); if (status < 0) return status; gser_string_defs[0].id = status; } /* allocate and initialize one new instance */ gser = kzalloc(sizeof *gser, GFP_KERNEL); if (!gser) return -ENOMEM; #ifdef CONFIG_MODEM_SUPPORT spin_lock_init(&gser->lock); #endif gser->port_num = port_num; gser->port.func.name = "gser"; gser->port.func.strings = gser_strings; gser->port.func.bind = gser_bind; gser->port.func.unbind = gser_unbind; gser->port.func.set_alt = gser_set_alt; gser->port.func.disable = gser_disable; gser->transport = gserial_ports[port_num].transport; #ifdef CONFIG_MODEM_SUPPORT /* We support only three ports for now */ if (port_num == 0) gser->port.func.name = "modem"; else if (port_num == 1) gser->port.func.name = "nmea"; else gser->port.func.name = "modem2"; gser->port.func.setup = gser_setup; gser->port.connect = gser_connect; gser->port.get_dtr = gser_get_dtr; gser->port.get_rts = gser_get_rts; gser->port.send_carrier_detect = gser_send_carrier_detect; gser->port.send_ring_indicator = gser_send_ring_indicator; gser->port.send_modem_ctrl_bits = gser_send_modem_ctrl_bits; gser->port.disconnect = gser_disconnect; gser->port.send_break = gser_send_break; #endif status = usb_add_function(c, &gser->port.func); if (status) kfree(gser); return status; } /** * gserial_init_port - bind a gserial_port to its transport */ static int gserial_init_port(int port_num, const char *name) { enum transport_type transport; if (port_num >= GSERIAL_NO_PORTS) return -ENODEV; transport = str_to_xport(name); pr_debug("%s, port:%d, transport:%s\n", __func__, port_num, xport_to_str(transport)); gserial_ports[port_num].transport = transport; gserial_ports[port_num].port_num = port_num; switch (transport) { case USB_GADGET_XPORT_TTY: gserial_ports[port_num].client_port_num = no_tty_ports; no_tty_ports++; break; case USB_GADGET_XPORT_SDIO: gserial_ports[port_num].client_port_num = no_sdio_ports; no_sdio_ports++; break; case USB_GADGET_XPORT_SMD: gserial_ports[port_num].client_port_num = no_smd_ports; no_smd_ports++; break; case USB_GADGET_XPORT_HSIC: /*client port number will be updated in gport_setup*/ no_hsic_sports++; break; case USB_GADGET_XPORT_HSUART: /*client port number will be updated in gport_setup*/ no_hsuart_sports++; break; default: pr_err("%s: Un-supported transport transport: %u\n", __func__, gserial_ports[port_num].transport); return -ENODEV; } nr_ports++; return 0; }