[PATCH v2 1/2] lib/circbuf: Make circbuf selectable symbol

[PATCH v2 1/2] lib/circbuf: Make circbuf selectable symbol

[Loic Poulain]

It is currenly only used from usbtty driver but make it properly
selectable via Kconfig symbol, for future usage.

Signed-off-by: Loic Poulain <loic.poulain@linaro.org>
---
 v2: no change

 lib/Kconfig  | 3 +++
 lib/Makefile | 8 +++++++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/lib/Kconfig b/lib/Kconfig
index c535147..1bd54d8 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -290,6 +290,9 @@ config TRACE_EARLY_ADDR
 	  the size is too small then the message which says the amount of early
 	  data being coped will the the same as the
 
+config CIRCBUF
+        bool
+
 source lib/dhry/Kconfig
 
 menu "Security support"
diff --git a/lib/Makefile b/lib/Makefile
index 8ba745f..4daeee2 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -29,7 +29,13 @@ ifneq ($(CONFIG_CHARSET),)
 obj-y += charset.o
 endif
 endif
-obj-$(CONFIG_USB_TTY) += circbuf.o
+
+ifdef CONFIG_USB_TTY
+obj-y += circbuf.o
+else
+obj-$(CONFIG_CIRCBUF) += circbuf.o
+endif
+
 obj-y += crc8.o
 obj-y += crc16.o
 obj-$(CONFIG_ERRNO_STR) += errno_str.o
-- 
2.7.4

[PATCH v2 2/2] usb: gadget: Add CDC ACM function

[Loic Poulain]

Add support for CDC ACM using the new UDC and gadget API. This protocol
can be used for serial over USB data transfer and is widely supported
by various OS (GNU/Linux, MS-Windows, OSX...). The usual purpose of
such link is to access device debug console and can be useful for
products not exposing regular UART to the user.

A default stdio device named 'stdio_acm' is created, and can be used
to redirect console to USB link over CDC ACM:

> setenv stdin stdio_acm; setenv stdout stdio_acm

Signed-off-by: Loic Poulain <loic.poulain@linaro.org>
---
 v2: - remove possible infinite recursipe print loop
     - Remove acmconsole command, start function along the stdio device

 common/stdio.c              |   3 +
 drivers/usb/gadget/Kconfig  |   9 +
 drivers/usb/gadget/Makefile |   1 +
 drivers/usb/gadget/f_acm.c  | 672 ++++++++++++++++++++++++++++++++++++++++++++
 include/stdio_dev.h         |   1 +
 5 files changed, 686 insertions(+)
 create mode 100644 drivers/usb/gadget/f_acm.c

diff --git a/common/stdio.c b/common/stdio.c
index 4083e4e..2862823 100644
--- a/common/stdio.c
+++ b/common/stdio.c
@@ -381,6 +381,9 @@ int stdio_add_devices(void)
 #ifdef CONFIG_USB_TTY
 	drv_usbtty_init();
 #endif
+#ifdef CONFIG_USB_FUNCTION_ACM
+	drv_usb_acm_stdio_init ();
+#endif
 	if (IS_ENABLED(CONFIG_NETCONSOLE))
 		drv_nc_init();
 #ifdef CONFIG_JTAG_CONSOLE
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 327ea86..d81a9c5 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -182,6 +182,15 @@ config USB_FUNCTION_THOR
 	  Enable Tizen's THOR download protocol support in U-Boot. It
 	  allows downloading images into memory and flash them to target device.
 
+config USB_FUNCTION_ACM
+	bool "Enable CDC ACM gadget"
+	select SYS_STDIO_DEREGISTER
+	select CIRCBUF
+	help
+	  ACM serial link. This function can be used to create a stdio device to
+	  interoperate with MS-Windows hosts or with the Linux-USB "cdc-acm"
+	  driver.
+
 endif # USB_GADGET_DOWNLOAD
 
 config USB_ETHER
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index f560068..d5d891b 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -30,6 +30,7 @@ obj-$(CONFIG_USB_FUNCTION_MASS_STORAGE) += f_mass_storage.o
 obj-$(CONFIG_USB_FUNCTION_FASTBOOT) += f_fastboot.o
 obj-$(CONFIG_USB_FUNCTION_SDP) += f_sdp.o
 obj-$(CONFIG_USB_FUNCTION_ROCKUSB) += f_rockusb.o
