[Xenomai] [PATCH] Fix up the imx uart driver so it now compiles with new kernels.

Greg Gallagher greg at embeddedgreg.com
Fri Feb 2 04:06:22 CET 2018


This patch is based on one that was submitted by Wolfgang Netbal back in Feb
2016 but a formal patch was never submitted.
I added a couple small changes (style errors and imx7 define) and tested on a
imx7d board. One quick note, the IMX7D define may not really be needed since
most imx7 uarts look to be compatible with imx6. The original thread that this
patch was derived from is located here:

https://xenomai.org/pipermail/xenomai/2016-February/035924.html

Signed-off-by: Greg Gallagher <greg at embeddedgreg.com>
---
 kernel/drivers/serial/rt_imx_uart.c | 326 ++++++++++++++++++++++++------------
 1 file changed, 218 insertions(+), 108 deletions(-)

diff --git a/kernel/drivers/serial/rt_imx_uart.c b/kernel/drivers/serial/rt_imx_uart.c
index 092cecc..61836ae 100644
--- a/kernel/drivers/serial/rt_imx_uart.c
+++ b/kernel/drivers/serial/rt_imx_uart.c
@@ -36,8 +36,10 @@
 #include <asm/irq.h>
 #include <asm/dma.h>
 #include <asm/div64.h>
-#include <mach/hardware.h>
-#include <mach/imx-uart.h>
+#include <linux/platform_data/serial-imx.h>
+#include <linux/slab.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
 
 #include <rtdm/serial.h>
 #include <rtdm/driver.h>
@@ -65,7 +67,10 @@ MODULE_LICENSE("GPL");
 #define UBMR	0xa8 /* BRM Modulator Register */
 #define UBRC	0xac /* Baud Rate Count Register */
 #define MX2_ONEMS 0xb0 /* One Millisecond register */
-#define UTS (cpu_is_mx1() ? 0xd0 : 0xb4) /* UART Test Register */
+#define IMX1_UTS 0xd0 /* UART Test Register on i.mx1 */
+#define IMX21_UTS 0xb4 /* UART Test Register on all other i.mx*/
+
+
 
 /* UART Control Register Bit Fields.*/
 #define URXD_CHARRDY	(1<<15)
@@ -143,7 +148,7 @@ MODULE_LICENSE("GPL");
 #define USR1_DTRD	(1<<7)	/* DTR Delta */
 #define USR1_RXDS	(1<<6)	/* Receiver idle interrupt flag */
 #define USR1_AIRINT	(1<<5)	/* Async IR wake interrupt flag */
-#define USR1_AWAKE	(1<<4)	/* Aysnc wake interrupt flag */
+#define USR1_AWAKE	(1<<4)	/* Async wake interrupt flag */
 #define USR2_ADET	(1<<15) /* Auto baud rate detect complete */
 #define USR2_TXFE	(1<<14) /* Transmit buffer FIFO empty */
 #define USR2_DTRF	(1<<13) /* DTR edge interrupt flag */
@@ -189,9 +194,24 @@ MODULE_LICENSE("GPL");
 #define RT_IMX_UART_MAX		5
 
 static int tx_fifo[RT_IMX_UART_MAX];
-compat_module_param_array(tx_fifo, int, RT_IMX_UART_MAX, 0400);
+module_param_array(tx_fifo, int, NULL, 0400);
 MODULE_PARM_DESC(tx_fifo, "Transmitter FIFO size");
 
