usb gadget: issue notifications from ACM function (1f1ba11b) · Commits · 戴 / test

drivers/usb/gadget/f_acm.c

+183 −11

Original line number	Diff line number	Diff line
		@@ -47,16 +47,37 @@ struct f_acm {
		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 acm_ep_descs fs;
		struct acm_ep_descs hs;

		struct usb_ep *notify;
		struct usb_endpoint_descriptor *notify_desc;
		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 RS232_RTS (1 << 1) /* unused with full duplex */
		#define RS232_DTR (1 << 0) /* host is ready for data r/w */
		#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)
		@@ -64,12 +85,17 @@ 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_LOG2_NOTIFY_INTERVAL 5 /* 1 << 5 == 32 msec */
		#define GS_NOTIFY_MAXPACKET 8
		#define GS_NOTIFY_MAXPACKET 10 /* notification + 2 bytes */

		/* interface and class descriptors: */

		@@ -115,7 +141,7 @@ static struct usb_cdc_acm_descriptor acm_descriptor __initdata = {
		.bLength = sizeof(acm_descriptor),
		.bDescriptorType = USB_DT_CS_INTERFACE,
		.bDescriptorSubType = USB_CDC_ACM_TYPE,
		.bmCapabilities = (1 << 1),
		.bmCapabilities = USB_CDC_CAP_LINE,
		};

		static struct usb_cdc_union_desc acm_union_desc __initdata = {
		@@ -275,6 +301,11 @@ static int acm_setup(struct usb_function f, const struct usb_ctrlrequest ctrl)

		/* 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) {

		@@ -310,7 +341,7 @@ static int acm_setup(struct usb_function f, const struct usb_ctrlrequest ctrl)
		value = 0;

		/* FIXME we should not allow data to flow until the
		* host sets the RS232_DTR bit; and when it clears
		* 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;
		@@ -348,9 +379,6 @@ static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
		/* we know alt == 0, so this is an activation or a reset */

		if (intf == acm->ctrl_id) {
		/* REVISIT this may need more work when we start to
		* send notifications ...
		*/
		if (acm->notify->driver_data) {
		VDBG(cdev, "reset acm control interface %d\n", intf);
		usb_ep_disable(acm->notify);
		@@ -395,6 +423,128 @@ static void acm_disable(struct usb_function *f)

		/-------------------------------------------------------------------------/

		/**
		* 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 sucess 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);

		status = usb_ep_queue(ep, req, GFP_ATOMIC);
		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 __init
		acm_bind(struct usb_configuration c, struct usb_function f)
		@@ -443,8 +593,20 @@ acm_bind(struct usb_configuration c, struct usb_function f)
		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;

		/* copy descriptors, and track endpoint copies */
		f->descriptors = usb_copy_descriptors(acm_fs_function);
		if (!f->descriptors)
		goto fail;

		acm->fs.in = usb_find_endpoint(acm_fs_function,
		f->descriptors, &acm_fs_in_desc);
		@@ -476,8 +638,6 @@ acm_bind(struct usb_configuration c, struct usb_function f)
		f->hs_descriptors, &acm_hs_notify_desc);
		}

		/* FIXME provide a callback for triggering notifications */

		DBG(cdev, "acm ttyGS%d: %s speed IN/%s OUT/%s NOTIFY/%s\n",
		acm->port_num,
		gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
		@@ -486,6 +646,9 @@ acm_bind(struct usb_configuration c, struct usb_function f)
		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;
		@@ -502,10 +665,13 @@ fail:
		static void
		acm_unbind(struct usb_configuration c, struct usb_function f)
		{
		struct f_acm *acm = func_to_acm(f);

		if (gadget_is_dualspeed(c->cdev->gadget))
		usb_free_descriptors(f->hs_descriptors);
		usb_free_descriptors(f->descriptors);
		kfree(func_to_acm(f));
		gs_free_req(acm->notify, acm->notify_req);
		kfree(acm);
		}

		/* Some controllers can't support CDC ACM ... */
		@@ -569,8 +735,14 @@ int __init acm_bind_config(struct usb_configuration *c, u8 port_num)
		if (!acm)
		return -ENOMEM;

		spin_lock_init(&acm->lock);

		acm->port_num = port_num;

		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 */

drivers/usb/gadget/u_serial.c

+42 −14

Original line number	Diff line number	Diff line
		@@ -60,7 +60,8 @@
		* tty_struct links to the tty/filesystem framework
		*
		* gserial <---> gs_port ... links will be null when the USB link is
		* inactive; managed by gserial_{connect,disconnect}().
		* inactive; managed by gserial_{connect,disconnect}(). each gserial
		* instance can wrap its own USB control protocol.
		* gserial->ioport == usb_ep->driver_data ... gs_port
		* gs_port->port_usb ... gserial
		*
		@@ -181,7 +182,7 @@ static void gs_buf_clear(struct gs_buf *gb)
		/*
		* gs_buf_data_avail
		*
		* Return the number of bytes of data available in the circular
		* Return the number of bytes of data written into the circular
		* buffer.
		*/
		static unsigned gs_buf_data_avail(struct gs_buf *gb)
		@@ -282,7 +283,7 @@ gs_buf_get(struct gs_buf gb, char buf, unsigned count)
		* Allocate a usb_request and its buffer. Returns a pointer to the
		* usb_request or NULL if there is an error.
		*/
		static struct usb_request *
		struct usb_request *
		gs_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
		{
		struct usb_request *req;
		@@ -306,7 +307,7 @@ gs_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
		*
		* Free a usb_request and its buffer.
		*/
		static void gs_free_req(struct usb_ep ep, struct usb_request req)
		void gs_free_req(struct usb_ep ep, struct usb_request req)
		{
		kfree(req->buf);
		usb_ep_free_request(ep, req);
		@@ -788,10 +789,13 @@ static int gs_open(struct tty_struct tty, struct file file)

		/* if connected, start the I/O stream */
		if (port->port_usb) {
		struct gserial *gser = port->port_usb;

		pr_debug("gs_open: start ttyGS%d\n", port->port_num);
		gs_start_io(port);

		/* REVISIT for ACM, issue "network connected" event */
		if (gser->connect)
		gser->connect(gser);
		}

		pr_debug("gs_open: ttyGS%d (%p,%p)\n", port->port_num, tty, file);
		@@ -818,6 +822,7 @@ static int gs_writes_finished(struct gs_port *p)
		static void gs_close(struct tty_struct tty, struct file file)
		{
		struct gs_port *port = tty->driver_data;
		struct gserial *gser;

		spin_lock_irq(&port->port_lock);

		@@ -837,26 +842,27 @@ static void gs_close(struct tty_struct tty, struct file file)
		port->openclose = true;
		port->open_count = 0;

		if (port->port_usb)
		/* REVISIT for ACM, issue "network disconnected" event */;
		gser = port->port_usb;
		if (gser && gser->disconnect)
		gser->disconnect(gser);

		/* wait for circular write buffer to drain, disconnect, or at
		* most GS_CLOSE_TIMEOUT seconds; then discard the rest
		*/
		if (gs_buf_data_avail(&port->port_write_buf) > 0
		&& port->port_usb) {
		if (gs_buf_data_avail(&port->port_write_buf) > 0 && gser) {
		spin_unlock_irq(&port->port_lock);
		wait_event_interruptible_timeout(port->drain_wait,
		gs_writes_finished(port),
		GS_CLOSE_TIMEOUT * HZ);
		spin_lock_irq(&port->port_lock);
		gser = port->port_usb;
		}

		/* Iff we're disconnected, there can be no I/O in flight so it's
		* ok to free the circular buffer; else just scrub it. And don't
		* let the push tasklet fire again until we're re-opened.
		*/
		if (port->port_usb == NULL)
		if (gser == NULL)
		gs_buf_free(&port->port_write_buf);
		else
		gs_buf_clear(&port->port_write_buf);
		@@ -974,6 +980,24 @@ static void gs_unthrottle(struct tty_struct *tty)
		spin_unlock_irqrestore(&port->port_lock, flags);
		}

		static int gs_break_ctl(struct tty_struct *tty, int duration)
		{
		struct gs_port *port = tty->driver_data;
		int status = 0;
		struct gserial *gser;

		pr_vdebug("gs_break_ctl: ttyGS%d, send break (%d) \n",
		port->port_num, duration);

		spin_lock_irq(&port->port_lock);
		gser = port->port_usb;
		if (gser && gser->send_break)
		status = gser->send_break(gser, duration);
		spin_unlock_irq(&port->port_lock);

		return status;
		}

		static const struct tty_operations gs_tty_ops = {
		.open = gs_open,
		.close = gs_close,
		@@ -983,6 +1007,7 @@ static const struct tty_operations gs_tty_ops = {
		.write_room = gs_write_room,
		.chars_in_buffer = gs_chars_in_buffer,
		.unthrottle = gs_unthrottle,
		.break_ctl = gs_break_ctl,
		};

		/-------------------------------------------------------------------------/
		@@ -1230,14 +1255,17 @@ int gserial_connect(struct gserial *gser, u8 port_num)

		/* REVISIT if waiting on "carrier detect", signal. */

		/* REVISIT for ACM, issue "network connection" status notification:
		* connected if open_count, else disconnected.
		/* if it's already open, start I/O ... and notify the serial
		* protocol about open/close status (connect/disconnect).
		*/

		/* if it's already open, start I/O */
		if (port->open_count) {
		pr_debug("gserial_connect: start ttyGS%d\n", port->port_num);
		gs_start_io(port);
		if (gser->connect)
		gser->connect(gser);
		} else {
		if (gser->disconnect)
		gser->disconnect(gser);
		}

		spin_unlock_irqrestore(&port->port_lock, flags);

drivers/usb/gadget/u_serial.h

+10 −2

Original line number	Diff line number	Diff line
		@@ -23,8 +23,7 @@
		* style I/O using the USB peripheral endpoints listed here, including
		* hookups to sysfs and /dev for each logical "tty" device.
		*
		* REVISIT need TTY --> USB event flow too, so ACM can report open/close
		* as carrier detect events. Model after ECM. There's more ACM state too.
		* REVISIT at least ACM could support tiocmget() if needed.
		*
		* REVISIT someday, allow multiplexing several TTYs over these endpoints.
		*/
		@@ -41,8 +40,17 @@ struct gserial {

		/* REVISIT avoid this CDC-ACM support harder ... */
		struct usb_cdc_line_coding port_line_coding; /* 9600-8-N-1 etc */

		/* notification callbacks */
		void (connect)(struct gserial p);
		void (disconnect)(struct gserial p);
		int (send_break)(struct gserial p, int duration);
		};

		/* utilities to allocate/free request and buffer */
		struct usb_request gs_alloc_req(struct usb_ep ep, unsigned len, gfp_t flags);
		void gs_free_req(struct usb_ep , struct usb_request req);

		/* port setup/teardown is handled by gadget driver */
		int gserial_setup(struct usb_gadget *g, unsigned n_ports);
		void gserial_cleanup(void);

Admin message