[PATCH v3 0/6] USB: serial: mxuport: add MUX50U support and updates

[PATCH v3 0/6] USB: serial: mxuport: add MUX50U support and updates

[Crescent Hsieh]

This series updates the mxuport driver to support MUX50U-based devices
and fixes device-specific runtime behaviours.

The first three patches clean up the USB device ID table and firmware
version handling, and add support for UPort G2 and Platform UART
devices. The device family is encoded in the USB device ID table so
that the table provides both the port count and the information needed
for firmware handling.

The fourth patch adds optional callbacks to the generic USB-serial
write path so that drivers can stop write submission based on
device-specific state and restore that state if URB submission fails.

The fifth patch uses these callbacks to implement the per-port
SEND_NEXT transmit flow-control protocol without duplicating the
generic write implementation.

The sixth patch adds RS485 mode configuration through the standard
TIOCSRS485/TIOCGRS485 interface.

---
Changes in v3:
  - [PATCH v3 1/6]:
    Rename the existing PID definitions after their corresponding
    products and introduce a helper to keep each USB device ID table
    entry on one line.
  - [PATCH v3 2/6]:
    Rename the firmware-version composition helper and retain the
    existing firmware image-size validation.
  - [PATCH v3 3/6]:
    Name the new PID definitions after their corresponding products,
    list all supported products by device family, rename the family
    definitions to describe device rather than firmware families, and
    use BIT() for the nonzero family values.
  - [PATCH v3 4/6] and [PATCH v3 5/6]:
    Replace the mxuport-specific copies of the generic write path with
    optional write_ready() and write_rollback() callbacks. Use the
    callbacks to pause SEND_NEXT writes and restore the per-port state
    if URB submission fails. Expand the SEND_NEXT commit message to
    describe the per-port protocol.

Changes in v2:
  - [PATCH v1 1/4]:
    Split into [PATCH v2 1/4] and [PATCH v2 2/4]. Clean up firmware
    version parsing and printing in the first patch, and move MUX50U
    device support to the second patch. Encode the firmware family in
    the USB device-id table and use the system-register remap state for
    the MUX50U firmware download decision.
  - [PATCH v1 2/4]:
    Moved to [PATCH v2 3/4]. Add mxuport-specific write(),
    write_start(), and write_bulk_callback() paths so SEND_NEXT can stop
    and resume transmission without returning zero from
    prepare_write_buffer().
    Drop the open-time FIFO flush.
  - [PATCH v1 3/4]:
    Moved to [PATCH v2 4/4]. Clear unsupported serial_rs485 flags and
    fields, cache the sanitized configuration, and protect it with the
    per-port mutex.
  - [PATCH v1 4/4]:
    Drop the UART FIFO sysfs interface from this revision.

v2: https://lore.kernel.org/all/20260623080138.166398-2-crescentcy.hsieh@moxa.com/
v1: https://lore.kernel.org/all/20260324035041.352190-1-crescentcy.hsieh@moxa.com/

Crescent Hsieh (6):
  USB: serial: mxuport: clean up product ID definitions and device table
  USB: serial: mxuport: clean up firmware version handling
  USB: serial: mxuport: add MUX50U-based device support
  USB: serial: add generic write control callbacks
  USB: serial: mxuport: handle SEND_NEXT transmit flow control
  USB: serial: mxuport: support RS485 mode configuration

 drivers/usb/serial/generic.c |  12 +-
 drivers/usb/serial/mxuport.c | 424 ++++++++++++++++++++++++++++++-----
 include/linux/usb/serial.h   |   9 +-
 3 files changed, 378 insertions(+), 67 deletions(-)

-- 
2.53.0

[PATCH v3 1/6] USB: serial: mxuport: clean up product ID definitions and device table

[Crescent Hsieh]

Rename the product ID definitions after the corresponding product names
to make the product mapping explicit. Introduce a helper macro to keep
each device-table entry on one line and make the table easier to scan.

Signed-off-by: Crescent Hsieh <crescentcy.hsieh@moxa.com>
---
 drivers/usb/serial/mxuport.c | 43 ++++++++++++++++--------------------
 1 file changed, 19 insertions(+), 24 deletions(-)

diff --git a/drivers/usb/serial/mxuport.c b/drivers/usb/serial/mxuport.c
index 088d5dd8abb5..a4e0467171c6 100644
--- a/drivers/usb/serial/mxuport.c
+++ b/drivers/usb/serial/mxuport.c
@@ -28,14 +28,14 @@
 /* Definitions for the vendor ID and device ID */
 #define MX_USBSERIAL_VID	0x110A
 #define MX_UPORT1250_PID	0x1250
-#define MX_UPORT1251_PID	0x1251
+#define MX_UPORT1250I_PID	0x1251
 #define MX_UPORT1410_PID	0x1410
 #define MX_UPORT1450_PID	0x1450
-#define MX_UPORT1451_PID	0x1451
-#define MX_UPORT1618_PID	0x1618
-#define MX_UPORT1658_PID	0x1658
-#define MX_UPORT1613_PID	0x1613
-#define MX_UPORT1653_PID	0x1653
+#define MX_UPORT1450I_PID	0x1451
+#define MX_UPORT1610_8_PID	0x1618
+#define MX_UPORT1650_8_PID	0x1658
+#define MX_UPORT1610_16_PID	0x1613
+#define MX_UPORT1650_16_PID	0x1653
 
 /* Definitions for USB info */
 #define HEADER_SIZE		4