+obj-$(CONFIG_USB_FUNCTION_ACM)	+= f_acm.o
 endif
 endif
 ifdef CONFIG_USB_ETHER
diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c
new file mode 100644
index 0000000..3ea3b4a
--- /dev/null
+++ b/drivers/usb/gadget/f_acm.c
@@ -0,0 +1,672 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * 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
+ * Copyright (c) 2021, Linaro Ltd <loic.poulain@linaro.org>
+ */
+
+#include <circbuf.h>
+#include <common.h>
+#include <console.h>
+#include <errno.h>
+#include <g_dnl.h>
+#include <malloc.h>
+#include <memalign.h>
+#include <stdio_dev.h>
+#include <version.h>
+#include <watchdog.h>
+
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb/composite.h>
+#include <linux/usb/cdc.h>
+
+#define REQ_SIZE_MAX	512
+
+struct f_acm {
+	int ctrl_id;
+	int data_id;
+
+	struct usb_ep *ep_in;
+	struct usb_ep *ep_out;
+	struct usb_ep *ep_notify;
+
+	struct usb_request *req_in;
+	struct usb_request *req_out;
+
+	bool connected;
+	bool tx_on;
+
+	circbuf_t rx_buf;
+	circbuf_t tx_buf;
+
+	struct usb_function usb_function;
+
+	struct usb_cdc_line_coding line_coding;
+	u16 handshake_bits;
+#define ACM_CTRL_RTS	BIT(1)	/* unused with full duplex */
+#define ACM_CTRL_DTR	BIT(0)	/* host is ready for data r/w */
+
+	int controller_index;
+};
+
+static struct f_acm *default_acm_function;
+
+static inline struct f_acm *func_to_acm(struct usb_function *f)
+{
+	return container_of(f, struct f_acm, usb_function);
+}
+
+static inline struct f_acm *stdio_to_acm(struct stdio_dev *s)
+{
+	/* stdio dev is cloned on registration, do not use container_of */
+	return s->priv;
+}
+
+static struct usb_interface_assoc_descriptor
+acm_iad_descriptor = {
+	.bLength =              sizeof(acm_iad_descriptor),
+	.bDescriptorType =      USB_DT_INTERFACE_ASSOCIATION,
+	.bFirstInterface =      0,
+	.bInterfaceCount =      2,	// control + data
+	.bFunctionClass =       USB_CLASS_COMM,
+	.bFunctionSubClass =    USB_CDC_SUBCLASS_ACM,
+	.bFunctionProtocol =    USB_CDC_ACM_PROTO_AT_V25TER,
+};
+
+static struct usb_interface_descriptor acm_control_intf_desc = {
+	.bLength =              USB_DT_INTERFACE_SIZE,
+	.bDescriptorType =      USB_DT_INTERFACE,
+	.bNumEndpoints =        1,
+	.bInterfaceClass =      USB_CLASS_COMM,
+	.bInterfaceSubClass =   USB_CDC_SUBCLASS_ACM,
+	.bInterfaceProtocol =   USB_CDC_ACM_PROTO_AT_V25TER,
+};
+
+static struct usb_interface_descriptor acm_data_intf_desc = {
+	.bLength =              sizeof(acm_data_intf_desc),
+	.bDescriptorType =      USB_DT_INTERFACE,
+	.bNumEndpoints =        2,
+	.bInterfaceClass =      USB_CLASS_CDC_DATA,
+};
+
+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_desc = {
+	.bLength =              sizeof(acm_call_mgmt_desc),
+	.bDescriptorType =      USB_DT_CS_INTERFACE,
+	.bDescriptorSubType =   USB_CDC_CALL_MANAGEMENT_TYPE,
+	.bmCapabilities =       0,
+	.bDataInterface =       0x01,
+};
+
+static struct usb_cdc_acm_descriptor acm_desc = {
+	.bLength =		sizeof(acm_desc),
+	.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 =	0x00,
+	.bSlaveInterface0 =	0x01,
+};
+
+static struct usb_endpoint_descriptor acm_fs_notify_desc = {
+	.bLength =              USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =      USB_DT_ENDPOINT,
+	.bEndpointAddress =     3 | USB_DIR_IN,
+	.bmAttributes =         USB_ENDPOINT_XFER_INT,
+	.wMaxPacketSize =       cpu_to_le16(64),
+	.bInterval =            32,
+};
+
+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_intf_desc,
+	(struct usb_descriptor_header *)&acm_header_desc,
+	(struct usb_descriptor_header *)&acm_call_mgmt_desc,
+	(struct usb_descriptor_header *)&acm_desc,
+	(struct usb_descriptor_header *)&acm_union_desc,
+	(struct usb_descriptor_header *)&acm_fs_notify_desc,
+	(struct usb_descriptor_header *)&acm_data_intf_desc,
+	(struct usb_descriptor_header *)&acm_fs_in_desc,
+	(struct usb_descriptor_header *)&acm_fs_out_desc,
+	NULL,
+};
+
+static struct usb_endpoint_descriptor acm_hs_notify_desc = {
+	.bLength =              USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =      USB_DT_ENDPOINT,
+	.bmAttributes =         USB_ENDPOINT_XFER_INT,
+	.wMaxPacketSize =       cpu_to_le16(64),
+	.bInterval =            11,
+};
+
+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_intf_desc,
+	(struct usb_descriptor_header *)&acm_header_desc,
+	(struct usb_descriptor_header *)&acm_call_mgmt_desc,
+	(struct usb_descriptor_header *)&acm_desc,
+	(struct usb_descriptor_header *)&acm_union_desc,
+	(struct usb_descriptor_header *)&acm_hs_notify_desc,
+	(struct usb_descriptor_header *)&acm_data_intf_desc,
+	(struct usb_descriptor_header *)&acm_hs_in_desc,
+	(struct usb_descriptor_header *)&acm_hs_out_desc,
+	NULL,
+};
+
+static inline struct usb_endpoint_descriptor *
+ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
+	struct usb_endpoint_descriptor *fs)
+{
+	if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+		return hs;
+	return fs;
+}
+
+static int acm_bind(struct usb_configuration *c, struct usb_function *f)
+{
+	struct usb_gadget *gadget = c->cdev->gadget;
+	struct f_acm *f_acm = func_to_acm(f);
+	struct usb_ep *ep;
+	int id;
+
+	id = usb_interface_id(c, f);
+	if (id < 0)
+		return id;
+
+	acm_iad_descriptor.bFirstInterface = id;
+	acm_control_intf_desc.bInterfaceNumber = id;
+	acm_union_desc.bMasterInterface0 = id;
+
+	f_acm->ctrl_id = id;
+
+	id = usb_interface_id(c, f);
+	if (id < 0)
+		return id;
+
+	acm_data_intf_desc.bInterfaceNumber = id;
+	acm_union_desc.bSlaveInterface0 = id;
+	acm_call_mgmt_desc.bDataInterface = id;
+
+	f_acm->data_id = id;
+
+	/* allocate instance-specific endpoints */
+	ep = usb_ep_autoconfig(gadget, &acm_fs_in_desc);
+	if (!ep)
+		return -ENODEV;
+
+	f_acm->ep_in = ep;
+
+	ep = usb_ep_autoconfig(gadget, &acm_fs_out_desc);
+	if (!ep)
+		return -ENODEV;
+
+	f_acm->ep_out = ep;
+
+	ep = usb_ep_autoconfig(gadget, &acm_fs_notify_desc);
+	if (!ep)
+		return -ENODEV;
+
+	f_acm->ep_notify = ep;
+
+	if (gadget_is_dualspeed(gadget)) {
+		/* Assume endpoint addresses are the same for 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;
+	}
+
+	return 0;
+}
+
+static void acm_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+	struct f_acm *f_acm = func_to_acm(f);
+
+	if (default_acm_function == f_acm)
+		default_acm_function = NULL;
+
+	buf_free(&f_acm->rx_buf);
+	buf_free(&f_acm->tx_buf);
+
+	free(f_acm);
+}
+
+static void acm_notify_complete(struct usb_ep *ep, struct usb_request *req)
+{
+	/* nothing to do */
+}
+
+static void acm_tx_complete(struct usb_ep *ep, struct usb_request *req)
+{
+	struct f_acm *f_acm = req->context;
+
+	f_acm->tx_on = true;
+}
+
+static void acm_rx_complete(struct usb_ep *ep, struct usb_request *req)
+{
+	struct f_acm *f_acm = req->context;
+
+	buf_push(&f_acm->rx_buf, req->buf, req->actual);
+
+	/* Queue RX req again */
+	req->actual = 0;
+	usb_ep_queue(ep, req, 0);
+}
+
+static struct usb_request *acm_start_ep(struct usb_ep *ep, void *complete_cb,
+					void *context)
+{
+	struct usb_request *req;
+
+	req = usb_ep_alloc_request(ep, 0);
+	if (!req)
+		return NULL;
+
+	req->length = REQ_SIZE_MAX;
+	req->buf = memalign(CONFIG_SYS_CACHELINE_SIZE, REQ_SIZE_MAX);
+	if (!req->buf) {
+		usb_ep_free_request(ep, req);
+		return NULL;
+	}
+
+	memset(req->buf, 0, req->length);
+	req->complete = complete_cb;
+	req->context = context;
+
+	return req;
+}
+
+static int acm_start_data(struct f_acm *f_acm, struct usb_gadget *gadget)
+{
+	const struct usb_endpoint_descriptor *d;
+	int ret;
+
+	/* EP IN */
+	d = ep_desc(gadget, &acm_hs_in_desc, &acm_fs_in_desc);
+	ret = usb_ep_enable(f_acm->ep_in, d);
+	if (ret)
+		return ret;
+
+	f_acm->req_in = acm_start_ep(f_acm->ep_in, acm_tx_complete, f_acm);
+
+	/* EP OUT */
+	d = ep_desc(gadget, &acm_hs_out_desc, &acm_fs_out_desc);
+	ret = usb_ep_enable(f_acm->ep_out, d);
+	if (ret)
+		return ret;
+
+	f_acm->req_out = acm_start_ep(f_acm->ep_out, acm_rx_complete, f_acm);
+
+	/* Start OUT transfer (EP OUT) */
+	ret = usb_ep_queue(f_acm->ep_out, f_acm->req_out, 0);
+	if (ret)
+		return ret;
+
+	return 0;
+}
+
+static int acm_start_ctrl(struct f_acm *f_acm, struct usb_gadget *gadget)
+{
+	const struct usb_endpoint_descriptor *d;
+
+	usb_ep_disable(f_acm->ep_notify);
+
+	d = ep_desc(gadget, &acm_hs_notify_desc, &acm_fs_notify_desc);
+	usb_ep_enable(f_acm->ep_notify, d);
+
+	acm_start_ep(f_acm->ep_notify, acm_notify_complete, f_acm);
+
+	return 0;
+}
+
+static int acm_set_alt(struct usb_function *f, unsigned int intf, unsigned int alt)
+{
+	struct usb_gadget *gadget = f->config->cdev->gadget;
+	struct f_acm *f_acm = func_to_acm(f);
+
+	if (intf == f_acm->ctrl_id) {
+		return acm_start_ctrl(f_acm, gadget);
+	} else if (intf == f_acm->data_id) {
+		acm_start_data(f_acm, gadget);
+		f_acm->connected = true;
+		f_acm->tx_on = true;
+		return 0;
+	}
+
+	return -EINVAL;
+}
+
+static int acm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
+{
+	struct usb_gadget *gadget =  f->config->cdev->gadget;
+	struct usb_request *req = f->config->cdev->req;
+	u16 w_index = le16_to_cpu(ctrl->wIndex);
+	u16 w_value = le16_to_cpu(ctrl->wValue);
+	u16 w_length = le16_to_cpu(ctrl->wLength);
+	struct f_acm *f_acm = func_to_acm(f);
+	int value = -1;
+
+	switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
+	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+			| USB_CDC_REQ_SET_LINE_CODING:
+		/* SET_LINE_CODING */
+
+		if (w_length != sizeof(f_acm->line_coding) || w_index != f_acm->ctrl_id)
+			goto invalid;
+
+		value = w_length;
+
+		memcpy(&f_acm->line_coding, req->buf, value);
+
+		break;
+	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+			| USB_CDC_REQ_GET_LINE_CODING:
+		/* GET_LINE_CODING */
+
+		if (w_length != sizeof(f_acm->line_coding) || w_index != f_acm->ctrl_id)
+			goto invalid;
+
+		value = w_length;
+
+		memcpy(req->buf, &f_acm->line_coding, value);
+
+		break;
+	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+			| USB_CDC_REQ_SET_CONTROL_LINE_STATE:
+		/* SET_CONTROL_LINE_STATE */
+
+		if (w_index != f_acm->ctrl_id)
+			goto invalid;
+
+		value = 0;
+
+		f_acm->handshake_bits = w_value;
+
+		break;
+	default:
+invalid:
+		printf("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) {
+		req->zero = 0;
+		req->length = value;
+		usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
+	}
+
+	return 0;
+}
+
+static void acm_disable(struct usb_function *f)
+{
+	struct f_acm *f_acm = func_to_acm(f);
+
+	usb_ep_disable(f_acm->ep_out);
+	usb_ep_disable(f_acm->ep_in);
+	usb_ep_disable(f_acm->ep_notify);
+
+	if (f_acm->req_out) {
+		free(f_acm->req_out->buf);
+		usb_ep_free_request(f_acm->ep_out, f_acm->req_out);
+		f_acm->req_out = NULL;
+	}
+
+	if (f_acm->req_in) {
+		free(f_acm->req_in->buf);
+		usb_ep_free_request(f_acm->ep_in, f_acm->req_in);
+		f_acm->req_in = NULL;
+	}
+}
+
+/* static strings, in UTF-8 */
+static struct usb_string acm_string_defs[] = {
+	[0].s = "CDC Abstract Control Model (ACM)",
+	[1].s = "CDC ACM Data",
+	[2].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,
+};
+
+static void __acm_tx(struct f_acm *f_acm)
+{
+	int len, ret;
+
+	do {
+		usb_gadget_handle_interrupts(f_acm->controller_index);
+
+		if (!(f_acm->handshake_bits & ACM_CTRL_DTR))
+			break;
+
+		if (!f_acm->tx_on)
+			continue;
+
+		len = buf_pop(&f_acm->tx_buf, f_acm->req_in->buf, REQ_SIZE_MAX);
+		if (!len)
+			break;
+
+		f_acm->req_in->length = len;
+
+		ret = usb_ep_queue(f_acm->ep_in, f_acm->req_in, 0);
+		if (ret)
+			break;
+
+		f_acm->tx_on = false;
+
+		/* Do not reset the watchdog, if TX is stuck there is probably
+		 * a real issue.
+		 */
+	} while (1);
+}
+
+static bool acm_connected(struct stdio_dev *dev)
+{
+	struct f_acm *f_acm = stdio_to_acm(dev);
+
+	/* give a chance to process udc irq */
+	usb_gadget_handle_interrupts(f_acm->controller_index);
+
+	return f_acm->connected;
+}
+
+static int acm_add(struct usb_configuration *c)
+{
+	struct f_acm *f_acm;
+	int status;
+
+	f_acm = calloc(1, sizeof(*f_acm));
+	if (!f_acm)
+		return -ENOMEM;
+
+	f_acm->usb_function.name = "f_acm";
+	f_acm->usb_function.bind = acm_bind;
+	f_acm->usb_function.unbind = acm_unbind;
+	f_acm->usb_function.set_alt = acm_set_alt;
+	f_acm->usb_function.disable = acm_disable;
+	f_acm->usb_function.strings = acm_strings;
+	f_acm->usb_function.descriptors = acm_fs_function;
+	f_acm->usb_function.hs_descriptors = acm_hs_function;
+	f_acm->usb_function.setup = acm_setup;
+	f_acm->controller_index = 0;
+
+	status = usb_add_function(c, &f_acm->usb_function);
+	if (status) {
+		free(f_acm);
+		return status;
+	}
+
+	buf_init(&f_acm->rx_buf, 2048);
+	buf_init(&f_acm->tx_buf, 2048);
+
+	if (!default_acm_function)
+		default_acm_function = f_acm;
+
+	return status;
+}
+
+DECLARE_GADGET_BIND_CALLBACK(usb_serial_acm, acm_add);
+
+/* STDIO */
+static int acm_stdio_tstc(struct stdio_dev *dev)
+{
+	struct f_acm *f_acm = stdio_to_acm(dev);
+
+	usb_gadget_handle_interrupts(f_acm->controller_index);
+
+	return (f_acm->rx_buf.size > 0);
+}
+
+static int acm_stdio_getc(struct stdio_dev *dev)
+{
+	struct f_acm *f_acm = stdio_to_acm(dev);
+	char c;
+
+	/* Wait for a character to arrive. */
+	while (!acm_stdio_tstc(dev))
+		WATCHDOG_RESET();
+
+	buf_pop(&f_acm->rx_buf, &c, 1);
+
+	return c;
+}
+
+static void acm_stdio_putc(struct stdio_dev *dev, const char c)
+{
+	struct f_acm *f_acm = stdio_to_acm(dev);
+
+	if (c == '\n')
+		buf_push(&f_acm->tx_buf, "\r", 1);
+
+	buf_push(&f_acm->tx_buf, &c, 1);
+
+	if (!f_acm->connected)
+		return;
+
+	__acm_tx(f_acm);
+}
+
+static void acm_stdio_puts(struct stdio_dev *dev, const char *str)
+{
+	struct f_acm *f_acm = stdio_to_acm(dev);
+
+	while (*str) {
+		if (*str == '\n')
+			buf_push(&f_acm->tx_buf, "\r", 1);
+
+		buf_push(&f_acm->tx_buf, str++, 1);
+	}
+
+	if (!f_acm->connected)
+		return;
+
+	__acm_tx(f_acm);
+}
+
+static int acm_stdio_start(struct stdio_dev *dev)
+{
+	int ret;
+
+	if (dev->priv) { /* function already exist */
+		return 0;
+	}
+
+	ret = g_dnl_register("usb_serial_acm");
+	if (ret)
+		return ret;
+
+	if (default_acm_function)
+		dev->priv = default_acm_function;
+	else
+		return -ENODEV;
+
+	while (!acm_connected(dev)) {
+		if (ctrlc())
+			return -ECANCELED;
+
+		WATCHDOG_RESET();
+	}
+
+	return 0;
+}
+
+static int acm_stdio_stop(struct stdio_dev *dev)
+{
+	g_dnl_unregister();
+	g_dnl_clear_detach();
+
+	return 0;
+}
+
+int drv_usb_acm_stdio_init(void)
+{
+	struct stdio_dev stdio;
+
+	strcpy(stdio.name, "stdio_acm");
+	stdio.flags = DEV_FLAGS_INPUT | DEV_FLAGS_OUTPUT;
+	stdio.tstc = acm_stdio_tstc;
+	stdio.getc = acm_stdio_getc;
+	stdio.putc = acm_stdio_putc;
+	stdio.puts = acm_stdio_puts;
+	stdio.start = acm_stdio_start;
+	stdio.stop = acm_stdio_stop;
+	stdio.priv = NULL;
+	stdio.ext = 0;
+
+	return stdio_register(&stdio);
+}
diff --git a/include/stdio_dev.h b/include/stdio_dev.h
index 8fb9a12..d584793 100644
--- a/include/stdio_dev.h
+++ b/include/stdio_dev.h
@@ -103,6 +103,7 @@ int drv_lcd_init(void);
 int drv_video_init(void);
 int drv_keyboard_init(void);
 int drv_usbtty_init(void);
+int drv_usb_acm_stdio_init(void);
 int drv_nc_init(void);
 int drv_jtag_console_init(void);
 int cbmemc_init(void);
-- 
2.7.4

Re: [PATCH v2 1/2] lib/circbuf: Make circbuf selectable symbol

[Wolfgang Denk]

Dear Loic Poulain,

In message <1637584252-15617-1-git-send-email-loic.poulain@linaro.org> you wrote:
> It is currenly only used from usbtty driver but make it properly
> selectable via Kconfig symbol, for future usage.
>
> Signed-off-by: Loic Poulain <loic.poulain@linaro.org>
> ---
>  v2: no change
>
>  lib/Kconfig  | 3 +++
>  lib/Makefile | 8 +++++++-
>  2 files changed, 10 insertions(+), 1 deletion(-)
>
> diff --git a/lib/Kconfig b/lib/Kconfig
> index c535147..1bd54d8 100644
> --- a/lib/Kconfig
> +++ b/lib/Kconfig
> @@ -290,6 +290,9 @@ config TRACE_EARLY_ADDR
>  	  the size is too small then the message which says the amount of early
>  	  data being coped will the the same as the
>  
> +config CIRCBUF
> +        bool
> +
>  source lib/dhry/Kconfig

Please add a description what this symbos is doing.

Thanks.


Wolfgang Denk

-- 
DENX Software Engineering GmbH,      Managing Director: Wolfgang Denk
HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany
Phone: (+49)-8142-66989-10 Fax: (+49)-8142-66989-80 Email: wd@denx.de
Old programmers never die, they just become managers.

Re: [PATCH v2 2/2] usb: gadget: Add CDC ACM function

[Pali Rohár]

Hello! I have just few notes, see below.

> diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
> index f560068..d5d891b 100644
> --- a/drivers/usb/gadget/Makefile
> +++ b/drivers/usb/gadget/Makefile
> @@ -30,6 +30,7 @@ obj-$(CONFIG_USB_FUNCTION_MASS_STORAGE) += f_mass_storage.o
>  obj-$(CONFIG_USB_FUNCTION_FASTBOOT) += f_fastboot.o
>  obj-$(CONFIG_USB_FUNCTION_SDP) += f_sdp.o
>  obj-$(CONFIG_USB_FUNCTION_ROCKUSB) += f_rockusb.o
> +obj-$(CONFIG_USB_FUNCTION_ACM)	+= f_acm.o
>  endif
>  endif
>  ifdef CONFIG_USB_ETHER
> diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c
> new file mode 100644
> index 0000000..3ea3b4a
> --- /dev/null
> +++ b/drivers/usb/gadget/f_acm.c
...
> +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),

