linux-usb.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
* [PATCH v4 0/2] IR driver for USB-UIRT device
@ 2021-06-10 10:16 Sean Young
  2021-06-10 10:16 ` [PATCH v4 1/2] media: rc: new " Sean Young
  2021-06-10 10:16 ` [PATCH v4 2/2] USB: serial: blacklist USB-UIRT when driver is selected Sean Young
  0 siblings, 2 replies; 9+ messages in thread
From: Sean Young @ 2021-06-10 10:16 UTC (permalink / raw)
  To: linux-media, linux-usb, Johan Hovold, Greg Kroah-Hartman,
	Jon Rhees, Oliver Neukum

This is a new rc-core driver for the USB-UIRT which you can see here
http://www.usbuirt.com/

This device is supported in lirc, via the usb serial kernel driver. This
driver is both for rc-core, which means it can use kernel/BPF decoding
ec. Also this implement is superior because it can:
 - support learning mode
 - setting transmit carrier
 - larger transmits using streaming tx command

Changes since v3:
 - Review comments from Johan Hovold
 - Do not move the ftdi_sio.h file an copy FTDI_* definitions instead

Changes since v2:
 - Fixed race condition is disconnect
 - Removed superfluous kmalloc in short tx

Changes since v1:
 - Review comments from Oliver Neukum
 - Simplified wideband read function

Sean Young (2):
  media: rc: new driver for USB-UIRT device
  USB: serial: blacklist USB-UIRT when driver is selected

 drivers/media/rc/Kconfig      |  11 +
 drivers/media/rc/Makefile     |   1 +
 drivers/media/rc/uirt.c       | 740 ++++++++++++++++++++++++++++++++++
 drivers/usb/serial/ftdi_sio.c |   6 +-
 4 files changed, 756 insertions(+), 2 deletions(-)
 create mode 100644 drivers/media/rc/uirt.c

-- 
2.31.1


^ permalink raw reply	[flat|nested] 9+ messages in thread

* [PATCH v4 1/2] media: rc: new driver for USB-UIRT device
  2021-06-10 10:16 [PATCH v4 0/2] IR driver for USB-UIRT device Sean Young