@@ -157,26 +157,21 @@ struct mxuport_port {
 #define MX_PORTS_OFFSET			1
 #define MX_PORTS(n)			(((n) - MX_PORTS_OFFSET) & MX_PORTS_MASK)
 
+#define MX_DEVICE(pid, ports)					\
+	{ USB_DEVICE(MX_USBSERIAL_VID, pid),			\
+	  .driver_info = MX_PORTS(ports) }
+
 /* Table of devices that work with this driver */
 static const struct usb_device_id mxuport_idtable[] = {
-	{ USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1250_PID),
-	  .driver_info = MX_PORTS(2) },
-	{ USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1251_PID),
-	  .driver_info = MX_PORTS(2) },
-	{ USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1410_PID),
-	  .driver_info = MX_PORTS(4) },
-	{ USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1450_PID),
-	  .driver_info = MX_PORTS(4) },
-	{ USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1451_PID),
-	  .driver_info = MX_PORTS(4) },
-	{ USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1618_PID),
-	  .driver_info = MX_PORTS(8) },
-	{ USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1658_PID),
-	  .driver_info = MX_PORTS(8) },
-	{ USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1613_PID),
-	  .driver_info = MX_PORTS(16) },
-	{ USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1653_PID),
-	  .driver_info = MX_PORTS(16) },
+	MX_DEVICE(MX_UPORT1250_PID,	 2),
+	MX_DEVICE(MX_UPORT1250I_PID,	 2),
+	MX_DEVICE(MX_UPORT1410_PID,	 4),
+	MX_DEVICE(MX_UPORT1450_PID,	 4),
+	MX_DEVICE(MX_UPORT1450I_PID,	 4),
+	MX_DEVICE(MX_UPORT1610_8_PID,	 8),
+	MX_DEVICE(MX_UPORT1650_8_PID,	 8),
+	MX_DEVICE(MX_UPORT1610_16_PID,	16),
+	MX_DEVICE(MX_UPORT1650_16_PID,	16),
 	{}			/* Terminating entry */
 };
 
-- 
2.53.0

[PATCH v3 2/6] USB: serial: mxuport: clean up firmware version handling

[Crescent Hsieh]

Add a small helper for parsing firmware versions and use it for the
firmware image. This avoids open-coded firmware image offsets in
probe() and retains the existing image-size validation before reading
the version bytes.

Keep the existing version comparison policy unchanged, but store the
version components explicitly so that the version can be printed
without unpacking a raw integer.

Print the firmware version fields in decimal, as these fields represent
readable version components rather than hexadecimal values.

Signed-off-by: Crescent Hsieh <crescentcy.hsieh@moxa.com>
---
 drivers/usb/serial/mxuport.c | 78 ++++++++++++++++++++++++------------
 1 file changed, 53 insertions(+), 25 deletions(-)

diff --git a/drivers/usb/serial/mxuport.c b/drivers/usb/serial/mxuport.c
index a4e0467171c6..61d4c6e1a9ce 100644
--- a/drivers/usb/serial/mxuport.c
+++ b/drivers/usb/serial/mxuport.c
@@ -43,9 +43,22 @@
 #define DOWN_BLOCK_SIZE		64
 
 /* Definitions for firmware info */
-#define VER_ADDR_1		0x20
-#define VER_ADDR_2		0x24
-#define VER_ADDR_3		0x28
+#define MX_FW_VER_BYTE1_OFF		0x20
+#define MX_FW_VER_BYTE2_OFF		0x24
+#define MX_FW_VER_BYTE3_OFF		0x28
+
+struct mxuport_fw_version {
+	u8 major;
+	u8 minor;
+	u8 build;
+	u32 value;
+};
+
+static const u16 mxuport_fw_ver_offsets[] = {
+	MX_FW_VER_BYTE1_OFF,
+	MX_FW_VER_BYTE2_OFF,
+	MX_FW_VER_BYTE3_OFF,
+};
 
 /* Definitions for USB vendor request */
 #define RQ_VENDOR_NONE			0x00
@@ -965,8 +978,31 @@ static int mxuport_calc_num_ports(struct usb_serial *serial,
 	return num_ports;
 }
 
+static void mxuport_compose_fw_version(struct mxuport_fw_version *version,
+				       u8 major, u8 minor, u8 build)
+{
+	version->major = major;
+	version->minor = minor;
+	version->build = build;
+	version->value = (major << 16) | (minor << 8) | build;
+}
+
+static int mxuport_parse_fw_version(const struct firmware *fw,
+				    const u16 *offsets,
+				    struct mxuport_fw_version *version)
+{
+	if (fw->size <= offsets[2])
+		return -EINVAL;
+
+	mxuport_compose_fw_version(version, fw->data[offsets[0]],
+				   fw->data[offsets[1]], fw->data[offsets[2]]);
+
+	return 0;
+}
+
 /* Get the version of the firmware currently running. */
-static int mxuport_get_fw_version(struct usb_serial *serial, u32 *version)
+static int mxuport_get_fw_version(struct usb_serial *serial,
+				  struct mxuport_fw_version *version)
 {
 	u8 *ver_buf;
 	int err;
@@ -983,7 +1019,7 @@ static int mxuport_get_fw_version(struct usb_serial *serial, u32 *version)
 		goto out;
 	}
 
-	*version = (ver_buf[0] << 16) | (ver_buf[1] << 8) | ver_buf[2];
+	mxuport_compose_fw_version(version, ver_buf[0], ver_buf[1], ver_buf[2]);
 	err = 0;
 out:
 	kfree(ver_buf);