This is global structure initialization. So should not it use
__constant_cpu_to_le16() macro instead of cpu_to_le16()? I guess that on
armel or x86 is cpu_to_le16() just identity macro, but on big endian
systems it is needed to use constant initialization. Other gadget
drivers are using those __constant_cpu* macros.

> +};
...
> +int drv_usb_acm_stdio_init(void)
> +{
> +	struct stdio_dev stdio;
> +
> +	strcpy(stdio.name, "stdio_acm");

Just suggestion: What about "usbacm" or just "acm"?

> +	stdio.flags = DEV_FLAGS_INPUT | DEV_FLAGS_OUTPUT;
> +	stdio.tstc = acm_stdio_tstc;
> +	stdio.getc = acm_stdio_getc;
> +	stdio.putc = acm_stdio_putc;
> +	stdio.puts = acm_stdio_puts;
> +	stdio.start = acm_stdio_start;
> +	stdio.stop = acm_stdio_stop;
> +	stdio.priv = NULL;
> +	stdio.ext = 0;
> +
> +	return stdio_register(&stdio);
> +}
> diff --git a/include/stdio_dev.h b/include/stdio_dev.h
> index 8fb9a12..d584793 100644
> --- a/include/stdio_dev.h
> +++ b/include/stdio_dev.h
> @@ -103,6 +103,7 @@ int drv_lcd_init(void);
>  int drv_video_init(void);
>  int drv_keyboard_init(void);
>  int drv_usbtty_init(void);
> +int drv_usb_acm_stdio_init(void);