@ 2021-06-10 10:16 ` Sean Young
  2021-06-17 22:18   ` kernel test robot
  2021-06-10 10:16 ` [PATCH v4 2/2] USB: serial: blacklist USB-UIRT when driver is selected Sean Young
  1 sibling, 1 reply; 9+ messages in thread
From: Sean Young @ 2021-06-10 10:16 UTC (permalink / raw)
  To: linux-media, linux-usb, Johan Hovold, Greg Kroah-Hartman,
	Jon Rhees, Oliver Neukum

This device uses an ftdi usb serial port, so this driver has a tiny
amount of usb ftdi code. It would be preferable to connect this driver via
serdev or line-discipline, but unfortunately neither support
hotplugging yet.

See http://www.usbuirt.com/

Signed-off-by: Sean Young <sean@mess.org>
---
 drivers/media/rc/Kconfig  |  11 +
 drivers/media/rc/Makefile |   1 +
 drivers/media/rc/uirt.c   | 740 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 752 insertions(+)
 create mode 100644 drivers/media/rc/uirt.c

diff --git a/drivers/media/rc/Kconfig b/drivers/media/rc/Kconfig
index d0a8326b75c2..cb1a2c65f920 100644
--- a/drivers/media/rc/Kconfig
+++ b/drivers/media/rc/Kconfig
@@ -471,6 +471,17 @@ config IR_TOY
 	   To compile this driver as a module, choose M here: the module will be
 	   called ir_toy.
 
+config IR_UIRT
+	tristate "USB-UIRT"
+	depends on RC_CORE
+	depends on USB_ARCH_HAS_HCD
+	help
+	   Say Y here if you want to use the USB-UIRT. See
+	   http://www.usbuirt.com/
+
+	   To compile this driver as a module, choose M here: the module will be
+	   called uirt.
+
 endif #RC_DEVICES
 
 endif #RC_CORE
diff --git a/drivers/media/rc/Makefile b/drivers/media/rc/Makefile
index 692e9b6b203f..068036698747 100644
--- a/drivers/media/rc/Makefile
+++ b/drivers/media/rc/Makefile
@@ -50,3 +50,4 @@ obj-$(CONFIG_IR_SIR) += sir_ir.o
 obj-$(CONFIG_IR_MTK) += mtk-cir.o
 obj-$(CONFIG_RC_XBOX_DVD) += xbox_remote.o
 obj-$(CONFIG_IR_TOY) += ir_toy.o
+obj-$(CONFIG_IR_UIRT) += uirt.o
diff --git a/drivers/media/rc/uirt.c b/drivers/media/rc/uirt.c
new file mode 100644
index 000000000000..975cf464113e
--- /dev/null
+++ b/drivers/media/rc/uirt.c
@@ -0,0 +1,740 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+/*
+ * USB-UIRT
+ *
+ * Copyright (C) 2021 Sean Young <sean@mess.org>
+ *
+ * See http://www.usbuirt.com/USB-UIRT%20Command%20Protocol.doc
+ */
+
+#include <linux/completion.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/slab.h>
+#include <linux/usb/input.h>
+
+#include <media/rc-core.h>
+
+/* Copied from drivers/usb/serial/ftdi_sio.h */
+#define FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE 0x40
+#define FTDI_SIO_SET_BAUDRATE_REQUEST 3
+
+#define  FTDI_SIO_SET_LATENCY_TIMER_REQUEST FTDI_SIO_SET_LATENCY_TIMER
+#define  FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE 0x40
+
+#define FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE 0x40
+#define FTDI_SIO_SET_FLOW_CTRL_REQUEST FTDI_SIO_SET_FLOW_CTRL
+
+#define FTDI_SIO_SET_FLOW_CTRL		2 /* Set flow control register */
+#define FTDI_SIO_SET_LATENCY_TIMER	9 /* Set the latency timer */
+
+#define FTDI_SIO_RTS_CTS_HS	BIT(8)
+#define FTDI_RS0_CTS		BIT(4)
+
+static const u8 CMD_GETVERSION[] = { 0x23, 0xdd };
+static const u8 CMD_SETMODERAW[] = { 0x21, 0xdf };
+static const u8 CMD_SETWIDEBAND[] = { 0x24, 0xdc };
+
+#define UNIT_US 50
+#define IR_TIMEOUT 12500
+#define MAX_PACKET 64
+
+enum cmd_state {
+	CMD_STATE_GETVERSION,
+	CMD_STATE_SETMODERAW,
+	CMD_STATE_SETMODEWIDEBAND,
+	CMD_STATE_IRDATA,
+	CMD_STATE_DOTXRAW,
+	CMD_STATE_STREAMING_TX,
+};
+
+enum rx_state {
+	RX_STATE_INTERSPACE_HIGH,
+	RX_STATE_INTERSPACE_LOW,
+	RX_STATE_ON_HIGH,
+	RX_STATE_ON_LOW,
+	RX_STATE_FREQ_HIGH,
+	RX_STATE_FREQ_LOW,
+	RX_STATE_OFF_HIGH,
+	RX_STATE_OFF_LOW,
+};
+
+struct uirt {
+	struct device *dev;
+	struct usb_device *usbdev;
+
+	struct rc_dev *rc;
+	struct urb *urb_in, *urb_out;
+
+	u8 *in;
+	u8 *out;
+	struct completion cmd_done;
+	u8 freq;
+	u8 high;
+	bool wideband;
+	u32 last_duration;
+
+	enum cmd_state cmd_state;
+	enum rx_state rx_state;
+
+	void *tx_buf;
+	u32 tx_len;
+
+	char phys[64];
+};
+
+// read IR in raw mode
+static void uirt_raw_mode(struct uirt *uirt, u32 offset, u32 len)
+{
+	uint i, duration;
+
+	for (i = offset; i < len; i++) {
+		switch (uirt->rx_state) {
+		case RX_STATE_INTERSPACE_HIGH:
+			uirt->rx_state = RX_STATE_INTERSPACE_LOW;
+			break;
+		case RX_STATE_INTERSPACE_LOW:
+			uirt->rx_state = RX_STATE_ON_HIGH;
+			break;
+		case RX_STATE_ON_HIGH:
+			duration = uirt->in[i];
+			if (duration == 0)
+				duration = 1;
+
+			ir_raw_event_store(uirt->rc, &((struct ir_raw_event) {
+				.duration = duration * UNIT_US,
+				.pulse = true,
+			}));
+
+			uirt->rx_state = RX_STATE_OFF_HIGH;
+			break;
+		case RX_STATE_OFF_HIGH:
+			if (uirt->in[i] == 0xff) {
+				ir_raw_event_store(uirt->rc, &((struct ir_raw_event) {
+					.duration = IR_TIMEOUT,
+					.timeout = true,
+				}));
+				uirt->rx_state = RX_STATE_INTERSPACE_HIGH;
+				break;
+			}
+
+			duration = uirt->in[i];
+			if (duration == 0)
+				duration = 1;
+
+			ir_raw_event_store(uirt->rc, &((struct ir_raw_event) {
+				.duration = duration * UNIT_US,
+				.pulse = false,
+			}));
+			uirt->rx_state = RX_STATE_ON_HIGH;
+			break;
+		default:
+			WARN(1, "unreachable state");
+			uirt->rx_state = RX_STATE_INTERSPACE_HIGH;
+			break;
+		}
+	}
+
+	ir_raw_event_handle(uirt->rc);
+}
+
+// Read IR in wideband mode. The byte stream is delivered in packets,
+// and the values which come in two bytes may straddle two packets
+static void uirt_wideband(struct uirt *uirt, u32 offset, u32 len)
+{
+	uint i, duration, carrier, pulses;
+
+	for (i = offset; i < len; i++) {
+		switch (uirt->rx_state) {
+		case RX_STATE_INTERSPACE_HIGH:
+			uirt->rx_state = RX_STATE_INTERSPACE_LOW;
+			break;
+		case RX_STATE_INTERSPACE_LOW:
+			uirt->rx_state = RX_STATE_ON_HIGH;
+			break;
+		case RX_STATE_ON_HIGH:
+			uirt->high = uirt->in[i];
+			uirt->rx_state = RX_STATE_ON_LOW;
+			break;
+		case RX_STATE_ON_LOW:
+			// duration is in 400ns units
+			duration = (uirt->high << 8) | uirt->in[i];
+			if (duration < 3)
+				duration = 3;
+			uirt->last_duration = duration;
+			ir_raw_event_store(uirt->rc, &((struct ir_raw_event) {
+				.duration = DIV_ROUND_CLOSEST(duration * 2, 5),
+				.pulse = true,
+			}));
+			uirt->rx_state = RX_STATE_FREQ_HIGH;
+			break;
+		case RX_STATE_FREQ_HIGH:
+			if (uirt->in[i] & 0x80) {
+				uirt->high = uirt->in[i] & 0x7f;
+				uirt->rx_state = RX_STATE_FREQ_LOW;
+				break;
+			}
+
+			uirt->high = 0;
+			fallthrough;
+		case RX_STATE_FREQ_LOW:
+			pulses = (uirt->high << 8) | uirt->in[i];
+			if (pulses && uirt->last_duration) {
+				dev_dbg(uirt->dev, "carrier duration %u pulses %u",
+					uirt->last_duration, pulses);
+
+				// calculate the Hz of pulses in duration 400ns units
+				carrier = DIV_ROUND_CLOSEST_ULL(pulses * 10000000ull,
+								uirt->last_duration * 4);
+				ir_raw_event_store(uirt->rc, &((struct ir_raw_event) {
+					.carrier = carrier,
+					.carrier_report = true,
+				}));
+			}
+			uirt->rx_state = RX_STATE_OFF_HIGH;
+			break;
+		case RX_STATE_OFF_HIGH:
+			if (uirt->in[i] == 0xff) {
+				ir_raw_event_store(uirt->rc, &((struct ir_raw_event) {
+					.duration = IR_TIMEOUT,
+					.timeout = true,
+				}));
+				uirt->rx_state = RX_STATE_INTERSPACE_HIGH;
+			} else {
+				uirt->high = uirt->in[i];
+				uirt->rx_state = RX_STATE_OFF_LOW;
+			}
+			break;
+		case RX_STATE_OFF_LOW:
+			// duration is in 400ns units
+			duration = (uirt->high << 8) | uirt->in[i];
+			if (duration < 3)
+				duration = 3;
+			ir_raw_event_store(uirt->rc, &((struct ir_raw_event) {
+				.duration = DIV_ROUND_CLOSEST(duration * 2, 5),
+				.pulse = false,
+			}));
+			uirt->rx_state = RX_STATE_ON_HIGH;
+			break;
+		}
+	}
+
+	ir_raw_event_handle(uirt->rc);
+}
+
+static void uirt_response(struct uirt *uirt, u32 len)
+{
+	int offset = 2;
+	int i;
+
+	dev_dbg(uirt->dev, "state:%d data: %*phN\n", uirt->cmd_state, len, uirt->in);
+
+	// Do we have more IR to transmit
+	if (uirt->cmd_state == CMD_STATE_STREAMING_TX && len >= 2 &&
+	    uirt->tx_len && uirt->in[0] & FTDI_RS0_CTS) {
+		u32 len;
+		int err;
+
+		len = min_t(u32, uirt->tx_len, MAX_PACKET);
+
+		memcpy(uirt->out, uirt->tx_buf, len);
+		uirt->urb_out->transfer_buffer_length = len;
+
+		uirt->tx_len -= len;
+		uirt->tx_buf += len;
+
+		err = usb_submit_urb(uirt->urb_out, GFP_ATOMIC);
+		if (err != 0)
+			dev_warn(uirt->dev,
+				 "failed to submit out urb: %d\n", err);
+	}
+
+	// if we only have two bytes, it just gives us the serial line status
+	if (len <= 2)
+		return;
+
+	switch (uirt->cmd_state) {
+	case CMD_STATE_GETVERSION:
+		if (len >= 10) {
+			// check checksum
+			u8 checksum = 0;
+
+			for (i = 2; i < len; i++)
+				checksum += uirt->in[i];
+
+			if (checksum != 0) {
+				dev_err(uirt->dev, "checksum does not match: %*phN\n",
+					len, uirt->in);
+				return;
+			}
+
+			dev_info(uirt->dev,
+				 "USB-UIRT firmware v%u.%u protocol v%u.%u %02u-%02u-%04u",
+				 uirt->in[2], uirt->in[3], uirt->in[4],
+				 uirt->in[5], uirt->in[6], uirt->in[7],
+				 2000 + uirt->in[8]);
+
+			complete(&uirt->cmd_done);
+			uirt->cmd_state = CMD_STATE_IRDATA;
+			offset += 10;
+		}
+		break;
+	case CMD_STATE_DOTXRAW:
+	case CMD_STATE_STREAMING_TX:
+	case CMD_STATE_SETMODERAW:
+	case CMD_STATE_SETMODEWIDEBAND:
+		if (len >= 3) {
+			switch (uirt->in[2]) {
+			case 0x20:
+				// 0x20 transmitting is expected during streaming tx
+				if (uirt->cmd_state == CMD_STATE_STREAMING_TX)
+					return;
+
+				if (uirt->cmd_state == CMD_STATE_DOTXRAW)
+					complete(&uirt->cmd_done);
+				else
+					dev_err(uirt->dev, "device transmitting");
+				break;
+			case 0x21:
+				if (uirt->tx_len) {
+					dev_err(uirt->dev, "tx completed with %u left to send",
+						uirt->tx_len);
+				} else {
+					if (uirt->cmd_state == CMD_STATE_SETMODERAW)
+						uirt->wideband = false;
+					if (uirt->cmd_state == CMD_STATE_SETMODEWIDEBAND)
+						uirt->wideband = true;
+
+					complete(&uirt->cmd_done);
+				}
+				break;
+			case 0x80:
+				dev_err(uirt->dev, "checksum error");
+				break;
+			case 0x81:
+				dev_err(uirt->dev, "timeout");
+				break;
+			case 0x82:
+				dev_err(uirt->dev, "command error");
+				break;
+			default:
+				dev_err(uirt->dev, "unknown response");
+			}
+
+			uirt->cmd_state = CMD_STATE_IRDATA;
+			offset += 1;
+		}
+	default:
+		break;
+	}
+
+	if (uirt->wideband)
+		uirt_wideband(uirt, offset, len);
+	else
+		uirt_raw_mode(uirt, offset, len);
+}
+
+static void uirt_out_callback(struct urb *urb)
+{
+	struct uirt *uirt = urb->context;
+
+	switch (urb->status) {
+	case 0:
+	case -ECONNRESET:
+	case -ENOENT:
+	case -ESHUTDOWN:
+		return;
+	case -EPIPE:
+	default:
+		dev_warn(uirt->dev, "out urb status: %d\n", urb->status);
+		break;
+	}
+}
+
+static void uirt_in_callback(struct urb *urb)
+{
+	struct uirt *uirt = urb->context;
+	int ret;
+
+	if (urb->status == 0)
+		uirt_response(uirt, urb->actual_length);
+	else
+		dev_dbg(uirt->dev, "in urb status: %d\n", urb->status);
+
+	ret = usb_submit_urb(urb, GFP_ATOMIC);
+	if (ret && ret != -ENODEV)
+		dev_warn(uirt->dev, "failed to resubmit urb: %d\n", ret);
+}
+
+static int uirt_command(struct uirt *uirt, const u8 *cmd, u32 cmd_len,
+			enum cmd_state state)
+{
+	int err;
+
+	init_completion(&uirt->cmd_done);
+
+	uirt->cmd_state = state;
+
+	memcpy(uirt->out, cmd, cmd_len);
+	uirt->urb_out->transfer_buffer_length = cmd_len;
+
+	err = usb_submit_urb(uirt->urb_out, GFP_KERNEL);
+	if (err != 0) {
+		uirt->cmd_state = CMD_STATE_IRDATA;
+		return err;
+	}
+
+	if (!wait_for_completion_timeout(&uirt->cmd_done,
+					 msecs_to_jiffies(USB_CTRL_SET_TIMEOUT))) {
+		usb_kill_urb(uirt->urb_out);
+		uirt->cmd_state = CMD_STATE_IRDATA;
+		return -ETIMEDOUT;
+	}
+
+	return 0;
+}
+
+static int uirt_setup(struct uirt *uirt)
+{
+	int err;
+
+	err = uirt_command(uirt, CMD_SETMODERAW, sizeof(CMD_SETMODERAW),
+			   CMD_STATE_SETMODERAW);
+	if (err) {
+		dev_err(uirt->dev, "set mode raw command failed: %d\n",
+			err);
+		return err;
+	}
+
+	err = uirt_command(uirt, CMD_GETVERSION,
+			   sizeof(CMD_GETVERSION), CMD_STATE_GETVERSION);
+	if (err != 0)
+		dev_err(uirt->dev, "get version command failed: %d\n",
+			err);
+
+	return err;
+}
+
+// IR TX when the data can fit into a single packet (i.e 64 bytes).
+// count must be no larger than 24, else we might overflow the buffer.
+static int uirt_short_tx(struct rc_dev *rc, uint *txbuf, uint count)
+{
+	struct uirt *uirt = rc->priv;
+	u8 out[MAX_PACKET], checksum;
+	u32 i, dest, width, freq;
+	int err;
+
+	out[0] = 0x36; // DOTXRAW
+	out[2] = uirt->freq; // carrier frequency
+	out[3] = 1; // number of repeats
+
+	dest = 7;
+
+	freq = uirt->freq & 0x7f;
+
+	for (i = 0; i < count; i++) {
+		// width = (us / freq) * 2.5
+		width = DIV_ROUND_CLOSEST(txbuf[i] * 5, freq * 2);
+
+		if (width == 0)
+			width = 1;
+		else if (width > 127)
+			out[dest++] = (width >> 8) | 0x80;
+
+		out[dest++] = width;
+	}
+
+	// length of RAWSTRUCT + 1
+	out[1] = dest - 1;
+	// number of bytes in encoded pulse/space
+	out[6] = dest - 7;
+
+	// checksum
+	for (i = 0, checksum = 0; i < dest; i++)
+		checksum -= out[i];
+
+	out[dest++] = checksum;
+
+	uirt->tx_buf = NULL;
+	uirt->tx_len = 0;
+
+	err = uirt_command(uirt, out, dest, CMD_STATE_DOTXRAW);
+	if (err != 0)
+		return err;
+
+	return count;
+}
+
+static int uirt_tx(struct rc_dev *rc, uint *txbuf, uint count)
+{
+	struct uirt *uirt = rc->priv;
+	u8 *out;
+	u32 i, dest, unit_raw, freq, len;
+	int err;
+
+	// streaming tx does not work for short IR; use non-streaming
+	// tx for short IR
+	if (count <= 24)
+		return uirt_short_tx(rc, txbuf, count);
+
+	out = kmalloc(count * 2 + 3, GFP_KERNEL);
+	if (!out)
+		return -ENOMEM;
+
+	out[0] = 0x25; // Streaming Transmit
+	out[1] = 0xdb; // checksum over command (just the previous byte)
+	out[2] = uirt->freq; // carrier frequency
+
+	dest = 3;
+
+	freq = uirt->freq & 0x7f;
+
+	for (i = 0; i < count; i++) {
+		// width = (us / freq) * 2.5
+		unit_raw = DIV_ROUND_CLOSEST(txbuf[i] * 5, freq * 2);
+
+		if (unit_raw == 0)
+			unit_raw = 1;
+		else if (unit_raw > 127)
+			out[dest++] = (unit_raw >> 8) | 0x80;
+
+		out[dest++] = unit_raw;
+	}
+
+	len = min_t(u32, dest, MAX_PACKET);
+
+	uirt->tx_buf = out + len;
+	uirt->tx_len = dest - len;
+
+	err = uirt_command(uirt, out, len, CMD_STATE_STREAMING_TX);
+	kfree(out);
+	if (err != 0)
+		return err;
+
+	return count;
+}
+
+static int uirt_set_tx_carrier(struct rc_dev *dev, u32 carrier)
+{
+	struct uirt *uirt = dev->priv;
+
+	if (carrier == 0)
+		// bit 7 must be 1 for unmodulated, lower bits need to
+		// be something that makes sense for tx
+		uirt->freq = 0xc0;
+	else if (carrier >= 20000 && carrier <= 500000)
+		// bit 7 must be 0 for modulated
+		uirt->freq = 2500000 / carrier;
+	else
+		return -EINVAL;
+
+	return 0;
+}
+
+static int uirt_set_rx_wideband(struct rc_dev *dev, int enable)
+{
+	struct uirt *uirt = dev->priv;
+	int err;
+
+	if (enable)
+		err = uirt_command(uirt, CMD_SETWIDEBAND,
+				   sizeof(CMD_SETWIDEBAND),
+				   CMD_STATE_SETMODEWIDEBAND);
+	else
+		err = uirt_command(uirt, CMD_SETMODERAW,
+				   sizeof(CMD_SETMODERAW),
+				   CMD_STATE_SETMODERAW);
+
+	if (err) {
+		dev_err(uirt->dev, "set mode command failed: %d\n",
+			err);
+		return err;
+	}
+
+	return 0;
+}
+
+static int init_ftdi(struct usb_device *udev)
+{
+	int err;
+
+	// set the baud rate
+	err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+			      FTDI_SIO_SET_BAUDRATE_REQUEST,
+			      FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
+			      0x4009, 0x0001,
+			      NULL, 0, USB_CTRL_SET_TIMEOUT);
+	if (err)
+		return err;
+
+	// enabling rts/cts flow control
+	err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+			      FTDI_SIO_SET_FLOW_CTRL_REQUEST,
+			      FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
+			      0, FTDI_SIO_RTS_CTS_HS,
+			      NULL, 0, USB_CTRL_SET_TIMEOUT);
+	if (err)
+		return err;
+
+	// Set latency in milliseconds. The USB-UIRT will generate a
+	// urb every latency milliseconds (IR or not), so this should be
+	// set as high as possible to reduce interrupts. However, setting
+	// this value too high will mean there is a preceptible delay for
+	// IR being processed and a key press being registered.
+	//
+	// Choose 50ms as a compromise.
+	return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+			      FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
+			      FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
+			      50, 0,
+			      NULL, 0, USB_CTRL_SET_TIMEOUT);
+}
+
+static int uirt_probe(struct usb_interface *intf,
+		      const struct usb_device_id *id)
+{
+	struct usb_device *usbdev = interface_to_usbdev(intf);
+	struct usb_endpoint_descriptor *ep_in;
+	struct usb_endpoint_descriptor *ep_out;
+	struct uirt *uirt;
+	struct rc_dev *rc;
+	struct urb *urb;
+	int pipe, err;
+
+	if (usb_find_common_endpoints(intf->cur_altsetting, &ep_in, &ep_out, NULL, NULL) ||
+	    usb_endpoint_maxp(ep_in) != MAX_PACKET ||
+	    usb_endpoint_maxp(ep_out) != MAX_PACKET) {
+		dev_err(&intf->dev, "required endpoints not found\n");
+		return -ENODEV;
+	}
+
+	uirt = kzalloc(sizeof(*uirt), GFP_KERNEL);
+	if (!uirt)
+		return -ENOMEM;
+
+	uirt->in = kmalloc(MAX_PACKET, GFP_KERNEL);
+	if (!uirt->in)
+		goto free_uirt;
+
+	uirt->out = kmalloc(MAX_PACKET, GFP_KERNEL);
+	if (!uirt->out)
+		goto free_uirt;
+
+	rc = rc_allocate_device(RC_DRIVER_IR_RAW);
+	if (!rc)
+		goto free_uirt;
+
+	urb = usb_alloc_urb(0, GFP_KERNEL);
+	if (!urb)
+		goto free_rcdev;
+
+	pipe = usb_rcvbulkpipe(usbdev, ep_in->bEndpointAddress);
+	usb_fill_bulk_urb(urb, usbdev, pipe, uirt->in, MAX_PACKET,
+			  uirt_in_callback, uirt);
+	uirt->urb_in = urb;
+
+	urb = usb_alloc_urb(0, GFP_KERNEL);
+	if (!urb)
+		goto free_rcdev;
+
+	pipe = usb_sndbulkpipe(usbdev, ep_out->bEndpointAddress);
+	usb_fill_bulk_urb(urb, usbdev, pipe, uirt->out, MAX_PACKET,
+			  uirt_out_callback, uirt);
+
+	uirt->dev = &intf->dev;
+	uirt->usbdev = usbdev;
+	uirt->rc = rc;
+	uirt->urb_out = urb;
+	uirt->rx_state = RX_STATE_INTERSPACE_HIGH;
+
+	err = usb_submit_urb(uirt->urb_in, GFP_KERNEL);
+	if (err != 0) {
+		dev_err(uirt->dev, "failed to submit read urb: %d\n", err);
+		goto free_rcdev;
+	}
+
+	err = init_ftdi(usbdev);
+	if (err) {
+		dev_err(uirt->dev, "failed to setup ftdi: %d\n", err);
+		goto kill_urbs;
+	}
+
+	err = uirt_setup(uirt);
+	if (err)
+		goto kill_urbs;
+
+	usb_make_path(usbdev, uirt->phys, sizeof(uirt->phys));
+
+	rc->device_name = "USB-UIRT";
+	rc->driver_name = KBUILD_MODNAME;
+	rc->input_phys = uirt->phys;
+	usb_to_input_id(usbdev, &rc->input_id);
+	rc->dev.parent = &intf->dev;
+	rc->priv = uirt;
+	rc->tx_ir = uirt_tx;
+	rc->s_tx_carrier = uirt_set_tx_carrier;
+	rc->s_learning_mode = uirt_set_rx_wideband;
+	rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
+	rc->map_name = RC_MAP_RC6_MCE;
+	rc->rx_resolution = UNIT_US;
+	rc->timeout = IR_TIMEOUT;
+
+	uirt_set_tx_carrier(rc, 38000);
+
+	err = rc_register_device(rc);
+	if (err)
+		goto kill_urbs;
+
+	usb_set_intfdata(intf, uirt);
+
+	return 0;
+
+kill_urbs:
+	usb_kill_urb(uirt->urb_in);
+	usb_kill_urb(uirt->urb_out);
+free_rcdev:
+	usb_free_urb(uirt->urb_in);
+	usb_free_urb(uirt->urb_out);
+	rc_free_device(rc);
+free_uirt:
+	kfree(uirt->in);
+	kfree(uirt->out);
+	kfree(uirt);
+	return err;
+}
+
+static void uirt_disconnect(struct usb_interface *intf)
+{
+	struct uirt *ir = usb_get_intfdata(intf);
+
+	rc_unregister_device(ir->rc);
+	usb_set_intfdata(intf, NULL);
+	usb_kill_urb(ir->urb_in);
+	usb_kill_urb(ir->urb_out);
+	usb_free_urb(ir->urb_in);
+	usb_free_urb(ir->urb_out);
+	kfree(ir->in);
+	kfree(ir->out);
+	kfree(ir);
+}
+
+static const struct usb_device_id uirt_table[] = {
+	{ USB_DEVICE(0x0403, 0xf850) },
+	{ }
+};
+
+static struct usb_driver uirt_driver = {
+	.name = KBUILD_MODNAME,
+	.probe = uirt_probe,
+	.disconnect = uirt_disconnect,
+	.id_table = uirt_table,
+};
+
+module_usb_driver(uirt_driver);
+
+MODULE_AUTHOR("Sean Young <sean@mess.org>");
+MODULE_DESCRIPTION("USB-UIRT driver");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(usb, uirt_table);
-- 
2.31.1


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [PATCH v4 2/2] USB: serial: blacklist USB-UIRT when driver is selected
  2021-06-10 10:16 [PATCH v4 0/2] IR driver for USB-UIRT device Sean Young
  2021-06-10 10:16 ` [PATCH v4 1/2] media: rc: new " Sean Young