@@ -1043,9 +1079,8 @@ static int mxuport_probe(struct usb_serial *serial,
 			 const struct usb_device_id *id)
 {
 	u16 productid = le16_to_cpu(serial->dev->descriptor.idProduct);
+	struct mxuport_fw_version version, local_ver;
 	const struct firmware *fw_p = NULL;
-	u32 version;
-	int local_ver;
 	char buf[32];
 	int err;
 
@@ -1060,10 +1095,8 @@ static int mxuport_probe(struct usb_serial *serial,
 	if (err < 0)
 		return err;
 
-	dev_dbg(&serial->interface->dev, "Device firmware version v%x.%x.%x\n",
-		(version & 0xff0000) >> 16,
-		(version & 0xff00) >> 8,
-		(version & 0xff));
+	dev_dbg(&serial->interface->dev, "Device firmware version v%u.%u.%u\n",
+		version.major, version.minor, version.build);
 
 	snprintf(buf, sizeof(buf) - 1, "moxa/moxa-%04x.fw", productid);
 
@@ -1075,35 +1108,30 @@ static int mxuport_probe(struct usb_serial *serial,
 		/* Use the firmware already in the device */
 		err = 0;
 	} else {
-		if (fw_p->size <= VER_ADDR_3) {
+		err = mxuport_parse_fw_version(fw_p, mxuport_fw_ver_offsets, &local_ver);
+		if (err) {
 			dev_err(&serial->interface->dev,
 				"Firmware %s is too short\n", buf);
-			err = -EINVAL;
 			goto out;
 		}
 
-		local_ver = ((fw_p->data[VER_ADDR_1] << 16) |
-			     (fw_p->data[VER_ADDR_2] << 8) |
-			     fw_p->data[VER_ADDR_3]);
 		dev_dbg(&serial->interface->dev,
-			"Available firmware version v%x.%x.%x\n",
-			fw_p->data[VER_ADDR_1], fw_p->data[VER_ADDR_2],
-			fw_p->data[VER_ADDR_3]);
-		if (local_ver > version) {
+			"Available firmware version v%u.%u.%u\n",
+			local_ver.major, local_ver.minor, local_ver.build);
+
+		if (local_ver.value > version.value) {
 			err = mxuport_download_fw(serial, fw_p);
 			if (err)
 				goto out;
-			err  = mxuport_get_fw_version(serial, &version);
+			err = mxuport_get_fw_version(serial, &version);
 			if (err < 0)
 				goto out;
 		}
 	}
 
 	dev_info(&serial->interface->dev,
-		 "Using device firmware version v%x.%x.%x\n",
-		 (version & 0xff0000) >> 16,
-		 (version & 0xff00) >> 8,
-		 (version & 0xff));
+		 "Using device firmware version v%u.%u.%u\n",
+		 version.major, version.minor, version.build);
 
 	/*
 	 * Contains the features of this hardware. Store away for
-- 
2.53.0

[PATCH v3 3/6] USB: serial: mxuport: add MUX50U-based device support

[Crescent Hsieh]

Add support for MUX50U-based UPort G2 devices and Platform UARTs.
Add their product IDs and list the supported products by family.

Encode the number of ports and device family in each USB device ID
entry. Use the family to select the firmware image and version
offsets, and the method used to determine whether a firmware download
is needed.

UPort G2 devices use the shared UP firmware image
(moxa-up-mux50u.fw), while Platform UARTs use the shared PF firmware
image (moxa-pf-mux50u.fw). Platform UARTs are board-level UARTs
accessed through the USB bus.

The factory firmware on MUX50U-based devices reports its version in a
different format from the runtime firmware image, so version comparison
cannot reliably determine whether a firmware download is needed. Check
the system-register remap state instead to determine whether the device
is already running the runtime firmware from SRAM.

Keep the existing per-product firmware selection and version comparison
for UPort G1 devices.

Signed-off-by: Crescent Hsieh <crescentcy.hsieh@moxa.com>
---
 drivers/usb/serial/mxuport.c | 170 +++++++++++++++++++++++++++++++----
 1 file changed, 152 insertions(+), 18 deletions(-)

diff --git a/drivers/usb/serial/mxuport.c b/drivers/usb/serial/mxuport.c
index 61d4c6e1a9ce..35123572ca4d 100644
--- a/drivers/usb/serial/mxuport.c
+++ b/drivers/usb/serial/mxuport.c
@@ -6,10 +6,20 @@
  *	Copyright (c) 2013 Andrew Lunn <andrew@lunn.ch>
  *
  *	Supports the following Moxa USB to serial converters:
- *	 2 ports : UPort 1250, UPort 1250I
- *	 4 ports : UPort 1410, UPort 1450, UPort 1450I
- *	 8 ports : UPort 1610-8, UPort 1650-8
- *	16 ports : UPort 1610-16, UPort 1650-16
+ *
+ *	UPort G1:
+ *		UPort 1250, UPort 1250I
+ *		UPort 1410, UPort 1450, UPort 1450I
+ *		UPort 1610-8, UPort 1650-8
+ *		UPort 1610-16, UPort 1650-16
+ *	UPort G2:
+ *		UPort 1250-G2, UPort 1250I-G2
+ *		UPort 1410-G2, UPort 1450-G2, UPort 1450I-G2
+ *		UPort 1610-8-G2, UPort 1650-8-G2
+ *		UPort 1650-8-G2-Hub, UPort 1650I-8-G2
+ *	Platform UART:
+ *		MU250U, MU450U, MU850U
+ *		MUx50U-3, MUx50U-5, MUx50U-6, MUx50U-7
  */
 
 #include <linux/kernel.h>
@@ -37,6 +47,24 @@
 #define MX_UPORT1610_16_PID	0x1613
 #define MX_UPORT1650_16_PID	0x1653
 
+#define MX_UPORT1250_G2_PID		0x1252
+#define MX_UPORT1250I_G2_PID		0x1253
+#define MX_UPORT1410_G2_PID		0x1411
+#define MX_UPORT1450_G2_PID		0x1452
+#define MX_UPORT1450I_G2_PID		0x1453
+#define MX_UPORT1610_8_G2_PID		0x1619
+#define MX_UPORT1650_8_G2_PID		0x1659
+#define MX_UPORT1650_8_G2_HUB_PID	0x165a
+#define MX_UPORT1650I_8_G2_PID		0x165b
+
+#define MX_MU250U_PID		0x0250
+#define MX_MU450U_PID		0x0450
+#define MX_MU850U_PID		0x0850
+#define MX_MUX50U_6_PID		0x7002
+#define MX_MUX50U_3_PID		0x7003
+#define MX_MUX50U_5_PID		0x7004
+#define MX_MUX50U_7_PID		0x7005
+
 /* Definitions for USB info */
 #define HEADER_SIZE		4
 #define EVENT_LENGTH		8
@@ -46,6 +74,13 @@
 #define MX_FW_VER_BYTE1_OFF		0x20
 #define MX_FW_VER_BYTE2_OFF		0x24
 #define MX_FW_VER_BYTE3_OFF		0x28
+#define MX_MUX50U_FW_VER_BYTE1_OFF	0x86
+#define MX_MUX50U_FW_VER_BYTE2_OFF	0x88
+#define MX_MUX50U_FW_VER_BYTE3_OFF	0x8a
+
+#define MX_SYS_REG_REMAP_OFF		0x20
+#define MX_PWR_REMAP_MASK		0x03
+#define MX_REMAP_TO_SRAM		0x02
 
 struct mxuport_fw_version {
 	u8 major;
@@ -60,6 +95,12 @@ static const u16 mxuport_fw_ver_offsets[] = {
 	MX_FW_VER_BYTE3_OFF,
 };
 
+static const u16 mxuport_mux50u_fw_ver_offsets[] = {
+	MX_MUX50U_FW_VER_BYTE1_OFF,
+	MX_MUX50U_FW_VER_BYTE2_OFF,
+	MX_MUX50U_FW_VER_BYTE3_OFF,
+};
+
 /* Definitions for USB vendor request */
 #define RQ_VENDOR_NONE			0x00
 #define RQ_VENDOR_SET_BAUD		0x01 /* Set baud rate */
@@ -96,6 +137,8 @@ static const u16 mxuport_fw_ver_offsets[] = {
 #define RQ_VENDOR_RESET_DEVICE		0x23 /* Try to reset the device */
 #define RQ_VENDOR_QUERY_FW_CONFIG	0x24
 
+#define RQ_VENDOR_GET_SYS_REG		0x34
+
 #define RQ_VENDOR_GET_VERSION		0x81 /* Get firmware version */
 #define RQ_VENDOR_GET_PAGE		0x82 /* Read flash page */
 #define RQ_VENDOR_GET_ROM_PROC		0x83 /* Get ROM process state */
@@ -170,21 +213,44 @@ struct mxuport_port {
 #define MX_PORTS_OFFSET			1
 #define MX_PORTS(n)			(((n) - MX_PORTS_OFFSET) & MX_PORTS_MASK)
 
-#define MX_DEVICE(pid, ports)					\
+#define MX_FAMILY_MASK			GENMASK(5, 4)
+#define MX_UPORT_G1			0
+#define MX_UPORT_G2			BIT(4)
+#define MX_PLATFORM_UART		BIT(5)
+#define MX_FAMILY(info)			((info) & MX_FAMILY_MASK)
+#define MX_DEVICE_INFO(ports, family)	(MX_PORTS(ports) | (family))
+
+#define MX_DEVICE(pid, ports, family)				\
 	{ USB_DEVICE(MX_USBSERIAL_VID, pid),			\
-	  .driver_info = MX_PORTS(ports) }
+	  .driver_info = MX_DEVICE_INFO(ports, family) }
 
 /* Table of devices that work with this driver */
 static const struct usb_device_id mxuport_idtable[] = {
-	MX_DEVICE(MX_UPORT1250_PID,	 2),
-	MX_DEVICE(MX_UPORT1250I_PID,	 2),
-	MX_DEVICE(MX_UPORT1410_PID,	 4),
-	MX_DEVICE(MX_UPORT1450_PID,	 4),
-	MX_DEVICE(MX_UPORT1450I_PID,	 4),
-	MX_DEVICE(MX_UPORT1610_8_PID,	 8),
-	MX_DEVICE(MX_UPORT1650_8_PID,	 8),
-	MX_DEVICE(MX_UPORT1610_16_PID,	16),
-	MX_DEVICE(MX_UPORT1650_16_PID,	16),
+	MX_DEVICE(MX_UPORT1250_PID,	     2, MX_UPORT_G1),
+	MX_DEVICE(MX_UPORT1250I_PID,	     2, MX_UPORT_G1),
+	MX_DEVICE(MX_UPORT1410_PID,	     4, MX_UPORT_G1),
+	MX_DEVICE(MX_UPORT1450_PID,	     4, MX_UPORT_G1),
+	MX_DEVICE(MX_UPORT1450I_PID,	     4, MX_UPORT_G1),
+	MX_DEVICE(MX_UPORT1610_8_PID,	     8, MX_UPORT_G1),
+	MX_DEVICE(MX_UPORT1650_8_PID,	     8, MX_UPORT_G1),
+	MX_DEVICE(MX_UPORT1610_16_PID,	    16, MX_UPORT_G1),
+	MX_DEVICE(MX_UPORT1650_16_PID,	    16, MX_UPORT_G1),
+	MX_DEVICE(MX_UPORT1250_G2_PID,	     2, MX_UPORT_G2),
+	MX_DEVICE(MX_UPORT1250I_G2_PID,	     2, MX_UPORT_G2),
+	MX_DEVICE(MX_UPORT1410_G2_PID,	     4, MX_UPORT_G2),
+	MX_DEVICE(MX_UPORT1450_G2_PID,	     4, MX_UPORT_G2),
+	MX_DEVICE(MX_UPORT1450I_G2_PID,	     4, MX_UPORT_G2),
+	MX_DEVICE(MX_UPORT1610_8_G2_PID,     8, MX_UPORT_G2),
+	MX_DEVICE(MX_UPORT1650_8_G2_PID,     8, MX_UPORT_G2),
+	MX_DEVICE(MX_UPORT1650_8_G2_HUB_PID, 8, MX_UPORT_G2),
+	MX_DEVICE(MX_UPORT1650I_8_G2_PID,    8, MX_UPORT_G2),
+	MX_DEVICE(MX_MU250U_PID,	     2, MX_PLATFORM_UART),
+	MX_DEVICE(MX_MU450U_PID,	     4, MX_PLATFORM_UART),
+	MX_DEVICE(MX_MU850U_PID,	     8, MX_PLATFORM_UART),
+	MX_DEVICE(MX_MUX50U_6_PID,	     6, MX_PLATFORM_UART),
+	MX_DEVICE(MX_MUX50U_3_PID,	     3, MX_PLATFORM_UART),
+	MX_DEVICE(MX_MUX50U_5_PID,	     5, MX_PLATFORM_UART),
+	MX_DEVICE(MX_MUX50U_7_PID,	     7, MX_PLATFORM_UART),
 	{}			/* Terminating entry */
 };
 
@@ -1000,6 +1066,56 @@ static int mxuport_parse_fw_version(const struct firmware *fw,
 	return 0;
 }
 
+static bool mxuport_is_mux50u_device(unsigned long features)
+{
+	switch (MX_FAMILY(features)) {
+	case MX_UPORT_G2:
+	case MX_PLATFORM_UART:
+		return true;
+	default:
+		return false;
+	}
+}
+
+static void mxuport_get_fw_name(unsigned long features, u16 productid,
+				char *buf, size_t size)
+{
+	switch (MX_FAMILY(features)) {
+	case MX_UPORT_G2:
+		strscpy(buf, "moxa/moxa-up-mux50u.fw", size);
+		break;
+	case MX_PLATFORM_UART:
+		strscpy(buf, "moxa/moxa-pf-mux50u.fw", size);
+		break;
+	default:
+		snprintf(buf, size, "moxa/moxa-%04x.fw", productid);
+		break;
+	}
+}
+
+static int mxuport_fw_running_from_sram(struct usb_serial *serial, bool *from_sram)
+{
+	int err;
+	u32 reg;
+	u8 *buf;
+
+	buf = kzalloc_objs(*buf, sizeof(reg));
+	if (!buf)
+		return -ENOMEM;
+
+	err = mxuport_recv_ctrl_urb(serial, RQ_VENDOR_GET_SYS_REG,
+				    MX_SYS_REG_REMAP_OFF, 0, buf, sizeof(reg));
+	if (err < 0)
+		goto out;
+
+	reg = get_unaligned_be32(buf);
+	*from_sram = (((reg >> 24) & MX_PWR_REMAP_MASK) == MX_REMAP_TO_SRAM);
+	err = 0;
+out:
+	kfree(buf);
+	return err;
+}
+
 /* Get the version of the firmware currently running. */
 static int mxuport_get_fw_version(struct usb_serial *serial,
 				  struct mxuport_fw_version *version)
@@ -1080,7 +1196,10 @@ static int mxuport_probe(struct usb_serial *serial,
 {
 	u16 productid = le16_to_cpu(serial->dev->descriptor.idProduct);
 	struct mxuport_fw_version version, local_ver;
+	unsigned long features = id->driver_info;
 	const struct firmware *fw_p = NULL;
+	const u16 *fw_version_offsets;
+	bool download_fw, from_sram;
 	char buf[32];
 	int err;
 
@@ -1098,7 +1217,12 @@ static int mxuport_probe(struct usb_serial *serial,
 	dev_dbg(&serial->interface->dev, "Device firmware version v%u.%u.%u\n",
 		version.major, version.minor, version.build);
 
-	snprintf(buf, sizeof(buf) - 1, "moxa/moxa-%04x.fw", productid);
+	if (mxuport_is_mux50u_device(features))
+		fw_version_offsets = mxuport_mux50u_fw_ver_offsets;
+	else
+		fw_version_offsets = mxuport_fw_ver_offsets;
+
+	mxuport_get_fw_name(features, productid, buf, sizeof(buf));
 
 	err = request_firmware(&fw_p, buf, &serial->interface->dev);
 	if (err) {
@@ -1108,7 +1232,7 @@ static int mxuport_probe(struct usb_serial *serial,
 		/* Use the firmware already in the device */
 		err = 0;
 	} else {
-		err = mxuport_parse_fw_version(fw_p, mxuport_fw_ver_offsets, &local_ver);
+		err = mxuport_parse_fw_version(fw_p, fw_version_offsets, &local_ver);
 		if (err) {
 			dev_err(&serial->interface->dev,
 				"Firmware %s is too short\n", buf);
@@ -1119,7 +1243,17 @@ static int mxuport_probe(struct usb_serial *serial,
 			"Available firmware version v%u.%u.%u\n",
 			local_ver.major, local_ver.minor, local_ver.build);
 
-		if (local_ver.value > version.value) {
+		if (mxuport_is_mux50u_device(features)) {
+			err = mxuport_fw_running_from_sram(serial, &from_sram);
+			if (err)
+				goto out;
+
+			download_fw = !from_sram;
+		} else {
+			download_fw = local_ver.value > version.value;
+		}
+
+		if (download_fw) {
 			err = mxuport_download_fw(serial, fw_p);
 			if (err)
 				goto out;
-- 
2.53.0

[PATCH v3 4/6] USB: serial: add generic write control callbacks

[Crescent Hsieh]

Some USB serial devices use device-specific flow control to determine
whether write submission may proceed. The generic write path currently
provides no way to pause submission based on driver-specific state. It
also provides no way for a driver to restore its state if URB submission
fails.

Add an optional write_ready() callback to struct usb_serial_driver. Call
it with port->lock held after confirming that data is queued and a write
URB is available. If the callback returns false, stop write processing
and leave the data in the FIFO. The driver must call
usb_serial_generic_write_start() when writes may proceed again.

Add an optional write_rollback() callback for restoring driver-specific
state after usb_submit_urb() fails. Call it with port->lock held after
restoring the generic transmit accounting, and pass it the length of the
prepared transfer.

Drivers which do not provide these callbacks retain the existing generic
write behaviour.

Signed-off-by: Crescent Hsieh <crescentcy.hsieh@moxa.com>
---
 drivers/usb/serial/generic.c | 12 ++++++++----
 include/linux/usb/serial.h   |  9 ++++++++-
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index 6eaf74930aa3..bb042b97893b 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -152,6 +152,7 @@ int usb_serial_generic_prepare_write_buffer(struct usb_serial_port *port,
 int usb_serial_generic_write_start(struct usb_serial_port *port,
 							gfp_t mem_flags)
 {
+	struct usb_serial_driver *type = port->serial->type;
 	struct urb *urb;
 	int count, result;
 	unsigned long flags;
@@ -161,7 +162,8 @@ int usb_serial_generic_write_start(struct usb_serial_port *port,
 		return 0;
 retry:
 	spin_lock_irqsave(&port->lock, flags);
-	if (!port->write_urbs_free || !kfifo_len(&port->write_fifo)) {
+	if (!port->write_urbs_free || !kfifo_len(&port->write_fifo) ||
+	    (type->write_ready && !type->write_ready(port))) {
 		clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
 		spin_unlock_irqrestore(&port->lock, flags);
 		return 0;
@@ -171,9 +173,7 @@ int usb_serial_generic_write_start(struct usb_serial_port *port,
 	spin_unlock_irqrestore(&port->lock, flags);
 
 	urb = port->write_urbs[i];
-	count = port->serial->type->prepare_write_buffer(port,
-						urb->transfer_buffer,
-						port->bulk_out_size);
+	count = type->prepare_write_buffer(port, urb->transfer_buffer, port->bulk_out_size);
 	urb->transfer_buffer_length = count;
 	usb_serial_debug_data(&port->dev, __func__, count, urb->transfer_buffer);
 	spin_lock_irqsave(&port->lock, flags);
@@ -188,6 +188,10 @@ int usb_serial_generic_write_start(struct usb_serial_port *port,
 		set_bit(i, &port->write_urbs_free);
 		spin_lock_irqsave(&port->lock, flags);
 		port->tx_bytes -= count;
+
+		if (type->write_rollback)
+			type->write_rollback(port, count);
+
 		spin_unlock_irqrestore(&port->lock, flags);
 
 		clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index 534e6650e2aa..d44ae5a9bf5d 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -305,9 +305,17 @@ struct usb_serial_driver {
 	void (*write_bulk_callback)(struct urb *urb);
 	/* Called by the generic read bulk callback */
 	void (*process_read_urb)(struct urb *urb);
+	/*
+	 * Called with port->lock held before preparing another write URB.
+	 * Drivers returning false must restart the generic write path when
+	 * writes may proceed again.
+	 */
+	bool (*write_ready)(struct usb_serial_port *port);
 	/* Called by the generic write implementation */
 	int (*prepare_write_buffer)(struct usb_serial_port *port,
 						void *dest, size_t size);
+	/* Called with port->lock held to roll back a failed write submission */
+	void (*write_rollback)(struct usb_serial_port *port, int count);
 };
 #define to_usb_serial_driver(d) \
 	container_of(d, struct usb_serial_driver, driver)
@@ -436,4 +444,3 @@ module_exit(usb_serial_module_exit);
 	usb_serial_module_driver(KBUILD_MODNAME, __serial_drivers, __ids)
 
 #endif /* __LINUX_USB_SERIAL_H */
-
-- 
2.53.0

[PATCH v3 5/6] USB: serial: mxuport: handle SEND_NEXT transmit flow control

[Crescent Hsieh]

The device uses a per-port SEND_NEXT request and event to pace
host-to-device transmission. During burn-in testing, sustained writes
without waiting for this event resulted in per-port buffer overflows and
data errors. The issue can be reproduced on existing G1 devices as well.

The driver initiates the protocol by setting the SEND_NEXT bit in a
bulk-out header and then stops submitting data for that port. The
firmware reports a SEND_NEXT event when the corresponding per-port
buffer is empty, at which point the driver resumes transmission.

Track the payload placed in bulk-out transfers for each port and set the
request bit when it reaches bulk_out_size. Use the generic write control
callbacks to hold further submissions until the event arrives and to
roll back the payload count and hold state if usb_submit_urb() fails.

Use bulk_out_size as a common threshold for all device families instead
of encoding their firmware buffer sizes in the driver.

Signed-off-by: Crescent Hsieh <crescentcy.hsieh@moxa.com>
---
 drivers/usb/serial/mxuport.c | 61 +++++++++++++++++++++++++++++++-----
 1 file changed, 54 insertions(+), 7 deletions(-)

diff --git a/drivers/usb/serial/mxuport.c b/drivers/usb/serial/mxuport.c
index 35123572ca4d..96dc85defb0b 100644
--- a/drivers/usb/serial/mxuport.c
+++ b/drivers/usb/serial/mxuport.c
@@ -156,6 +156,8 @@ static const u16 mxuport_mux50u_fw_ver_offsets[] = {
 #define UPORT_EVENT_LSR			4 /* Line status */
 #define UPORT_EVENT_MCR			5 /* Modem control */
 
+#define UPORT_REQUEST_SEND_NEXT		0x80
+
 /* Definitions for serial event type */
 #define SERIAL_EV_CTS			0x0008	/* CTS changed state */
 #define SERIAL_EV_DSR			0x0010	/* DSR changed state */
@@ -202,6 +204,8 @@ static const u16 mxuport_mux50u_fw_ver_offsets[] = {
 
 /* This structure holds all of the local port information */
 struct mxuport_port {
+	u32 sent_payload;
+	u8 hold_reason;
 	u8 mcr_state;		/* Last MCR state */
 	u8 msr_state;		/* Last MSR state */
 	struct mutex mutex;	/* Protects mcr_state */
@@ -256,6 +260,13 @@ static const struct usb_device_id mxuport_idtable[] = {
 
 MODULE_DEVICE_TABLE(usb, mxuport_idtable);
 
+static bool mxuport_write_ready(struct usb_serial_port *port)
+{
+	struct mxuport_port *mxport = usb_get_serial_port_data(port);
+
+	return !(mxport->hold_reason & MX_WAIT_FOR_SEND_NEXT);
+}
+
 /*
  * Add a four byte header containing the port number and the number of
  * bytes of data in the message. Return the number of bytes in the
@@ -264,22 +275,40 @@ MODULE_DEVICE_TABLE(usb, mxuport_idtable);
 static int mxuport_prepare_write_buffer(struct usb_serial_port *port,
 					void *dest, size_t size)
 {
+	struct mxuport_port *mxport = usb_get_serial_port_data(port);
+	bool request_send_next;
+	unsigned long flags;
 	u8 *buf = dest;
 	int count;
 
-	count = kfifo_out_locked(&port->write_fifo, buf + HEADER_SIZE,
-				 size - HEADER_SIZE,
-				 &port->lock);
+	spin_lock_irqsave(&port->lock, flags);
+	count = kfifo_out(&port->write_fifo, buf + HEADER_SIZE, size - HEADER_SIZE);
+	mxport->sent_payload += count;
+	request_send_next = mxport->sent_payload >= port->bulk_out_size;
+	if (request_send_next)
+		mxport->hold_reason |= MX_WAIT_FOR_SEND_NEXT;
+	spin_unlock_irqrestore(&port->lock, flags);
 
 	put_unaligned_be16(port->port_number, buf);
 	put_unaligned_be16(count, buf + 2);
 
+	if (request_send_next)
+		buf[0] |= UPORT_REQUEST_SEND_NEXT;
+
 	dev_dbg(&port->dev, "%s - size %zd count %d\n", __func__,
 		size, count);
 
 	return count + HEADER_SIZE;
 }
 
+static void mxuport_write_rollback(struct usb_serial_port *port, int count)
+{
+	struct mxuport_port *mxport = usb_get_serial_port_data(port);
+
+	mxport->sent_payload -= count - HEADER_SIZE;
+	mxport->hold_reason &= ~MX_WAIT_FOR_SEND_NEXT;
+}
+
 /* Read the given buffer in from the control pipe. */
 static int mxuport_recv_ctrl_urb(struct usb_serial *serial,
 				 u8 request, u16 value, u16 index,
@@ -498,14 +527,24 @@ static void mxuport_lsr_event(struct usb_serial_port *port, u8 buf[4])
 static void mxuport_process_read_urb_event(struct usb_serial_port *port,
 					   u8 buf[4], u32 event)
 {
+	struct mxuport_port *mxport = usb_get_serial_port_data(port);
+	bool resume_tx = false;
+	unsigned long flags;
+
 	dev_dbg(&port->dev, "%s - receive event : %04x\n", __func__, event);
 
 	switch (event) {
 	case UPORT_EVENT_SEND_NEXT:
-		/*
-		 * Sent as part of the flow control on device buffers.
-		 * Not currently used.
-		 */
+		spin_lock_irqsave(&port->lock, flags);
+		if (mxport->hold_reason & MX_WAIT_FOR_SEND_NEXT) {
+			mxport->hold_reason &= ~MX_WAIT_FOR_SEND_NEXT;
+			mxport->sent_payload = 0;
+			resume_tx = true;
+		}
+		spin_unlock_irqrestore(&port->lock, flags);
+
+		if (resume_tx)
+			usb_serial_generic_write_start(port, GFP_ATOMIC);
 		break;
 	case UPORT_EVENT_MSR:
 		mxuport_msr_event(port, buf);
@@ -1353,6 +1392,7 @@ static int mxuport_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
 	struct mxuport_port *mxport = usb_get_serial_port_data(port);
 	struct usb_serial *serial = port->serial;
+	unsigned long flags;
 	int err;
 
 	/* Set receive host (enable) */
@@ -1373,6 +1413,11 @@ static int mxuport_open(struct tty_struct *tty, struct usb_serial_port *port)
 	if (tty)
 		mxuport_set_termios(tty, port, NULL);
 
+	spin_lock_irqsave(&port->lock, flags);
+	mxport->sent_payload = 0;
+	mxport->hold_reason &= ~MX_WAIT_FOR_SEND_NEXT;
+	spin_unlock_irqrestore(&port->lock, flags);
+
 	/*
 	 * TODO: use RQ_VENDOR_GET_MSR, once we know what it
 	 * returns.
@@ -1466,7 +1511,9 @@ static struct usb_serial_driver mxuport_device = {
 	.tiocmset		= mxuport_tiocmset,
 	.dtr_rts		= mxuport_dtr_rts,
 	.process_read_urb	= mxuport_process_read_urb,
+	.write_ready		= mxuport_write_ready,
 	.prepare_write_buffer	= mxuport_prepare_write_buffer,
+	.write_rollback		= mxuport_write_rollback,
 	.resume			= mxuport_resume,
 };
 
-- 
2.53.0

[PATCH v3 6/6] USB: serial: mxuport: support RS485 mode configuration

[Crescent Hsieh]

Add support for TIOCSRS485 and TIOCGRS485 so that userspace can
configure the serial interface mode using struct serial_rs485.

Map the serial_rs485 flags to the device interface modes as follows:

  - RS232                  = no flags set
  - RS422                  = SER_RS485_ENABLED | SER_RS485_MODE_RS422
  - RS485_2W (half-duplex) = SER_RS485_ENABLED
  - RS485_4W (full-duplex) = SER_RS485_ENABLED | SER_RS485_RX_DURING_TX

Unsupported flags and fields are cleared before applying the
configuration. Cache the sanitized per-port configuration and serialize
access with the per-port mutex.

Signed-off-by: Crescent Hsieh <crescentcy.hsieh@moxa.com>
---
 drivers/usb/serial/mxuport.c | 98 +++++++++++++++++++++++++++++++++++-
 1 file changed, 97 insertions(+), 1 deletion(-)

diff --git a/drivers/usb/serial/mxuport.c b/drivers/usb/serial/mxuport.c
index 96dc85defb0b..319704e64528 100644
--- a/drivers/usb/serial/mxuport.c
+++ b/drivers/usb/serial/mxuport.c
@@ -208,7 +208,8 @@ struct mxuport_port {
 	u8 hold_reason;
 	u8 mcr_state;		/* Last MCR state */
 	u8 msr_state;		/* Last MSR state */
-	struct mutex mutex;	/* Protects mcr_state */
+	struct serial_rs485 rs485;
+	struct mutex mutex;	/* Protects per-port control state */
 	spinlock_t spinlock;	/* Protects msr_state */
 };
 
@@ -870,6 +871,100 @@ static int mxuport_tiocmget(struct tty_struct *tty)
 	return result;
 }
 
+static void mxuport_sanitize_serial_rs485(struct serial_rs485 *rs485)
+{
+	if (!(rs485->flags & SER_RS485_ENABLED)) {
+		memset(rs485, 0, sizeof(*rs485));
+		return;
+	}
+
+	if (rs485->flags & SER_RS485_MODE_RS422)
+		rs485->flags &= SER_RS485_ENABLED | SER_RS485_MODE_RS422;
+	else
+		rs485->flags &= SER_RS485_ENABLED | SER_RS485_RX_DURING_TX;
+
+	rs485->delay_rts_before_send = 0;
+	rs485->delay_rts_after_send = 0;
+	memset(rs485->padding, 0, sizeof(rs485->padding));
+}
+
+static int mxuport_rs485_config(struct usb_serial_port *port,
+				const struct serial_rs485 *rs485)
+{
+	struct usb_serial *serial = port->serial;
+	u16 mode = MX_INT_RS232;
+
+	if (rs485->flags & SER_RS485_ENABLED) {
+		if (rs485->flags & SER_RS485_MODE_RS422)
+			mode = MX_INT_RS422;
+		else if (rs485->flags & SER_RS485_RX_DURING_TX)
+			mode = MX_INT_4W_RS485;
+		else
+			mode = MX_INT_2W_RS485;
+	}
+
+	return mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_INTERFACE, mode,
+				     port->port_number);
+}
+
+static int mxuport_get_rs485_config(struct usb_serial_port *port,
+				    struct serial_rs485 __user *argp)
+{
+	struct mxuport_port *mxport = usb_get_serial_port_data(port);
+	struct serial_rs485 rs485;
+
+	mutex_lock(&mxport->mutex);
+	rs485 = mxport->rs485;
+	mutex_unlock(&mxport->mutex);
+
+	if (copy_to_user(argp, &rs485, sizeof(rs485)))
+		return -EFAULT;
+
+	return 0;
+}
+
+static int mxuport_set_rs485_config(struct usb_serial_port *port,
+				    struct serial_rs485 __user *argp)
+{
+	struct mxuport_port *mxport = usb_get_serial_port_data(port);
+	struct serial_rs485 rs485;
+	int err;
+
+	if (copy_from_user(&rs485, argp, sizeof(rs485)))
+		return -EFAULT;
+
+	mxuport_sanitize_serial_rs485(&rs485);
+
+	mutex_lock(&mxport->mutex);
+	err = mxuport_rs485_config(port, &rs485);
+	if (!err)
+		mxport->rs485 = rs485;
+	mutex_unlock(&mxport->mutex);
+	if (err)
+		return err;
+
+	if (copy_to_user(argp, &rs485, sizeof(rs485)))
+		return -EFAULT;
+
+	return 0;
+}
+
+static int mxuport_ioctl(struct tty_struct *tty, unsigned int cmd,
+			 unsigned long arg)
+{
+	struct usb_serial_port *port = tty->driver_data;
+	void __user *argp = (void __user *)arg;
+
+	switch (cmd) {
+	case TIOCGRS485:
+		return mxuport_get_rs485_config(port, argp);
+	case TIOCSRS485:
+		return mxuport_set_rs485_config(port, argp);
+	}
+
+	return -ENOIOCTLCMD;
+}
+
 static int mxuport_set_termios_flow(struct tty_struct *tty,
 				    const struct ktermios *old_termios,
 				    struct usb_serial_port *port,
@@ -1503,6 +1598,7 @@ static struct usb_serial_driver mxuport_device = {
 	.set_termios		= mxuport_set_termios,
 	.break_ctl		= mxuport_break_ctl,
 	.tx_empty		= mxuport_tx_empty,
+	.ioctl			= mxuport_ioctl,
 	.tiocmiwait		= usb_serial_generic_tiocmiwait,
 	.get_icount		= usb_serial_generic_get_icount,
 	.throttle		= mxuport_throttle,
-- 
2.53.0

Re: [PATCH v3 0/6] USB: serial: mxuport: add MUX50U support and updates

[Crescent Hsieh]

Hi,

Just a gentle ping on this series. Any comments would be appreciated.

--
Thanks,
Crescent Hsieh

Re: [PATCH v3 0/6] USB: serial: mxuport: add MUX50U support and updates

[Johan Hovold]

On Thu, Sep 10, 2026 at 11:03:23AM +0800, Crescent Hsieh wrote:

> Just a gentle ping on this series. Any comments would be appreciated.

It's only been a bit more than a week since the merge window opened.
This one is still in my queue.

Johan

Re: [PATCH v3 0/6] USB: serial: mxuport: add MUX50U support and updates

[Johan Hovold]

On Thu, Sep 10, 2026 at 02:56:38PM +0200, Johan Hovold wrote:
> On Thu, Sep 10, 2026 at 11:03:23AM +0800, Crescent Hsieh wrote:
> 
> > Just a gentle ping on this series. Any comments would be appreciated.
> 
> It's only been a bit more than a week since the merge window opened.

s/opened/closed/

> This one is still in my queue.
 
Johan

Re: [PATCH v3 0/6] USB: serial: mxuport: add MUX50U support and updates

[Crescent Hsieh]

Hi Johan,

Just a gentle follow-up on this series, which was posted nearly two
months ago. I understand that it is still in your queue. Please let me
know if there is anything I can do to help with the review.

--
Thanks,
Crescent Hsieh

Re: [PATCH v3 0/6] USB: serial: mxuport: add MUX50U support and updates

[Johan Hovold]

On Mon, Oct 05, 2026 at 01:43:04PM +0800, Crescent Hsieh wrote:

> Just a gentle follow-up on this series, which was posted nearly two
> months ago. I understand that it is still in your queue. Please let me
> know if there is anything I can do to help with the review.

Yeah, sorry about the delay. Will try to look at it shortly but
probably not before next week due to conferences.

Johan