Other functions do not have stdio in name too. So what about shorting
it? E.g. just drv_usbacm_init()?

>  int drv_nc_init(void);
>  int drv_jtag_console_init(void);
>  int cbmemc_init(void);
> -- 
> 2.7.4
> 

Re: [PATCH v2 2/2] usb: gadget: Add CDC ACM function

[Loic Poulain]

Hi Pali,

On Mon, 22 Nov 2021 at 16:48, Pali Rohár <pali@kernel.org> wrote:
>
> Hello! I have just few notes, see below.
>
> > diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
> > index f560068..d5d891b 100644
> > --- a/drivers/usb/gadget/Makefile
> > +++ b/drivers/usb/gadget/Makefile
> > @@ -30,6 +30,7 @@ obj-$(CONFIG_USB_FUNCTION_MASS_STORAGE) += f_mass_storage.o
> >  obj-$(CONFIG_USB_FUNCTION_FASTBOOT) += f_fastboot.o
> >  obj-$(CONFIG_USB_FUNCTION_SDP) += f_sdp.o
> >  obj-$(CONFIG_USB_FUNCTION_ROCKUSB) += f_rockusb.o
> > +obj-$(CONFIG_USB_FUNCTION_ACM)       += f_acm.o
> >  endif
> >  endif
> >  ifdef CONFIG_USB_ETHER
> > diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c
> > new file mode 100644
> > index 0000000..3ea3b4a
> > --- /dev/null
> > +++ b/drivers/usb/gadget/f_acm.c
> ...
> > +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),
>
> This is global structure initialization. So should not it use
> __constant_cpu_to_le16() macro instead of cpu_to_le16()? I guess that on
> armel or x86 is cpu_to_le16() just identity macro, but on big endian
> systems it is needed to use constant initialization. Other gadget
> drivers are using those __constant_cpu* macros.