@ 2021-06-10 10:16 ` Sean Young
  2021-06-10 10:23   ` Greg Kroah-Hartman
  1 sibling, 1 reply; 9+ messages in thread
From: Sean Young @ 2021-06-10 10:16 UTC (permalink / raw)
  To: linux-media, linux-usb, Johan Hovold, Greg Kroah-Hartman,
	Jon Rhees, Oliver Neukum

The USB-UIRT device has its own driver, so blacklist the fdti driver
from using it if the driver has been enabled.

Signed-off-by: Sean Young <sean@mess.org>
---
 drivers/usb/serial/ftdi_sio.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 369ef140df78..2e9a9076a38d 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -106,7 +106,7 @@ static const struct ftdi_sio_quirk ftdi_NDI_device_quirk = {
 	.probe	= ftdi_NDI_device_setup,
 };
 
-static const struct ftdi_sio_quirk ftdi_USB_UIRT_quirk = {
+static __maybe_unused const struct ftdi_sio_quirk ftdi_USB_UIRT_quirk = {
 	.port_probe = ftdi_USB_UIRT_setup,
 };
 
@@ -568,8 +568,10 @@ static const struct usb_device_id id_table_combined[] = {
 	{ USB_DEVICE(OCT_VID, OCT_DK201_PID) },
 	{ USB_DEVICE(FTDI_VID, FTDI_HE_TIRA1_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_HE_TIRA1_quirk },
+#if !IS_ENABLED(CONFIG_IR_UIRT)
 	{ USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID),
 		.driver_info = (kernel_ulong_t)&ftdi_USB_UIRT_quirk },
+#endif
 	{ USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_1) },
 	{ USB_DEVICE(FTDI_VID, PROTEGO_R2X0) },
 	{ USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_3) },