+/* i.MX21 type uart runs on all i.mx except i.MX1 and i.MX6q */
+enum imx_uart_type {
+	IMX1_UART,
+	IMX21_UART,
+	IMX53_UART,
+	IMX6Q_UART,
+};
+
+/* device type dependent stuff */
+struct imx_uart_data {
+	unsigned int uts_reg;
+	enum imx_uart_type devtype;
+};
+
+
 struct rt_imx_uart_port {
 	unsigned char __iomem *membase;	/* read/write[bwl] */
 	resource_size_t mapbase;	/* for ioremap */
@@ -200,11 +220,69 @@ struct rt_imx_uart_port {
 	unsigned int have_rtscts;
 	unsigned int use_dcedte;
 	unsigned int use_hwflow;
-	struct clk *clk;		/* clock id for UART clock */
+	struct clk *clk_ipg;		/* clock id for UART clock */
+	struct clk *clk_per;		/* clock id for UART clock */
+	const struct imx_uart_data *devdata;
 	unsigned int uartclk;		/* base uart clock */
 	struct rtdm_device rtdm_dev;	/* RTDM device structure */
 };
 
+
+static struct imx_uart_data imx_uart_devdata[] = {
+	[IMX1_UART] = {
+		.uts_reg = IMX1_UTS,
+		.devtype = IMX1_UART,
+	},
+	[IMX21_UART] = {
+		.uts_reg = IMX21_UTS,
+		.devtype = IMX21_UART,
+	},
+	[IMX53_UART] = {
+		.uts_reg = IMX21_UTS,
+		.devtype = IMX53_UART,
+	},
+	[IMX6Q_UART] = {
+		.uts_reg = IMX21_UTS,
+		.devtype = IMX6Q_UART,
+	},
+};
+
+static const struct platform_device_id rt_imx_uart_id_table[] = {
+	{
+		.name = "imx1-uart",
+		.driver_data = (kernel_ulong_t) &imx_uart_devdata[IMX1_UART],
+	}, {
+		.name = "imx21-uart",
+		.driver_data = (kernel_ulong_t) &imx_uart_devdata[IMX21_UART],
+	}, {
+		.name = "imx53-uart",
+		.driver_data = (kernel_ulong_t) &imx_uart_devdata[IMX53_UART],
+	}, {
+		.name = "imx6q-uart",
+		.driver_data = (kernel_ulong_t) &imx_uart_devdata[IMX6Q_UART],
+	}, {
+		/* sentinel */
+	}
+};
+MODULE_DEVICE_TABLE(platform, rt_imx_uart_id_table);
+
+static const struct of_device_id rt_imx_uart_dt_ids[] = {
+	{
+		.compatible = "fsl,imx6q-uart",
+		.data = &imx_uart_devdata[IMX6Q_UART], },
+	{
+		.compatible = "fsl,imx53-uart",
+		.data = &imx_uart_devdata[IMX53_UART], },
+	{
+		.compatible = "fsl,imx1-uart",
+		.data = &imx_uart_devdata[IMX1_UART], },
+	{
+		.compatible = "fsl,imx21-uart",
+		.data = &imx_uart_devdata[IMX21_UART], },
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, rt_imx_uart_dt_ids);
+
 struct rt_imx_uart_ctx {
 	struct rtser_config config;	/* current device configuration */
 
@@ -217,6 +295,7 @@ struct rt_imx_uart_ctx {
 	int in_nwait;			/* bytes the user waits for */
 	rtdm_event_t in_event;		/* raised to unblock reader */
 	char in_buf[IN_BUFFER_SIZE];	/* RX ring buffer */
+
 	volatile unsigned long in_lock;	/* single-reader lock */
 	uint64_t *in_history;		/* RX timestamp buffer */
 
@@ -344,6 +423,7 @@ static int rt_imx_uart_rx_chars(struct rt_imx_uart_ctx *ctx,
 static void rt_imx_uart_tx_chars(struct rt_imx_uart_ctx *ctx)
 {
 	int ch, count;
+	unsigned int uts_reg = ctx->port->devdata->uts_reg;
 
 	for (count = ctx->port->tx_fifo;
 	     (count > 0) && (ctx->out_npend > 0);
@@ -352,7 +432,7 @@ static void rt_imx_uart_tx_chars(struct rt_imx_uart_ctx *ctx)
 		writel(ch, ctx->port->membase + URTX0);
 		ctx->out_head &= (OUT_BUFFER_SIZE - 1);
 
-		if (readl(ctx->port->membase + UTS) & UTS_TXFULL)
+		if (readl(ctx->port->membase + uts_reg) & UTS_TXFULL)
 			break;
 	}
 }
@@ -458,7 +538,7 @@ static int rt_imx_uart_int(rtdm_irq_t *irq_context)
 	rtdm_lock_put(&ctx->lock);
 
 	if (ret != RTDM_IRQ_HANDLED)
-		printk(KERN_WARNING "%s: unhandled interrupt\n", __func__);
+		pr_warn("%s: unhandled interrupt\n", __func__);
 	return ret;
 }
 
@@ -493,9 +573,10 @@ static unsigned int rt_imx_uart_get_msr(struct rt_imx_uart_ctx *ctx)
 static void rt_imx_uart_set_mcr(struct rt_imx_uart_ctx *ctx,
 				unsigned int mcr)
 {
+	unsigned int uts_reg = ctx->port->devdata->uts_reg;
 	unsigned long ucr2 = readl(ctx->port->membase + UCR2);
 	unsigned long ucr3 = readl(ctx->port->membase + UCR3);
-	unsigned long uts = readl(ctx->port->membase + UTS);
+	unsigned long uts = readl(ctx->port->membase + uts_reg);
 
 	if (mcr & RTSER_MCR_RTS) {
 		/*
@@ -523,7 +604,7 @@ static void rt_imx_uart_set_mcr(struct rt_imx_uart_ctx *ctx,
 		uts |= UTS_LOOP;
 	else
 		uts &= ~UTS_LOOP;
-	writel(uts, ctx->port->membase + UTS);
+	writel(uts, ctx->port->membase + uts_reg);
 }
 
 static void rt_imx_uart_break_ctl(struct rt_imx_uart_ctx *ctx,
@@ -557,7 +638,8 @@ static int rt_imx_uart_set_config(struct rt_imx_uart_ctx *ctx,
 		ctx->config.stop_bits = config->stop_bits & STOP_BITS_MASK;
 
 	/* Timeout manipulation is not atomic. The user is supposed to take
-	   care not to use and change timeouts at the same time. */
+	 * care not to use and change timeouts at the same time.
+	 */
 	if (config->config_mask & RTSER_SET_TIMEOUT_RX)
 		ctx->config.rx_timeout = config->rx_timeout;
 	if (config->config_mask & RTSER_SET_TIMEOUT_TX)
@@ -723,7 +805,7 @@ static int rt_imx_uart_setup_ufcr(struct rt_imx_uart_port *port)
 	 * RFDIV is set such way to satisfy requested uartclk value
 	 */
 	val = TXTL << 10 | RXTL;
-	ufcr_rfdiv = (clk_get_rate(port->clk) + port->uartclk / 2) /
+	ufcr_rfdiv = (clk_get_rate(port->clk_per) + port->uartclk / 2) /
 		port->uartclk;
 
 	if (!ufcr_rfdiv)
@@ -852,8 +934,7 @@ void rt_imx_uart_close(struct rtdm_fd *fd)
 	rtdm_irq_free(&ctx->irq_handle);
 	rt_imx_uart_cleanup_ctx(ctx);
 
-	if (in_history)
-		kfree(in_history);
+	kfree(in_history);
 }
 
 static int rt_imx_uart_ioctl(struct rtdm_fd *fd,
@@ -897,7 +978,7 @@ static int rt_imx_uart_ioctl(struct rtdm_fd *fd,
 		}
 
 		if ((config->config_mask & RTSER_SET_BAUD) &&
-		    (config->baud_rate > clk_get_rate(ctx->port->clk) / 16 ||
+		    (config->baud_rate > clk_get_rate(ctx->port->clk_per) / 16 ||
 		     config->baud_rate <= 0))
 			/* invalid baudrate for this port */
 			return -EINVAL;
@@ -910,7 +991,8 @@ static int rt_imx_uart_ioctl(struct rtdm_fd *fd,
 			if (rtdm_in_rt_context())
 				return -ENOSYS;
 
-			if (config->timestamp_history & RTSER_RX_TIMESTAMP_HISTORY)
+			if (config->timestamp_history &
+						RTSER_RX_TIMESTAMP_HISTORY)
 				hist_buf = kmalloc(IN_BUFFER_SIZE *
 						   sizeof(nanosecs_abs_t),
 						   GFP_KERNEL);
@@ -918,9 +1000,7 @@ static int rt_imx_uart_ioctl(struct rtdm_fd *fd,
 
 		rt_imx_uart_set_config(ctx, config, &hist_buf);
 
-		if (hist_buf)
-			kfree(hist_buf);
-
+		kfree(hist_buf);
 		break;
 	}
 
@@ -994,7 +1074,8 @@ static int rt_imx_uart_ioctl(struct rtdm_fd *fd,
 
 		while (!ctx->ioc_events) {
 			/* Only enable error interrupt
-			   when the user waits for it. */
+			 * when the user waits for it.
+			 */
 			if (ctx->config.event_mask & RTSER_EVENT_ERRPEND) {
 				ctx->ier_status |= IER_STAT;
 #ifdef FIXME
@@ -1144,7 +1225,8 @@ ssize_t rt_imx_uart_read(struct rtdm_fd *fd, void *buf, size_t nbyte)
 			/* Do we have to wrap around the buffer end? */
 			if (in_pos + subblock > IN_BUFFER_SIZE) {
 				/* Treat the block between head and buffer end
-				   separately. */
+				 * separately.
+				 */
 				subblock = IN_BUFFER_SIZE - in_pos;
 
 				if (rtdm_fd_is_user(fd)) {
@@ -1196,8 +1278,9 @@ ssize_t rt_imx_uart_read(struct rtdm_fd *fd, void *buf, size_t nbyte)
 
 		if (nonblocking)
 			/* ret was set to EAGAIN in case of a real
-			   non-blocking call or contains the error
-			   returned by rtdm_event_wait[_until] */
+			 * non-blocking call or contains the error
+			 * returned by rtdm_event_wait[_until]
+			 */
 			break;
 
 		ctx->in_nwait = nbyte;
@@ -1210,7 +1293,8 @@ ssize_t rt_imx_uart_read(struct rtdm_fd *fd, void *buf, size_t nbyte)
 		if (ret < 0) {
 			if (ret == -EIDRM) {
 				/* Device has been closed -
-				   return immediately. */
+				 * return immediately.
+				 */
 				return -EBADF;
 			}
 
@@ -1219,7 +1303,8 @@ ssize_t rt_imx_uart_read(struct rtdm_fd *fd, void *buf, size_t nbyte)
 			nonblocking = 1;
 			if (ctx->in_npend > 0) {
 				/* Final turn: collect pending bytes
-				   before exit. */
+				 * before exit.
+				 */
 				continue;
 			}
 
@@ -1287,7 +1372,8 @@ static ssize_t rt_imx_uart_write(struct rtdm_fd *fd, const void *buf,
 			/* Do we have to wrap around the buffer end? */
 			if (out_pos + subblock > OUT_BUFFER_SIZE) {
 				/* Treat the block between head and buffer
-				   end separately. */
+				 * end separately.
+				 */
 				subblock = OUT_BUFFER_SIZE - out_pos;
 
 				if (rtdm_fd_is_user(fd)) {
@@ -1344,7 +1430,8 @@ static ssize_t rt_imx_uart_write(struct rtdm_fd *fd, const void *buf,
 		if (ret < 0) {
 			if (ret == -EIDRM) {
 				/* Device has been closed -
-				   return immediately. */
+				 * return immediately.
+				 */
 				return -EBADF;
 			}
 			if (ret == -EWOULDBLOCK) {
@@ -1382,42 +1469,96 @@ static struct rtdm_driver imx_uart_driver = {
 	},
 };
 
+
+#ifdef CONFIG_OF
+
+/*
+ * This function returns 1 iff pdev isn't a device instatiated by dt, 0 iff it
+ * could successfully get all information from dt or a negative errno.
+ */
+static int rt_imx_uart_probe_dt(struct rt_imx_uart_port *port,
+				struct platform_device *pdev)
+{
+	struct device_node *np = pdev->dev.of_node;
+	const struct of_device_id *of_id =
+			of_match_device(rt_imx_uart_dt_ids, &pdev->dev);
+	int ret;
+
+	if (!np)
+		/* no device tree device */
+		return 1;
+
+	ret = of_alias_get_id(np, "serial");
+	if (ret < 0) {
+		dev_err(&pdev->dev, "failed to get alias id, errno %d\n", ret);
+		return ret;
+	}
+
+	pdev->id = ret;
+
+	if (of_get_property(np, "fsl,uart-has-rtscts", NULL))
+		port->have_rtscts = 1;
+	if (of_get_property(np, "fsl,irda-mode", NULL))
+		dev_warn(&pdev->dev, "IRDA not yet supported\n");
+
+	if (of_get_property(np, "fsl,dte-mode", NULL))
+		port->use_dcedte = 1;
+
+	port->devdata = of_id->data;
+
+	return 0;
+}
+#else
+static inline int rt_imx_uart_probe_dt(struct rt_imx_uart_port *port,
+				       struct platform_device *pdev)
+{
+	return 1;
+}
+#endif
+
+static void rt_imx_uart_probe_pdata(struct rt_imx_uart_port *port,
+				    struct platform_device *pdev)
+{
+	struct imxuart_platform_data *pdata = dev_get_platdata(&pdev->dev);
+
+	port->devdata = (struct imx_uart_data  *) pdev->id_entry->driver_data;
+
+	if (!pdata)
+		return;
+
+	if (pdata->flags & IMXUART_HAVE_RTSCTS)
+		port->have_rtscts = 1;
+}
+
 static int rt_imx_uart_probe(struct platform_device *pdev)
 {
-	struct imxuart_platform_data *pdata;
 	struct rtdm_device *dev;
 	struct rt_imx_uart_port *port;
 	struct resource *res;
-	int err;
+	int ret;
 
-	port = kzalloc(sizeof(*port), GFP_KERNEL);
+	port = devm_kzalloc(&pdev->dev, sizeof(*port), GFP_KERNEL);
 	if (!port)
 		return -ENOMEM;
 
+	ret = rt_imx_uart_probe_dt(port, pdev);
+	if (ret > 0)
+		rt_imx_uart_probe_pdata(port, pdev);
+	else if (ret < 0)
+		return ret;
+
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-	if (!res) {
-		err = -ENODEV;
-		goto kfree_out;
-	}
-	port->mapbase = res->start;
+	if (!res)
+		return -ENODEV;
 
 	port->irq = platform_get_irq(pdev, 0);
-	if (port->irq <= 0) {
-		err = -ENODEV;
-		goto kfree_out;
-	}
 
-	if (!request_mem_region(port->mapbase, PAGE_SIZE, DRIVER_NAME)) {
-		err = -EBUSY;
-		goto kfree_out;
-	}
-
-	port->membase = ioremap(port->mapbase, PAGE_SIZE);
-	if (!port->membase) {
-		err = -ENOMEM;
-		goto release_mem_region_out;
-	}
+	if (port->irq <= 0)
+		return -ENODEV;
 
+	port->membase = devm_ioremap_resource(&pdev->dev, res);
+	if (IS_ERR(port->membase))
+		return PTR_ERR(port->membase);
 
 	dev = &port->rtdm_dev;
 	dev->driver = &imx_uart_driver;
@@ -1429,54 +1570,29 @@ static int rt_imx_uart_probe(struct platform_device *pdev)
 	else
 		port->tx_fifo = tx_fifo[pdev->id];
 
-	port->clk = clk_get(&pdev->dev, "uart");
-	if (IS_ERR(port->clk)) {
-		err = PTR_ERR(port->clk);
-		goto iounmap_out;
-	}
-	clk_enable(port->clk);
-	port->uartclk = clk_get_rate(port->clk);
+	port->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
+	if (IS_ERR(port->clk_ipg))
+		return PTR_ERR(port->clk_ipg);
 
-	port->use_hwflow = 1;
+	port->clk_per = devm_clk_get(&pdev->dev, "per");
+	if (IS_ERR(port->clk_per))
+		return PTR_ERR(port->clk_per);
 
-	pdata = pdev->dev.platform_data;
-	if (pdata && (pdata->flags & IMXUART_HAVE_RTSCTS))
-		port->have_rtscts = 1;
-	if (pdata && (pdata->flags & IMXUART_USE_DCEDTE))
-		port->use_dcedte = 1;
-	if (pdata && pdata->init) {
-		err = pdata->init(pdev);
-		if (err)
-			goto clk_disable_out;
-	}
+	clk_enable(port->clk_ipg);
+	clk_enable(port->clk_per);
+	port->uartclk = clk_get_rate(port->clk_per);
 
-	err = rtdm_dev_register(dev);
-	if (err)
-		goto pdata_exit_out;
+	port->use_hwflow = 1;
 
-	platform_set_drvdata(pdev, port);
+	ret = rtdm_dev_register(dev);
+	if (ret)
+		return ret;
 
-	printk(KERN_INFO
-	       "%s on IMX UART%d: membase=0x%p mapbase=%#x irq=%d uartclk=%d\n",
-	       dev->name, pdev->id, port->membase, (u32)port->mapbase,
-	       port->irq, port->uartclk);
+	platform_set_drvdata(pdev, port);
 
+	pr_info("%s on IMX UART%d: membase=0x%p irq=%d uartclk=%d\n",
+	       dev->name, pdev->id, port->membase, port->irq, port->uartclk);
 	return 0;
-
-pdata_exit_out:
-	if (pdata && pdata->exit)
-		pdata->exit(pdev);
-clk_disable_out:
-	clk_put(port->clk);
-	clk_disable(port->clk);
-iounmap_out:
-	iounmap(port->membase);
-release_mem_region_out:
-	release_mem_region(port->mapbase, SZ_4K);
-kfree_out:
-	kfree(port);
-
-	return err;
 }
 
 static int rt_imx_uart_remove(struct platform_device *pdev)
@@ -1490,26 +1606,9 @@ static int rt_imx_uart_remove(struct platform_device *pdev)
 
 	rtdm_dev_unregister(dev);
 
-	if (port->clk) {
-		clk_put(port->clk);
-		clk_disable(port->clk);
-	}
-
-	if (pdata && pdata->exit)
-		pdata->exit(pdev);
-
-	iounmap(port->membase);
-	release_mem_region(port->mapbase, PAGE_SIZE);
-	kfree(port);
-
 	return 0;
 }
 
-static const struct platform_device_id rt_imx_uart_id_table[] = {
-	{"imx-uart",},
-	{},
-};
-
 static struct platform_driver rt_imx_uart_driver = {
 	.probe = rt_imx_uart_probe,
 	.remove	= rt_imx_uart_remove,
@@ -1517,15 +1616,26 @@ static struct platform_driver rt_imx_uart_driver = {
 	.driver = {
 		.name = DRIVER_NAME,
 		.owner = THIS_MODULE,
+		.of_match_table = rt_imx_uart_dt_ids,
 	},
+	.prevent_deferred_probe = true,
 };
 
+
 static int __init rt_imx_uart_init(void)
 {
+	int ret;
+
 	if (!realtime_core_enabled())
 		return 0;
 
-	return platform_driver_register(&rt_imx_uart_driver);
+	ret = platform_driver_register(&rt_imx_uart_driver);
+	if (ret) {
+		pr_err("%s; Could not register  driver (err=%d)\n",
+			__func__, ret);
+	}
+
+	return ret;
 }
 
 static void __exit rt_imx_uart_exit(void)
-- 
2.7.4




More information about the Xenomai mailing list