Indeed, going to use it.

>
> > +};
> ...
> > +int drv_usb_acm_stdio_init(void)
> > +{
> > +     struct stdio_dev stdio;
> > +
> > +     strcpy(stdio.name, "stdio_acm");
>
> Just suggestion: What about "usbacm" or just "acm"?

usbacm sounds good.

>
> > +     stdio.flags = DEV_FLAGS_INPUT | DEV_FLAGS_OUTPUT;
> > +     stdio.tstc = acm_stdio_tstc;
> > +     stdio.getc = acm_stdio_getc;
> > +     stdio.putc = acm_stdio_putc;
> > +     stdio.puts = acm_stdio_puts;
> > +     stdio.start = acm_stdio_start;
> > +     stdio.stop = acm_stdio_stop;
> > +     stdio.priv = NULL;
> > +     stdio.ext = 0;
> > +
> > +     return stdio_register(&stdio);
> > +}
> > diff --git a/include/stdio_dev.h b/include/stdio_dev.h
> > index 8fb9a12..d584793 100644
> > --- a/include/stdio_dev.h
> > +++ b/include/stdio_dev.h
> > @@ -103,6 +103,7 @@ int drv_lcd_init(void);
> >  int drv_video_init(void);
> >  int drv_keyboard_init(void);
> >  int drv_usbtty_init(void);
> > +int drv_usb_acm_stdio_init(void);
>
> Other functions do not have stdio in name too. So what about shorting
> it? E.g. just drv_usbacm_init()?