@@ -2281,7 +2283,7 @@ static int ftdi_sio_port_probe(struct usb_serial_port *port)
 /* Setup for the USB-UIRT device, which requires hardwired
  * baudrate (38400 gets mapped to 312500) */
 /* Called from usbserial:serial_probe */
-static void ftdi_USB_UIRT_setup(struct ftdi_private *priv)
+static __maybe_unused void ftdi_USB_UIRT_setup(struct ftdi_private *priv)
 {
 	priv->flags |= ASYNC_SPD_CUST;
 	priv->custom_divisor = 77;
-- 
2.31.1


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* Re: [PATCH v4 2/2] USB: serial: blacklist USB-UIRT when driver is selected
  2021-06-10 10:16 ` [PATCH v4 2/2] USB: serial: blacklist USB-UIRT when driver is selected Sean Young
@ 2021-06-10 10:23   ` Greg Kroah-Hartman
  2021-06-10 10:34     ` Sean Young
  0 siblings, 1 reply; 9+ messages in thread
From: Greg Kroah-Hartman @ 2021-06-10 10:23 UTC (permalink / raw)
  To: Sean Young; +Cc: linux-media, linux-usb, Johan Hovold, Jon Rhees, Oliver Neukum

On Thu, Jun 10, 2021 at 11:16:25AM +0100, Sean Young wrote:
> The USB-UIRT device has its own driver, so blacklist the fdti driver
> from using it if the driver has been enabled.
> 
> Signed-off-by: Sean Young <sean@mess.org>
> ---
>  drivers/usb/serial/ftdi_sio.c | 6 ++++--
>  1 file changed, 4 insertions(+), 2 deletions(-)
> 
> diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
> index 369ef140df78..2e9a9076a38d 100644
> --- a/drivers/usb/serial/ftdi_sio.c
> +++ b/drivers/usb/serial/ftdi_sio.c
> @@ -106,7 +106,7 @@ static const struct ftdi_sio_quirk ftdi_NDI_device_quirk = {
>  	.probe	= ftdi_NDI_device_setup,
>  };
>  
> -static const struct ftdi_sio_quirk ftdi_USB_UIRT_quirk = {
> +static __maybe_unused const struct ftdi_sio_quirk ftdi_USB_UIRT_quirk = {

Why make this change?

>  	.port_probe = ftdi_USB_UIRT_setup,
>  };
>  
> @@ -568,8 +568,10 @@ static const struct usb_device_id id_table_combined[] = {
>  	{ USB_DEVICE(OCT_VID, OCT_DK201_PID) },
>  	{ USB_DEVICE(FTDI_VID, FTDI_HE_TIRA1_PID),
>  		.driver_info = (kernel_ulong_t)&ftdi_HE_TIRA1_quirk },
> +#if !IS_ENABLED(CONFIG_IR_UIRT)
>  	{ USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID),
>  		.driver_info = (kernel_ulong_t)&ftdi_USB_UIRT_quirk },
> +#endif
>  	{ USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_1) },
>  	{ USB_DEVICE(FTDI_VID, PROTEGO_R2X0) },
>  	{ USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_3) },
> @@ -2281,7 +2283,7 @@ static int ftdi_sio_port_probe(struct usb_serial_port *port)
>  /* Setup for the USB-UIRT device, which requires hardwired
>   * baudrate (38400 gets mapped to 312500) */
>  /* Called from usbserial:serial_probe */
> -static void ftdi_USB_UIRT_setup(struct ftdi_private *priv)
> +static __maybe_unused void ftdi_USB_UIRT_setup(struct ftdi_private *priv)

Again, why this change here?

thanks,

greg k-h

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: [PATCH v4 2/2] USB: serial: blacklist USB-UIRT when driver is selected
  2021-06-10 10:23   ` Greg Kroah-Hartman
@ 2021-06-10 10:34     ` Sean Young
  0 siblings, 0 replies; 9+ messages in thread
From: Sean Young @ 2021-06-10 10:34 UTC (permalink / raw)
  To: Greg Kroah-Hartman
  Cc: linux-media, linux-usb, Johan Hovold, Jon Rhees, Oliver Neukum

On Thu, Jun 10, 2021 at 12:23:53PM +0200, Greg Kroah-Hartman wrote:
> On Thu, Jun 10, 2021 at 11:16:25AM +0100, Sean Young wrote:
> > The USB-UIRT device has its own driver, so blacklist the fdti driver
> > from using it if the driver has been enabled.
> > 
> > Signed-off-by: Sean Young <sean@mess.org>
> > ---
> >  drivers/usb/serial/ftdi_sio.c | 6 ++++--
> >  1 file changed, 4 insertions(+), 2 deletions(-)
> > 
> > diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
> > index 369ef140df78..2e9a9076a38d 100644
> > --- a/drivers/usb/serial/ftdi_sio.c
> > +++ b/drivers/usb/serial/ftdi_sio.c
> > @@ -106,7 +106,7 @@ static const struct ftdi_sio_quirk ftdi_NDI_device_quirk = {
> >  	.probe	= ftdi_NDI_device_setup,
> >  };
> >  
> > -static const struct ftdi_sio_quirk ftdi_USB_UIRT_quirk = {
> > +static __maybe_unused const struct ftdi_sio_quirk ftdi_USB_UIRT_quirk = {
> 
> Why make this change?

If CONFIG_IR_UIRT is enabled, then this struct is not used. This generates
a warning when compiling with W=1 (clang or gcc):

  CC [M]  drivers/usb/serial/ftdi_sio.o
drivers/usb/serial/ftdi_sio.c:109:36: warning: ‘ftdi_USB_UIRT_quirk’ defined but not used [-Wunused-const-variable=]
  109 | static const struct ftdi_sio_quirk ftdi_USB_UIRT_quirk = {
      |                                    ^~~~~~~~~~~~~~~~~~~

> 
> >  	.port_probe = ftdi_USB_UIRT_setup,
> >  };
> >  
> > @@ -568,8 +568,10 @@ static const struct usb_device_id id_table_combined[] = {
> >  	{ USB_DEVICE(OCT_VID, OCT_DK201_PID) },
> >  	{ USB_DEVICE(FTDI_VID, FTDI_HE_TIRA1_PID),
> >  		.driver_info = (kernel_ulong_t)&ftdi_HE_TIRA1_quirk },
> > +#if !IS_ENABLED(CONFIG_IR_UIRT)
> >  	{ USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID),
> >  		.driver_info = (kernel_ulong_t)&ftdi_USB_UIRT_quirk },
> > +#endif
> >  	{ USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_1) },
> >  	{ USB_DEVICE(FTDI_VID, PROTEGO_R2X0) },
> >  	{ USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_3) },
> > @@ -2281,7 +2283,7 @@ static int ftdi_sio_port_probe(struct usb_serial_port *port)
> >  /* Setup for the USB-UIRT device, which requires hardwired
> >   * baudrate (38400 gets mapped to 312500) */
> >  /* Called from usbserial:serial_probe */
> > -static void ftdi_USB_UIRT_setup(struct ftdi_private *priv)
> > +static __maybe_unused void ftdi_USB_UIRT_setup(struct ftdi_private *priv)
> 
> Again, why this change here?

Same again.


Thanks for reviewing.

Sean

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: [PATCH v4 1/2] media: rc: new driver for USB-UIRT device
  2021-06-10 10:16 ` [PATCH v4 1/2] media: rc: new " Sean Young
@ 2021-06-17 22:18   ` kernel test robot
  2021-06-18  8:44     ` Sean Young
  0 siblings, 1 reply; 9+ messages in thread
From: kernel test robot @ 2021-06-17 22:18 UTC (permalink / raw)
  To: Sean Young, linux-media, linux-usb, Johan Hovold,
	Greg Kroah-Hartman, Jon Rhees, Oliver Neukum
  Cc: kbuild-all, clang-built-linux

[-- Attachment #1: Type: text/plain, Size: 8314 bytes --]

Hi Sean,

I love your patch! Perhaps something to improve:

[auto build test WARNING on linuxtv-media/master]
[also build test WARNING on usb-serial/usb-next usb/usb-testing peter.chen-usb/for-usb-next v5.13-rc6 next-20210617]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Sean-Young/IR-driver-for-USB-UIRT-device/20210616-182135
base:   git://linuxtv.org/media_tree.git master
config: powerpc64-randconfig-r012-20210617 (attached as .config)
compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 64720f57bea6a6bf033feef4a5751ab9c0c3b401)
reproduce (this is a W=1 build):
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # install powerpc64 cross compiling tool for clang build
        # apt-get install binutils-powerpc64-linux-gnu
        # https://github.com/0day-ci/linux/commit/17d3a0332baecb0359e05e8ae755478c7a1a4468
        git remote add linux-review https://github.com/0day-ci/linux
        git fetch --no-tags linux-review Sean-Young/IR-driver-for-USB-UIRT-device/20210616-182135
        git checkout 17d3a0332baecb0359e05e8ae755478c7a1a4468
        # save the attached .config to linux build tree
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=powerpc64 

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>

All warnings (new ones prefixed by >>):

   In file included from drivers/media/rc/uirt.c:11:
   In file included from include/linux/completion.h:12:
   In file included from include/linux/swait.h:5:
   In file included from include/linux/list.h:9:
   In file included from include/linux/kernel.h:12:
   In file included from include/linux/bitops.h:32:
   In file included from arch/powerpc/include/asm/bitops.h:62:
   arch/powerpc/include/asm/barrier.h:49:9: warning: '__lwsync' macro redefined [-Wmacro-redefined]
   #define __lwsync()      __asm__ __volatile__ (stringify_in_c(LWSYNC) : : :"memory")
           ^
   <built-in>:310:9: note: previous definition is here
   #define __lwsync __builtin_ppc_lwsync
           ^
>> drivers/media/rc/uirt.c:639:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
           if (!urb)
               ^~~~
   drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
           return err;
                  ^~~
   drivers/media/rc/uirt.c:639:2: note: remove the 'if' if its condition is always false
           if (!urb)
           ^~~~~~~~~
   drivers/media/rc/uirt.c:630:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
           if (!urb)
               ^~~~
   drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
           return err;
                  ^~~
   drivers/media/rc/uirt.c:630:2: note: remove the 'if' if its condition is always false
           if (!urb)
           ^~~~~~~~~
   drivers/media/rc/uirt.c:626:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
           if (!rc)
               ^~~
   drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
           return err;
                  ^~~
   drivers/media/rc/uirt.c:626:2: note: remove the 'if' if its condition is always false
           if (!rc)
           ^~~~~~~~
   drivers/media/rc/uirt.c:622:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
           if (!uirt->out)
               ^~~~~~~~~~
   drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
           return err;
                  ^~~
   drivers/media/rc/uirt.c:622:2: note: remove the 'if' if its condition is always false
           if (!uirt->out)
           ^~~~~~~~~~~~~~~
   drivers/media/rc/uirt.c:618:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
           if (!uirt->in)
               ^~~~~~~~~
   drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
           return err;
                  ^~~
   drivers/media/rc/uirt.c:618:2: note: remove the 'if' if its condition is always false
           if (!uirt->in)
           ^~~~~~~~~~~~~~
   drivers/media/rc/uirt.c:604:15: note: initialize the variable 'err' to silence this warning
           int pipe, err;
                        ^
                         = 0
   6 warnings generated.


vim +639 drivers/media/rc/uirt.c

   594	
   595	static int uirt_probe(struct usb_interface *intf,
   596			      const struct usb_device_id *id)
   597	{
   598		struct usb_device *usbdev = interface_to_usbdev(intf);
   599		struct usb_endpoint_descriptor *ep_in;
   600		struct usb_endpoint_descriptor *ep_out;
   601		struct uirt *uirt;
   602		struct rc_dev *rc;
   603		struct urb *urb;
   604		int pipe, err;
   605	
   606		if (usb_find_common_endpoints(intf->cur_altsetting, &ep_in, &ep_out, NULL, NULL) ||
   607		    usb_endpoint_maxp(ep_in) != MAX_PACKET ||
   608		    usb_endpoint_maxp(ep_out) != MAX_PACKET) {
   609			dev_err(&intf->dev, "required endpoints not found\n");
   610			return -ENODEV;
   611		}
   612	
   613		uirt = kzalloc(sizeof(*uirt), GFP_KERNEL);
   614		if (!uirt)
   615			return -ENOMEM;
   616	
   617		uirt->in = kmalloc(MAX_PACKET, GFP_KERNEL);
   618		if (!uirt->in)
   619			goto free_uirt;
   620	
   621		uirt->out = kmalloc(MAX_PACKET, GFP_KERNEL);
   622		if (!uirt->out)
   623			goto free_uirt;
   624	
   625		rc = rc_allocate_device(RC_DRIVER_IR_RAW);
   626		if (!rc)
   627			goto free_uirt;
   628	
   629		urb = usb_alloc_urb(0, GFP_KERNEL);
   630		if (!urb)
   631			goto free_rcdev;
   632	
   633		pipe = usb_rcvbulkpipe(usbdev, ep_in->bEndpointAddress);
   634		usb_fill_bulk_urb(urb, usbdev, pipe, uirt->in, MAX_PACKET,
   635				  uirt_in_callback, uirt);
   636		uirt->urb_in = urb;
   637	
   638		urb = usb_alloc_urb(0, GFP_KERNEL);
 > 639		if (!urb)
   640			goto free_rcdev;
   641	
   642		pipe = usb_sndbulkpipe(usbdev, ep_out->bEndpointAddress);
   643		usb_fill_bulk_urb(urb, usbdev, pipe, uirt->out, MAX_PACKET,
   644				  uirt_out_callback, uirt);
   645	
   646		uirt->dev = &intf->dev;
   647		uirt->usbdev = usbdev;
   648		uirt->rc = rc;
   649		uirt->urb_out = urb;
   650		uirt->rx_state = RX_STATE_INTERSPACE_HIGH;
   651	
   652		err = usb_submit_urb(uirt->urb_in, GFP_KERNEL);
   653		if (err != 0) {
   654			dev_err(uirt->dev, "failed to submit read urb: %d\n", err);
   655			goto free_rcdev;
   656		}
   657	
   658		err = init_ftdi(usbdev);
   659		if (err) {
   660			dev_err(uirt->dev, "failed to setup ftdi: %d\n", err);
   661			goto kill_urbs;
   662		}
   663	
   664		err = uirt_setup(uirt);
   665		if (err)
   666			goto kill_urbs;
   667	
   668		usb_make_path(usbdev, uirt->phys, sizeof(uirt->phys));
   669	
   670		rc->device_name = "USB-UIRT";
   671		rc->driver_name = KBUILD_MODNAME;
   672		rc->input_phys = uirt->phys;
   673		usb_to_input_id(usbdev, &rc->input_id);
   674		rc->dev.parent = &intf->dev;
   675		rc->priv = uirt;
   676		rc->tx_ir = uirt_tx;
   677		rc->s_tx_carrier = uirt_set_tx_carrier;
   678		rc->s_learning_mode = uirt_set_rx_wideband;
   679		rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
   680		rc->map_name = RC_MAP_RC6_MCE;
   681		rc->rx_resolution = UNIT_US;
   682		rc->timeout = IR_TIMEOUT;
   683	
   684		uirt_set_tx_carrier(rc, 38000);
   685	
   686		err = rc_register_device(rc);
   687		if (err)
   688			goto kill_urbs;
   689	
   690		usb_set_intfdata(intf, uirt);
   691	
   692		return 0;
   693	
   694	kill_urbs:
   695		usb_kill_urb(uirt->urb_in);
   696		usb_kill_urb(uirt->urb_out);
   697	free_rcdev:
   698		usb_free_urb(uirt->urb_in);
   699		usb_free_urb(uirt->urb_out);
   700		rc_free_device(rc);
   701	free_uirt:
   702		kfree(uirt->in);
   703		kfree(uirt->out);
   704		kfree(uirt);
   705		return err;
   706	}
   707	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 46994 bytes --]

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: [PATCH v4 1/2] media: rc: new driver for USB-UIRT device
  2021-06-17 22:18   ` kernel test robot
@ 2021-06-18  8:44     ` Sean Young
  2021-06-18 17:04       ` Nathan Chancellor
  0 siblings, 1 reply; 9+ messages in thread
From: Sean Young @ 2021-06-18  8:44 UTC (permalink / raw)
  To: kernel test robot
  Cc: linux-media, linux-usb, Johan Hovold, Greg Kroah-Hartman,
	Jon Rhees, Oliver Neukum, kbuild-all, clang-built-linux

On Fri, Jun 18, 2021 at 06:18:06AM +0800, kernel test robot wrote:
> Hi Sean,
> 
> I love your patch! Perhaps something to improve:
> 
> [auto build test WARNING on linuxtv-media/master]
> [also build test WARNING on usb-serial/usb-next usb/usb-testing peter.chen-usb/for-usb-next v5.13-rc6 next-20210617]
> [If your patch is applied to the wrong git tree, kindly drop us a note.
> And when submitting patch, we suggest to use '--base' as documented in
> https://git-scm.com/docs/git-format-patch]
> 
> url:    https://github.com/0day-ci/linux/commits/Sean-Young/IR-driver-for-USB-UIRT-device/20210616-182135
> base:   git://linuxtv.org/media_tree.git master
> config: powerpc64-randconfig-r012-20210617 (attached as .config)
> compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 64720f57bea6a6bf033feef4a5751ab9c0c3b401)
> reproduce (this is a W=1 build):
>         wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
>         chmod +x ~/bin/make.cross
>         # install powerpc64 cross compiling tool for clang build
>         # apt-get install binutils-powerpc64-linux-gnu
>         # https://github.com/0day-ci/linux/commit/17d3a0332baecb0359e05e8ae755478c7a1a4468
>         git remote add linux-review https://github.com/0day-ci/linux
>         git fetch --no-tags linux-review Sean-Young/IR-driver-for-USB-UIRT-device/20210616-182135
>         git checkout 17d3a0332baecb0359e05e8ae755478c7a1a4468
>         # save the attached .config to linux build tree
>         COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=powerpc64 
> 
> If you fix the issue, kindly add following tag as appropriate
> Reported-by: kernel test robot <lkp@intel.com>
> 
> All warnings (new ones prefixed by >>):
> 
>    In file included from drivers/media/rc/uirt.c:11:
>    In file included from include/linux/completion.h:12:
>    In file included from include/linux/swait.h:5:
>    In file included from include/linux/list.h:9:
>    In file included from include/linux/kernel.h:12:
>    In file included from include/linux/bitops.h:32:
>    In file included from arch/powerpc/include/asm/bitops.h:62:
>    arch/powerpc/include/asm/barrier.h:49:9: warning: '__lwsync' macro redefined [-Wmacro-redefined]
>    #define __lwsync()      __asm__ __volatile__ (stringify_in_c(LWSYNC) : : :"memory")
>            ^
>    <built-in>:310:9: note: previous definition is here
>    #define __lwsync __builtin_ppc_lwsync
>            ^
> >> drivers/media/rc/uirt.c:639:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
>            if (!urb)
>                ^~~~
>    drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
>            return err;

This is interesting. clang is right here, there are error paths where err is
not initialized. gcc-11.1 does not pick this up for some reason. The error path
should be an immediate dominator so it shouldn't be complicated to detect.

I'll send out a v5 with this issue fixed.

Sean

>                   ^~~
>    drivers/media/rc/uirt.c:639:2: note: remove the 'if' if its condition is always false
>            if (!urb)
>            ^~~~~~~~~
>    drivers/media/rc/uirt.c:630:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
>            if (!urb)
>                ^~~~
>    drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
>            return err;
>                   ^~~
>    drivers/media/rc/uirt.c:630:2: note: remove the 'if' if its condition is always false
>            if (!urb)
>            ^~~~~~~~~
>    drivers/media/rc/uirt.c:626:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
>            if (!rc)
>                ^~~
>    drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
>            return err;
>                   ^~~
>    drivers/media/rc/uirt.c:626:2: note: remove the 'if' if its condition is always false
>            if (!rc)
>            ^~~~~~~~
>    drivers/media/rc/uirt.c:622:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
>            if (!uirt->out)
>                ^~~~~~~~~~
>    drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
>            return err;
>                   ^~~
>    drivers/media/rc/uirt.c:622:2: note: remove the 'if' if its condition is always false
>            if (!uirt->out)
>            ^~~~~~~~~~~~~~~
>    drivers/media/rc/uirt.c:618:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
>            if (!uirt->in)
>                ^~~~~~~~~
>    drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
>            return err;
>                   ^~~
>    drivers/media/rc/uirt.c:618:2: note: remove the 'if' if its condition is always false
>            if (!uirt->in)
>            ^~~~~~~~~~~~~~
>    drivers/media/rc/uirt.c:604:15: note: initialize the variable 'err' to silence this warning
>            int pipe, err;
>                         ^
>                          = 0
>    6 warnings generated.
> 
> 
> vim +639 drivers/media/rc/uirt.c
> 
>    594	
>    595	static int uirt_probe(struct usb_interface *intf,
>    596			      const struct usb_device_id *id)
>    597	{
>    598		struct usb_device *usbdev = interface_to_usbdev(intf);
>    599		struct usb_endpoint_descriptor *ep_in;
>    600		struct usb_endpoint_descriptor *ep_out;
>    601		struct uirt *uirt;
>    602		struct rc_dev *rc;
>    603		struct urb *urb;
>    604		int pipe, err;
>    605	
>    606		if (usb_find_common_endpoints(intf->cur_altsetting, &ep_in, &ep_out, NULL, NULL) ||
>    607		    usb_endpoint_maxp(ep_in) != MAX_PACKET ||
>    608		    usb_endpoint_maxp(ep_out) != MAX_PACKET) {
>    609			dev_err(&intf->dev, "required endpoints not found\n");
>    610			return -ENODEV;
>    611		}
>    612	
>    613		uirt = kzalloc(sizeof(*uirt), GFP_KERNEL);
>    614		if (!uirt)
>    615			return -ENOMEM;
>    616	
>    617		uirt->in = kmalloc(MAX_PACKET, GFP_KERNEL);
>    618		if (!uirt->in)
>    619			goto free_uirt;
>    620	
>    621		uirt->out = kmalloc(MAX_PACKET, GFP_KERNEL);
>    622		if (!uirt->out)
>    623			goto free_uirt;
>    624	
>    625		rc = rc_allocate_device(RC_DRIVER_IR_RAW);
>    626		if (!rc)
>    627			goto free_uirt;
>    628	
>    629		urb = usb_alloc_urb(0, GFP_KERNEL);
>    630		if (!urb)
>    631			goto free_rcdev;
>    632	
>    633		pipe = usb_rcvbulkpipe(usbdev, ep_in->bEndpointAddress);
>    634		usb_fill_bulk_urb(urb, usbdev, pipe, uirt->in, MAX_PACKET,
>    635				  uirt_in_callback, uirt);
>    636		uirt->urb_in = urb;
>    637	
>    638		urb = usb_alloc_urb(0, GFP_KERNEL);
>  > 639		if (!urb)
>    640			goto free_rcdev;
>    641	
>    642		pipe = usb_sndbulkpipe(usbdev, ep_out->bEndpointAddress);
>    643		usb_fill_bulk_urb(urb, usbdev, pipe, uirt->out, MAX_PACKET,
>    644				  uirt_out_callback, uirt);
>    645	
>    646		uirt->dev = &intf->dev;
>    647		uirt->usbdev = usbdev;
>    648		uirt->rc = rc;
>    649		uirt->urb_out = urb;
>    650		uirt->rx_state = RX_STATE_INTERSPACE_HIGH;
>    651	
>    652		err = usb_submit_urb(uirt->urb_in, GFP_KERNEL);
>    653		if (err != 0) {
>    654			dev_err(uirt->dev, "failed to submit read urb: %d\n", err);
>    655			goto free_rcdev;
>    656		}
>    657	
>    658		err = init_ftdi(usbdev);
>    659		if (err) {
>    660			dev_err(uirt->dev, "failed to setup ftdi: %d\n", err);
>    661			goto kill_urbs;
>    662		}
>    663	
>    664		err = uirt_setup(uirt);
>    665		if (err)
>    666			goto kill_urbs;
>    667	
>    668		usb_make_path(usbdev, uirt->phys, sizeof(uirt->phys));
>    669	
>    670		rc->device_name = "USB-UIRT";
>    671		rc->driver_name = KBUILD_MODNAME;
>    672		rc->input_phys = uirt->phys;
>    673		usb_to_input_id(usbdev, &rc->input_id);
>    674		rc->dev.parent = &intf->dev;
>    675		rc->priv = uirt;
>    676		rc->tx_ir = uirt_tx;
>    677		rc->s_tx_carrier = uirt_set_tx_carrier;
>    678		rc->s_learning_mode = uirt_set_rx_wideband;
>    679		rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
>    680		rc->map_name = RC_MAP_RC6_MCE;
>    681		rc->rx_resolution = UNIT_US;
>    682		rc->timeout = IR_TIMEOUT;
>    683	
>    684		uirt_set_tx_carrier(rc, 38000);
>    685	
>    686		err = rc_register_device(rc);
>    687		if (err)
>    688			goto kill_urbs;
>    689	
>    690		usb_set_intfdata(intf, uirt);
>    691	
>    692		return 0;
>    693	
>    694	kill_urbs:
>    695		usb_kill_urb(uirt->urb_in);
>    696		usb_kill_urb(uirt->urb_out);
>    697	free_rcdev:
>    698		usb_free_urb(uirt->urb_in);
>    699		usb_free_urb(uirt->urb_out);
>    700		rc_free_device(rc);
>    701	free_uirt:
>    702		kfree(uirt->in);
>    703		kfree(uirt->out);
>    704		kfree(uirt);
>    705		return err;
>    706	}
>    707	
> 
> ---
> 0-DAY CI Kernel Test Service, Intel Corporation
> https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org



^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: [PATCH v4 1/2] media: rc: new driver for USB-UIRT device
  2021-06-18  8:44     ` Sean Young
@ 2021-06-18 17:04       ` Nathan Chancellor
  2021-06-18 21:19         ` Sean Young
  0 siblings, 1 reply; 9+ messages in thread
From: Nathan Chancellor @ 2021-06-18 17:04 UTC (permalink / raw)
  To: Sean Young, kernel test robot
  Cc: linux-media, linux-usb, Johan Hovold, Greg Kroah-Hartman,
	Jon Rhees, Oliver Neukum, kbuild-all, clang-built-linux

On 6/18/2021 1:44 AM, Sean Young wrote:
> On Fri, Jun 18, 2021 at 06:18:06AM +0800, kernel test robot wrote:
>> Hi Sean,
>>
>> I love your patch! Perhaps something to improve:
>>
>> [auto build test WARNING on linuxtv-media/master]
>> [also build test WARNING on usb-serial/usb-next usb/usb-testing peter.chen-usb/for-usb-next v5.13-rc6 next-20210617]
>> [If your patch is applied to the wrong git tree, kindly drop us a note.
>> And when submitting patch, we suggest to use '--base' as documented in
>> https://git-scm.com/docs/git-format-patch]
>>
>> url:    https://github.com/0day-ci/linux/commits/Sean-Young/IR-driver-for-USB-UIRT-device/20210616-182135
>> base:   git://linuxtv.org/media_tree.git master
>> config: powerpc64-randconfig-r012-20210617 (attached as .config)
>> compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 64720f57bea6a6bf033feef4a5751ab9c0c3b401)
>> reproduce (this is a W=1 build):
>>          wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
>>          chmod +x ~/bin/make.cross
>>          # install powerpc64 cross compiling tool for clang build
>>          # apt-get install binutils-powerpc64-linux-gnu
>>          # https://github.com/0day-ci/linux/commit/17d3a0332baecb0359e05e8ae755478c7a1a4468
>>          git remote add linux-review https://github.com/0day-ci/linux
>>          git fetch --no-tags linux-review Sean-Young/IR-driver-for-USB-UIRT-device/20210616-182135
>>          git checkout 17d3a0332baecb0359e05e8ae755478c7a1a4468
>>          # save the attached .config to linux build tree
>>          COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=powerpc64
>>
>> If you fix the issue, kindly add following tag as appropriate
>> Reported-by: kernel test robot <lkp@intel.com>
>>
>> All warnings (new ones prefixed by >>):
>>
>>     In file included from drivers/media/rc/uirt.c:11:
>>     In file included from include/linux/completion.h:12:
>>     In file included from include/linux/swait.h:5:
>>     In file included from include/linux/list.h:9:
>>     In file included from include/linux/kernel.h:12:
>>     In file included from include/linux/bitops.h:32:
>>     In file included from arch/powerpc/include/asm/bitops.h:62:
>>     arch/powerpc/include/asm/barrier.h:49:9: warning: '__lwsync' macro redefined [-Wmacro-redefined]
>>     #define __lwsync()      __asm__ __volatile__ (stringify_in_c(LWSYNC) : : :"memory")
>>             ^
>>     <built-in>:310:9: note: previous definition is here
>>     #define __lwsync __builtin_ppc_lwsync
>>             ^
>>>> drivers/media/rc/uirt.c:639:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
>>             if (!urb)
>>                 ^~~~
>>     drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
>>             return err;
> 
> This is interesting. clang is right here, there are error paths where err is
> not initialized. gcc-11.1 does not pick this up for some reason. The error path
> should be an immediate dominator so it shouldn't be complicated to detect.