Yes, I've named it _stdio because it's a subpart of the driver. There
is the core cdc_acm function implementation and one client of this
function which is stdio. But I'm fine with shortening that.

Regards,
Loic

Re: [PATCH v2 1/2] lib/circbuf: Make circbuf selectable symbol

[Loic Poulain]

Hi Wolfgang,

On Mon, 22 Nov 2021 at 13:50, Wolfgang Denk <wd@denx.de> wrote:
>
> Dear Loic Poulain,
>
> In message <1637584252-15617-1-git-send-email-loic.poulain@linaro.org> you wrote:
> > It is currenly only used from usbtty driver but make it properly
> > selectable via Kconfig symbol, for future usage.
> >
> > Signed-off-by: Loic Poulain <loic.poulain@linaro.org>
> > ---
> >  v2: no change
> >
> >  lib/Kconfig  | 3 +++
> >  lib/Makefile | 8 +++++++-
> >  2 files changed, 10 insertions(+), 1 deletion(-)
> >
> > diff --git a/lib/Kconfig b/lib/Kconfig
> > index c535147..1bd54d8 100644
> > --- a/lib/Kconfig
> > +++ b/lib/Kconfig
> > @@ -290,6 +290,9 @@ config TRACE_EARLY_ADDR
> >         the size is too small then the message which says the amount of early
> >         data being coped will the the same as the
> >
> > +config CIRCBUF
> > +        bool
> > +
> >  source lib/dhry/Kconfig
>
> Please add a description what this symbos is doing.

It's not a user selectable symbol, adding description will break that, right?

Regards,
Loic