The reason GCC does not warn about this is due to commit 78a5255ffb6a 
("Stop the ad-hoc games with -Wno-maybe-initialized"), which disables 
the GCC version of this warning except with W=2, which very few people 
use. You could use 'KCFLAGS=-Wmaybe-uninitialized' to try and see the 
same warning.

Cheers,
Nathan

> I'll send out a v5 with this issue fixed.
> 
> Sean
> 
>>                    ^~~
>>     drivers/media/rc/uirt.c:639:2: note: remove the 'if' if its condition is always false
>>             if (!urb)
>>             ^~~~~~~~~
>>     drivers/media/rc/uirt.c:630:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
>>             if (!urb)
>>                 ^~~~
>>     drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
>>             return err;
>>                    ^~~
>>     drivers/media/rc/uirt.c:630:2: note: remove the 'if' if its condition is always false
>>             if (!urb)
>>             ^~~~~~~~~
>>     drivers/media/rc/uirt.c:626:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
>>             if (!rc)
>>                 ^~~
>>     drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
>>             return err;
>>                    ^~~
>>     drivers/media/rc/uirt.c:626:2: note: remove the 'if' if its condition is always false
>>             if (!rc)
>>             ^~~~~~~~
>>     drivers/media/rc/uirt.c:622:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
>>             if (!uirt->out)
>>                 ^~~~~~~~~~
>>     drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
>>             return err;
>>                    ^~~
>>     drivers/media/rc/uirt.c:622:2: note: remove the 'if' if its condition is always false
>>             if (!uirt->out)
>>             ^~~~~~~~~~~~~~~
>>     drivers/media/rc/uirt.c:618:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
>>             if (!uirt->in)
>>                 ^~~~~~~~~
>>     drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
>>             return err;
>>                    ^~~
>>     drivers/media/rc/uirt.c:618:2: note: remove the 'if' if its condition is always false
>>             if (!uirt->in)
>>             ^~~~~~~~~~~~~~
>>     drivers/media/rc/uirt.c:604:15: note: initialize the variable 'err' to silence this warning
>>             int pipe, err;
>>                          ^
>>                           = 0
>>     6 warnings generated.
>>
>>
>> vim +639 drivers/media/rc/uirt.c
>>
>>     594	
>>     595	static int uirt_probe(struct usb_interface *intf,
>>     596			      const struct usb_device_id *id)
>>     597	{
>>     598		struct usb_device *usbdev = interface_to_usbdev(intf);
>>     599		struct usb_endpoint_descriptor *ep_in;
>>     600		struct usb_endpoint_descriptor *ep_out;
>>     601		struct uirt *uirt;
>>     602		struct rc_dev *rc;
>>     603		struct urb *urb;
>>     604		int pipe, err;
>>     605	
>>     606		if (usb_find_common_endpoints(intf->cur_altsetting, &ep_in, &ep_out, NULL, NULL) ||
>>     607		    usb_endpoint_maxp(ep_in) != MAX_PACKET ||
>>     608		    usb_endpoint_maxp(ep_out) != MAX_PACKET) {
>>     609			dev_err(&intf->dev, "required endpoints not found\n");
>>     610			return -ENODEV;
>>     611		}
>>     612	
>>     613		uirt = kzalloc(sizeof(*uirt), GFP_KERNEL);
>>     614		if (!uirt)
>>     615			return -ENOMEM;
>>     616	
>>     617		uirt->in = kmalloc(MAX_PACKET, GFP_KERNEL);
>>     618		if (!uirt->in)
>>     619			goto free_uirt;
>>     620	
>>     621		uirt->out = kmalloc(MAX_PACKET, GFP_KERNEL);
>>     622		if (!uirt->out)
>>     623			goto free_uirt;
>>     624	
>>     625		rc = rc_allocate_device(RC_DRIVER_IR_RAW);
>>     626		if (!rc)
>>     627			goto free_uirt;
>>     628	
>>     629		urb = usb_alloc_urb(0, GFP_KERNEL);
>>     630		if (!urb)
>>     631			goto free_rcdev;
>>     632	
>>     633		pipe = usb_rcvbulkpipe(usbdev, ep_in->bEndpointAddress);
>>     634		usb_fill_bulk_urb(urb, usbdev, pipe, uirt->in, MAX_PACKET,
>>     635				  uirt_in_callback, uirt);
>>     636		uirt->urb_in = urb;
>>     637	
>>     638		urb = usb_alloc_urb(0, GFP_KERNEL);
>>   > 639		if (!urb)
>>     640			goto free_rcdev;
>>     641	
>>     642		pipe = usb_sndbulkpipe(usbdev, ep_out->bEndpointAddress);
>>     643		usb_fill_bulk_urb(urb, usbdev, pipe, uirt->out, MAX_PACKET,
>>     644				  uirt_out_callback, uirt);
>>     645	
>>     646		uirt->dev = &intf->dev;
>>     647		uirt->usbdev = usbdev;
>>     648		uirt->rc = rc;
>>     649		uirt->urb_out = urb;
>>     650		uirt->rx_state = RX_STATE_INTERSPACE_HIGH;
>>     651	
>>     652		err = usb_submit_urb(uirt->urb_in, GFP_KERNEL);
>>     653		if (err != 0) {
>>     654			dev_err(uirt->dev, "failed to submit read urb: %d\n", err);
>>     655			goto free_rcdev;
>>     656		}
>>     657	
>>     658		err = init_ftdi(usbdev);
>>     659		if (err) {
>>     660			dev_err(uirt->dev, "failed to setup ftdi: %d\n", err);
>>     661			goto kill_urbs;
>>     662		}
>>     663	
>>     664		err = uirt_setup(uirt);
>>     665		if (err)
>>     666			goto kill_urbs;
>>     667	
>>     668		usb_make_path(usbdev, uirt->phys, sizeof(uirt->phys));
>>     669	
>>     670		rc->device_name = "USB-UIRT";
>>     671		rc->driver_name = KBUILD_MODNAME;
>>     672		rc->input_phys = uirt->phys;
>>     673		usb_to_input_id(usbdev, &rc->input_id);
>>     674		rc->dev.parent = &intf->dev;
>>     675		rc->priv = uirt;
>>     676		rc->tx_ir = uirt_tx;
>>     677		rc->s_tx_carrier = uirt_set_tx_carrier;
>>     678		rc->s_learning_mode = uirt_set_rx_wideband;
>>     679		rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
>>     680		rc->map_name = RC_MAP_RC6_MCE;
>>     681		rc->rx_resolution = UNIT_US;
>>     682		rc->timeout = IR_TIMEOUT;
>>     683	
>>     684		uirt_set_tx_carrier(rc, 38000);
>>     685	
>>     686		err = rc_register_device(rc);
>>     687		if (err)
>>     688			goto kill_urbs;
>>     689	
>>     690		usb_set_intfdata(intf, uirt);
>>     691	
>>     692		return 0;
>>     693	
>>     694	kill_urbs:
>>     695		usb_kill_urb(uirt->urb_in);
>>     696		usb_kill_urb(uirt->urb_out);
>>     697	free_rcdev:
>>     698		usb_free_urb(uirt->urb_in);
>>     699		usb_free_urb(uirt->urb_out);
>>     700		rc_free_device(rc);
>>     701	free_uirt:
>>     702		kfree(uirt->in);
>>     703		kfree(uirt->out);
>>     704		kfree(uirt);
>>     705		return err;
>>     706	}
>>     707	
>>
>> ---
>> 0-DAY CI Kernel Test Service, Intel Corporation
>> https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
> 
> 


^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: [PATCH v4 1/2] media: rc: new driver for USB-UIRT device
  2021-06-18 17:04       ` Nathan Chancellor
@ 2021-06-18 21:19         ` Sean Young
  0 siblings, 0 replies; 9+ messages in thread
From: Sean Young @ 2021-06-18 21:19 UTC (permalink / raw)
  To: Nathan Chancellor
  Cc: kernel test robot, linux-media, linux-usb, Johan Hovold,
	Greg Kroah-Hartman, Jon Rhees, Oliver Neukum, kbuild-all,
	clang-built-linux

On Fri, Jun 18, 2021 at 10:04:58AM -0700, Nathan Chancellor wrote:
> On 6/18/2021 1:44 AM, Sean Young wrote:
> > On Fri, Jun 18, 2021 at 06:18:06AM +0800, kernel test robot wrote:
> > > Hi Sean,
> > > 
> > > I love your patch! Perhaps something to improve:
> > > 
> > > [auto build test WARNING on linuxtv-media/master]
> > > [also build test WARNING on usb-serial/usb-next usb/usb-testing peter.chen-usb/for-usb-next v5.13-rc6 next-20210617]
> > > [If your patch is applied to the wrong git tree, kindly drop us a note.
> > > And when submitting patch, we suggest to use '--base' as documented in
> > > https://git-scm.com/docs/git-format-patch]
> > > 
> > > url:    https://github.com/0day-ci/linux/commits/Sean-Young/IR-driver-for-USB-UIRT-device/20210616-182135
> > > base:   git://linuxtv.org/media_tree.git master
> > > config: powerpc64-randconfig-r012-20210617 (attached as .config)
> > > compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 64720f57bea6a6bf033feef4a5751ab9c0c3b401)
> > > reproduce (this is a W=1 build):
> > >          wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
> > >          chmod +x ~/bin/make.cross
> > >          # install powerpc64 cross compiling tool for clang build
> > >          # apt-get install binutils-powerpc64-linux-gnu
> > >          # https://github.com/0day-ci/linux/commit/17d3a0332baecb0359e05e8ae755478c7a1a4468
> > >          git remote add linux-review https://github.com/0day-ci/linux
> > >          git fetch --no-tags linux-review Sean-Young/IR-driver-for-USB-UIRT-device/20210616-182135
> > >          git checkout 17d3a0332baecb0359e05e8ae755478c7a1a4468
> > >          # save the attached .config to linux build tree
> > >          COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=powerpc64
> > > 
> > > If you fix the issue, kindly add following tag as appropriate
> > > Reported-by: kernel test robot <lkp@intel.com>
> > > 
> > > All warnings (new ones prefixed by >>):
> > > 
> > >     In file included from drivers/media/rc/uirt.c:11:
> > >     In file included from include/linux/completion.h:12:
> > >     In file included from include/linux/swait.h:5:
> > >     In file included from include/linux/list.h:9:
> > >     In file included from include/linux/kernel.h:12:
> > >     In file included from include/linux/bitops.h:32:
> > >     In file included from arch/powerpc/include/asm/bitops.h:62:
> > >     arch/powerpc/include/asm/barrier.h:49:9: warning: '__lwsync' macro redefined [-Wmacro-redefined]
> > >     #define __lwsync()      __asm__ __volatile__ (stringify_in_c(LWSYNC) : : :"memory")
> > >             ^
> > >     <built-in>:310:9: note: previous definition is here
> > >     #define __lwsync __builtin_ppc_lwsync
> > >             ^
> > > > > drivers/media/rc/uirt.c:639:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
> > >             if (!urb)
> > >                 ^~~~
> > >     drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
> > >             return err;
> > 
> > This is interesting. clang is right here, there are error paths where err is
> > not initialized. gcc-11.1 does not pick this up for some reason. The error path
> > should be an immediate dominator so it shouldn't be complicated to detect.
> 
> The reason GCC does not warn about this is due to commit 78a5255ffb6a ("Stop
> the ad-hoc games with -Wno-maybe-initialized"), which disables the GCC
> version of this warning except with W=2, which very few people use. You
> could use 'KCFLAGS=-Wmaybe-uninitialized' to try and see the same warning.

You're right, this is exactly the issue here.  When running with W=2 or
KCFLAGS=-Wmaybe-uninitialized you do get the warning.

There are paths where err are initialized, so gcc correctly says:

warning: ‘err’ may be used uninitialized in this function [-Wmaybe-uninitialized]


Thanks,

Sean

> 
> Cheers,
> Nathan
> 
> > I'll send out a v5 with this issue fixed.
> > 
> > Sean
> > 
> > >                    ^~~
> > >     drivers/media/rc/uirt.c:639:2: note: remove the 'if' if its condition is always false
> > >             if (!urb)
> > >             ^~~~~~~~~
> > >     drivers/media/rc/uirt.c:630:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
> > >             if (!urb)
> > >                 ^~~~
> > >     drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
> > >             return err;
> > >                    ^~~
> > >     drivers/media/rc/uirt.c:630:2: note: remove the 'if' if its condition is always false
> > >             if (!urb)
> > >             ^~~~~~~~~
> > >     drivers/media/rc/uirt.c:626:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
> > >             if (!rc)
> > >                 ^~~
> > >     drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
> > >             return err;
> > >                    ^~~
> > >     drivers/media/rc/uirt.c:626:2: note: remove the 'if' if its condition is always false
> > >             if (!rc)
> > >             ^~~~~~~~
> > >     drivers/media/rc/uirt.c:622:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
> > >             if (!uirt->out)
> > >                 ^~~~~~~~~~
> > >     drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
> > >             return err;
> > >                    ^~~
> > >     drivers/media/rc/uirt.c:622:2: note: remove the 'if' if its condition is always false
> > >             if (!uirt->out)
> > >             ^~~~~~~~~~~~~~~
> > >     drivers/media/rc/uirt.c:618:6: warning: variable 'err' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
> > >             if (!uirt->in)
> > >                 ^~~~~~~~~
> > >     drivers/media/rc/uirt.c:705:9: note: uninitialized use occurs here
> > >             return err;
> > >                    ^~~
> > >     drivers/media/rc/uirt.c:618:2: note: remove the 'if' if its condition is always false
> > >             if (!uirt->in)
> > >             ^~~~~~~~~~~~~~
> > >     drivers/media/rc/uirt.c:604:15: note: initialize the variable 'err' to silence this warning
> > >             int pipe, err;
> > >                          ^
> > >                           = 0
> > >     6 warnings generated.
> > > 
> > > 
> > > vim +639 drivers/media/rc/uirt.c
> > > 
> > >     594	
> > >     595	static int uirt_probe(struct usb_interface *intf,
> > >     596			      const struct usb_device_id *id)
> > >     597	{
> > >     598		struct usb_device *usbdev = interface_to_usbdev(intf);
> > >     599		struct usb_endpoint_descriptor *ep_in;
> > >     600		struct usb_endpoint_descriptor *ep_out;
> > >     601		struct uirt *uirt;
> > >     602		struct rc_dev *rc;
> > >     603		struct urb *urb;
> > >     604		int pipe, err;
> > >     605	
> > >     606		if (usb_find_common_endpoints(intf->cur_altsetting, &ep_in, &ep_out, NULL, NULL) ||
> > >     607		    usb_endpoint_maxp(ep_in) != MAX_PACKET ||
> > >     608		    usb_endpoint_maxp(ep_out) != MAX_PACKET) {
> > >     609			dev_err(&intf->dev, "required endpoints not found\n");
> > >     610			return -ENODEV;
> > >     611		}
> > >     612	
> > >     613		uirt = kzalloc(sizeof(*uirt), GFP_KERNEL);
> > >     614		if (!uirt)
> > >     615			return -ENOMEM;
> > >     616	
> > >     617		uirt->in = kmalloc(MAX_PACKET, GFP_KERNEL);
> > >     618		if (!uirt->in)
> > >     619			goto free_uirt;
> > >     620	
> > >     621		uirt->out = kmalloc(MAX_PACKET, GFP_KERNEL);
> > >     622		if (!uirt->out)
> > >     623			goto free_uirt;
> > >     624	
> > >     625		rc = rc_allocate_device(RC_DRIVER_IR_RAW);
> > >     626		if (!rc)
> > >     627			goto free_uirt;
> > >     628	
> > >     629		urb = usb_alloc_urb(0, GFP_KERNEL);
> > >     630		if (!urb)
> > >     631			goto free_rcdev;
> > >     632	
> > >     633		pipe = usb_rcvbulkpipe(usbdev, ep_in->bEndpointAddress);
> > >     634		usb_fill_bulk_urb(urb, usbdev, pipe, uirt->in, MAX_PACKET,
> > >     635				  uirt_in_callback, uirt);
> > >     636		uirt->urb_in = urb;
> > >     637	
> > >     638		urb = usb_alloc_urb(0, GFP_KERNEL);
> > >   > 639		if (!urb)
> > >     640			goto free_rcdev;
> > >     641	
> > >     642		pipe = usb_sndbulkpipe(usbdev, ep_out->bEndpointAddress);
> > >     643		usb_fill_bulk_urb(urb, usbdev, pipe, uirt->out, MAX_PACKET,
> > >     644				  uirt_out_callback, uirt);
> > >     645	
> > >     646		uirt->dev = &intf->dev;
> > >     647		uirt->usbdev = usbdev;
> > >     648		uirt->rc = rc;
> > >     649		uirt->urb_out = urb;
> > >     650		uirt->rx_state = RX_STATE_INTERSPACE_HIGH;
> > >     651	
> > >     652		err = usb_submit_urb(uirt->urb_in, GFP_KERNEL);
> > >     653		if (err != 0) {
> > >     654			dev_err(uirt->dev, "failed to submit read urb: %d\n", err);
> > >     655			goto free_rcdev;
> > >     656		}
> > >     657	
> > >     658		err = init_ftdi(usbdev);
> > >     659		if (err) {
> > >     660			dev_err(uirt->dev, "failed to setup ftdi: %d\n", err);
> > >     661			goto kill_urbs;
> > >     662		}
> > >     663	
> > >     664		err = uirt_setup(uirt);
> > >     665		if (err)
> > >     666			goto kill_urbs;
> > >     667	
> > >     668		usb_make_path(usbdev, uirt->phys, sizeof(uirt->phys));
> > >     669	
> > >     670		rc->device_name = "USB-UIRT";
> > >     671		rc->driver_name = KBUILD_MODNAME;
> > >     672		rc->input_phys = uirt->phys;
> > >     673		usb_to_input_id(usbdev, &rc->input_id);
> > >     674		rc->dev.parent = &intf->dev;
> > >     675		rc->priv = uirt;
> > >     676		rc->tx_ir = uirt_tx;
> > >     677		rc->s_tx_carrier = uirt_set_tx_carrier;
> > >     678		rc->s_learning_mode = uirt_set_rx_wideband;
> > >     679		rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
> > >     680		rc->map_name = RC_MAP_RC6_MCE;
> > >     681		rc->rx_resolution = UNIT_US;
> > >     682		rc->timeout = IR_TIMEOUT;
> > >     683	
> > >     684		uirt_set_tx_carrier(rc, 38000);
> > >     685	
> > >     686		err = rc_register_device(rc);
> > >     687		if (err)
> > >     688			goto kill_urbs;
> > >     689	
> > >     690		usb_set_intfdata(intf, uirt);
> > >     691	
> > >     692		return 0;
> > >     693	
> > >     694	kill_urbs:
> > >     695		usb_kill_urb(uirt->urb_in);
> > >     696		usb_kill_urb(uirt->urb_out);
> > >     697	free_rcdev:
> > >     698		usb_free_urb(uirt->urb_in);
> > >     699		usb_free_urb(uirt->urb_out);
> > >     700		rc_free_device(rc);
> > >     701	free_uirt:
> > >     702		kfree(uirt->in);
> > >     703		kfree(uirt->out);
> > >     704		kfree(uirt);
> > >     705		return err;
> > >     706	}
> > >     707	
> > > 
> > > ---
> > > 0-DAY CI Kernel Test Service, Intel Corporation
> > > https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
> > 
> > 

^ permalink raw reply	[flat|nested] 9+ messages in thread

end of thread, other threads:[~2021-06-18 21:19 UTC | newest]

Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-06-10 10:16 [PATCH v4 0/2] IR driver for USB-UIRT device Sean Young
2021-06-10 10:16 ` [PATCH v4 1/2] media: rc: new " Sean Young
2021-06-17 22:18   ` kernel test robot
2021-06-18  8:44     ` Sean Young
2021-06-18 17:04       ` Nathan Chancellor
2021-06-18 21:19         ` Sean Young
2021-06-10 10:16 ` [PATCH v4 2/2] USB: serial: blacklist USB-UIRT when driver is selected Sean Young
2021-06-10 10:23   ` Greg Kroah-Hartman
2021-06-10 10:34     ` Sean Young

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).