[PATCHv3 0/8] serial: imx: rework pm support and add runtime pm

[PATCHv3 0/8] serial: imx: rework pm support and add runtime pm

[Eduardo Valentin]

Hello all,


This is version 3 of a patch series to introduce runtime pm in the imx serial
driver. The idea is to get runtime pm to handle ipg and per clocks, idling
the device when possible, configuring wakeups, and saving and restoring
context when needed.

A minor refactoring was needed to get things done. On top of it I am also
adding pm_qos support in the driver too.

Changelog:

V2->V3:
- error checking handling on clk_*enable functions
- added a missing return
- moved some of the code from the runtime pm patch to the pm qos patch, which
were causing compilation issues.
V2: http://marc.info/?l=linux-pm&m=143925695931624&w=2

V1->V2:
- The difference now is that it is rebased on top of linux-next, given
that some of the work done in v1 was already sent.
V1: http://marc.info/?l=linux-pm&m=143914435605790&w=2

As always, comments are welcome.

BR

Eduardo Valentin (8):
  serial: imx: remove unbalanced clk_prepare
  serial: imx: introduce serial_imx_enable_wakeup()
  serial: imx: allow waking up on RTSD
  serial: imx: save and restore context in the suspend path
  serial: imx: add a flag to indicate we are in the suspend path
  serial: imx: add runtime pm support
  serial: imx: add pm_qos request
  serial: imx: use SET_*SYSTEM_PM_OPS helper functions

 arch/arm/boot/dts/Makefile |   1 +
 drivers/tty/serial/imx.c   | 368 +++++++++++++++++++++++++++++++++++----------
 2 files changed, 286 insertions(+), 83 deletions(-)

-- 
2.5.0

[PATCHv3 1/8] serial: imx: remove unbalanced clk_prepare

[Eduardo Valentin]

The current code attempts to prepare clk_per and clk_ipg
before using the device. However, the result is an extra
prepare call on each clock. Here is the output of uart
clocks (only uart enabled and used as console):

$  grep uart /sys/kernel/debug/clk/clk_summary
 uart_serial           1            2    80000000          0 0
       uart           1            2    66000000          0 0

This patch balances the calls of prepares. The result is:

$  grep uart /sys/kernel/debug/clk/clk_summary
 uart_serial           1            1    80000000          0 0
       uart           1            1    66000000          0 0

Cc: Fabio Estevam <festevam@gmail.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Jiri Slaby <jslaby@suse.com>
Cc: linux-serial@vger.kernel.org
Cc: linux-pm@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Eduardo Valentin <edubezval@gmail.com>
---
 drivers/tty/serial/imx.c | 20 ++++++--------------
 1 file changed, 6 insertions(+), 14 deletions(-)

diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c
index 9a248eb..b27c232 100644
--- a/drivers/tty/serial/imx.c
+++ b/drivers/tty/serial/imx.c
@@ -1630,12 +1630,12 @@ imx_console_write(struct console *co, const char *s, unsigned int count)
 	int locked = 1;
 	int retval;
 
-	retval = clk_enable(sport->clk_per);
+	retval = clk_prepare_enable(sport->clk_per);
 	if (retval)
 		return;
-	retval = clk_enable(sport->clk_ipg);
+	retval = clk_prepare_enable(sport->clk_ipg);
 	if (retval) {
-		clk_disable(sport->clk_per);
+		clk_disable_unprepare(sport->clk_per);
 		return;
 	}
 
@@ -1674,8 +1674,8 @@ imx_console_write(struct console *co, const char *s, unsigned int count)
 	if (locked)
 		spin_unlock_irqrestore(&sport->port.lock, flags);
 
-	clk_disable(sport->clk_ipg);
-	clk_disable(sport->clk_per);
+	clk_disable_unprepare(sport->clk_ipg);
+	clk_disable_unprepare(sport->clk_per);
 }
 
 /*
@@ -1776,15 +1776,7 @@ imx_console_setup(struct console *co, char *options)
 
 	retval = uart_set_options(&sport->port, co, baud, parity, bits, flow);
 
-	clk_disable(sport->clk_ipg);
-	if (retval) {
-		clk_unprepare(sport->clk_ipg);
-		goto error_console;
-	}
-
-	retval = clk_prepare(sport->clk_per);
-	if (retval)
-		clk_disable_unprepare(sport->clk_ipg);
+	clk_disable_unprepare(sport->clk_ipg);
 
 error_console:
 	return retval;
-- 
2.5.0

[PATCHv3 2/8] serial: imx: introduce serial_imx_enable_wakeup()

[Eduardo Valentin]

This change is a code reorganization. Here we introduce
serial_imx_enable_wakeup() helper function to do
the job of configuring and preparing wakeup sources
on imx serial device. The idea is to allow other
parts of the code to call this function whenever
the device is known to go to idle.

Cc: Fabio Estevam <festevam@gmail.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Jiri Slaby <jslaby@suse.com>
Cc: linux-serial@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Eduardo Valentin <edubezval@gmail.com>
---
 arch/arm/boot/dts/Makefile |  1 +
 drivers/tty/serial/imx.c   | 22 ++++++++++++++--------
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/arch/arm/boot/dts/Makefile b/arch/arm/boot/dts/Makefile
index 821e015..d60b28f 100644
--- a/arch/arm/boot/dts/Makefile
+++ b/arch/arm/boot/dts/Makefile
@@ -330,6 +330,7 @@ dtb-$(CONFIG_SOC_IMX6Q) += \
 	imx6q-wandboard-revb1.dtb
 dtb-$(CONFIG_SOC_IMX6SL) += \
 	imx6sl-evk.dtb \
+	imx6sl-fox-p1.dtb \
 	imx6sl-warp.dtb
 dtb-$(CONFIG_SOC_IMX6SX) += \
 	imx6sx-sabreauto.dtb \
diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c
index b27c232..3c2b0ac 100644
--- a/drivers/tty/serial/imx.c
+++ b/drivers/tty/serial/imx.c
@@ -1972,6 +1972,18 @@ static int serial_imx_remove(struct platform_device *pdev)
 	return uart_remove_one_port(&imx_reg, &sport->port);
 }
 
+static void serial_imx_enable_wakeup(struct imx_port *sport, bool on)
+{
+	unsigned int val;
+
+	val = readl(sport->port.membase + UCR3);
+	if (on)
+		val |= UCR3_AWAKEN;
+	else
+		val &= ~UCR3_AWAKEN;
+	writel(val, sport->port.membase + UCR3);
+}
+
 static int imx_serial_port_suspend_noirq(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
@@ -2029,12 +2041,9 @@ static int imx_serial_port_suspend(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
 	struct imx_port *sport = platform_get_drvdata(pdev);
-	unsigned int val;
 
 	/* enable wakeup from i.MX UART */
-	val = readl(sport->port.membase + UCR3);
-	val |= UCR3_AWAKEN;
-	writel(val, sport->port.membase + UCR3);
+	serial_imx_enable_wakeup(sport, true);
 
 	uart_suspend_port(&imx_reg, &sport->port);
 
@@ -2045,12 +2054,9 @@ static int imx_serial_port_resume(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
 	struct imx_port *sport = platform_get_drvdata(pdev);
-	unsigned int val;
 
 	/* disable wakeup from i.MX UART */
-	val = readl(sport->port.membase + UCR3);
-	val &= ~UCR3_AWAKEN;
-	writel(val, sport->port.membase + UCR3);
+	serial_imx_enable_wakeup(sport, false);
 
 	uart_resume_port(&imx_reg, &sport->port);
 
-- 
2.5.0

[PATCHv3 3/8] serial: imx: allow waking up on RTSD

[Eduardo Valentin]

This patch sets RTSDEN bit when going into idle (Stop mode).
We add the RTSDEN for the case RTS is sent from
the remote connection. This way we allow the system
to wakeup when RTS is received.

Cc: Fabio Stevam <festevam@gmail.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Jiri Slaby <jslaby@suse.com>
Cc: linux-serial@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Eduardo Valentin <edubezval@gmail.com>
---
 drivers/tty/serial/imx.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c
index 3c2b0ac..167dea1 100644
--- a/drivers/tty/serial/imx.c
+++ b/drivers/tty/serial/imx.c
@@ -1982,6 +1982,13 @@ static void serial_imx_enable_wakeup(struct imx_port *sport, bool on)
 	else
 		val &= ~UCR3_AWAKEN;
 	writel(val, sport->port.membase + UCR3);
+
+	val = readl(sport->port.membase + UCR1);
+	if (on)
+		val |= UCR1_RTSDEN;
+	else
+		val &= ~UCR1_RTSDEN;
+	writel(val, sport->port.membase + UCR1);
 }
 
 static int imx_serial_port_suspend_noirq(struct device *dev)
-- 
2.5.0

[PATCHv3 4/8] serial: imx: save and restore context in the suspend path

[Eduardo Valentin]

This change teaches the imx serial driver to save its
context and restore it across suspend and resume path.
To do so, it introduces serial_imx_restore_context()
and serial_imx_save_context() functions. They use
a shadow set of registers to save key registers
and restore them accordingly. These functions can
be reused on other situations, when the device
context is lost.

Cc: Fabio Estevam <festevam@gmail.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Jiri Slaby <jslaby@suse.com>
Cc: linux-serial@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Eduardo Valentin <edubezval@gmail.com>
---
 drivers/tty/serial/imx.c | 58 ++++++++++++++++++++++++++++++------------------
 1 file changed, 37 insertions(+), 21 deletions(-)

diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c
index 167dea1..fe3d41c 100644
--- a/drivers/tty/serial/imx.c
+++ b/drivers/tty/serial/imx.c
@@ -217,6 +217,7 @@ struct imx_port {
 	unsigned int		dma_tx_nents;
 	wait_queue_head_t	dma_wait;
 	unsigned int            saved_reg[10];
+	bool			context_saved;
 };
 
 struct imx_port_ucrs {
@@ -1972,6 +1973,40 @@ static int serial_imx_remove(struct platform_device *pdev)
 	return uart_remove_one_port(&imx_reg, &sport->port);
 }
 
+static void serial_imx_restore_context(struct imx_port *sport)
+{
+	if (!sport->context_saved)
+		return;
+
+	writel(sport->saved_reg[4], sport->port.membase + UFCR);
+	writel(sport->saved_reg[5], sport->port.membase + UESC);
+	writel(sport->saved_reg[6], sport->port.membase + UTIM);
+	writel(sport->saved_reg[7], sport->port.membase + UBIR);
+	writel(sport->saved_reg[8], sport->port.membase + UBMR);
+	writel(sport->saved_reg[9], sport->port.membase + IMX21_UTS);
+	writel(sport->saved_reg[0], sport->port.membase + UCR1);
+	writel(sport->saved_reg[1] | UCR2_SRST, sport->port.membase + UCR2);
+	writel(sport->saved_reg[2], sport->port.membase + UCR3);
+	writel(sport->saved_reg[3], sport->port.membase + UCR4);
+	sport->context_saved = false;
+}
+
+static void serial_imx_save_context(struct imx_port *sport)
+{
+	/* Save necessary regs */
+	sport->saved_reg[0] = readl(sport->port.membase + UCR1);
+	sport->saved_reg[1] = readl(sport->port.membase + UCR2);
+	sport->saved_reg[2] = readl(sport->port.membase + UCR3);
+	sport->saved_reg[3] = readl(sport->port.membase + UCR4);
+	sport->saved_reg[4] = readl(sport->port.membase + UFCR);
+	sport->saved_reg[5] = readl(sport->port.membase + UESC);
+	sport->saved_reg[6] = readl(sport->port.membase + UTIM);
+	sport->saved_reg[7] = readl(sport->port.membase + UBIR);
+	sport->saved_reg[8] = readl(sport->port.membase + UBMR);
+	sport->saved_reg[9] = readl(sport->port.membase + IMX21_UTS);
+	sport->context_saved = true;
+}
+
 static void serial_imx_enable_wakeup(struct imx_port *sport, bool on)
 {
 	unsigned int val;
@@ -2001,17 +2036,7 @@ static int imx_serial_port_suspend_noirq(struct device *dev)
 	if (ret)
 		return ret;
 
-	/* Save necessary regs */
-	sport->saved_reg[0] = readl(sport->port.membase + UCR1);
-	sport->saved_reg[1] = readl(sport->port.membase + UCR2);
-	sport->saved_reg[2] = readl(sport->port.membase + UCR3);
-	sport->saved_reg[3] = readl(sport->port.membase + UCR4);
-	sport->saved_reg[4] = readl(sport->port.membase + UFCR);
-	sport->saved_reg[5] = readl(sport->port.membase + UESC);
-	sport->saved_reg[6] = readl(sport->port.membase + UTIM);
-	sport->saved_reg[7] = readl(sport->port.membase + UBIR);
-	sport->saved_reg[8] = readl(sport->port.membase + UBMR);
-	sport->saved_reg[9] = readl(sport->port.membase + IMX21_UTS);
+	serial_imx_save_context(sport);
 
 	clk_disable(sport->clk_ipg);
 
@@ -2028,16 +2053,7 @@ static int imx_serial_port_resume_noirq(struct device *dev)
 	if (ret)
 		return ret;
 
-	writel(sport->saved_reg[4], sport->port.membase + UFCR);
-	writel(sport->saved_reg[5], sport->port.membase + UESC);
-	writel(sport->saved_reg[6], sport->port.membase + UTIM);
-	writel(sport->saved_reg[7], sport->port.membase + UBIR);
-	writel(sport->saved_reg[8], sport->port.membase + UBMR);
-	writel(sport->saved_reg[9], sport->port.membase + IMX21_UTS);
-	writel(sport->saved_reg[0], sport->port.membase + UCR1);
-	writel(sport->saved_reg[1] | UCR2_SRST, sport->port.membase + UCR2);
-	writel(sport->saved_reg[2], sport->port.membase + UCR3);
-	writel(sport->saved_reg[3], sport->port.membase + UCR4);
+	serial_imx_restore_context(sport);
 
 	clk_disable(sport->clk_ipg);
 
-- 
2.5.0

[PATCHv3 5/8] serial: imx: add a flag to indicate we are in the suspend path

[Eduardo Valentin]

This is a simple flag that gets set across prepare and complete
callbacks in the suspend path. We the flag we may avoid
runtime pm idling at the same time.

Cc: Fabio Estevam <festevam@gmail.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Jiri Slaby <jslaby@suse.com>
Cc: linux-serial@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Eduardo Valentin <edubezval@gmail.com>
---
 drivers/tty/serial/imx.c | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c
index fe3d41c..50abb60 100644
--- a/drivers/tty/serial/imx.c
+++ b/drivers/tty/serial/imx.c
@@ -218,6 +218,8 @@ struct imx_port {
 	wait_queue_head_t	dma_wait;
 	unsigned int            saved_reg[10];
 	bool			context_saved;
+
+	bool			is_suspending;
 };
 
 struct imx_port_ucrs {
@@ -2026,6 +2028,22 @@ static void serial_imx_enable_wakeup(struct imx_port *sport, bool on)
 	writel(val, sport->port.membase + UCR1);
 }
 
+static int serial_imx_prepare(struct device *dev)
+{
+	struct imx_port *sport = dev_get_drvdata(dev);
+
+	sport->is_suspending = true;
+
+	return 0;
+}
+
+static void serial_imx_complete(struct device *dev)
+{
+	struct imx_port *sport = dev_get_drvdata(dev);
+
+	sport->is_suspending = false;
+}
+
 static int imx_serial_port_suspend_noirq(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
@@ -2091,6 +2109,8 @@ static const struct dev_pm_ops imx_serial_port_pm_ops = {
 	.resume_noirq = imx_serial_port_resume_noirq,
 	.suspend = imx_serial_port_suspend,
 	.resume = imx_serial_port_resume,
+	.prepare = serial_imx_prepare,
+	.complete = serial_imx_complete,
 };
 
 static struct platform_driver serial_imx_driver = {
-- 
2.5.0

[PATCHv3 6/8] serial: imx: add runtime pm support

[Eduardo Valentin]

This change introduces the runtime pm support on imx serial
driver. The objective is to be able to idle the uart
port whenever it is not in use while still being able
to wake it up when needed. The key changes in this patch are:
1. Move the clock handling to runtime pm. Both, ipg and per,
are now handled in the suspend and resume callbacks. Only
enabling and disabling the clocks are handled in runtime
suspend and resume, so we are able to use runtime pm
in IRQ context.
2. Clocks are prepared in probe and unprepared in remove,
so we do not need to prepare (may sleep) in runtime pm.
3. We mark the device activity based on uart and console
callbacks. Whenever the device is needed and we want to
access registers, we runtime_pm_get and then mark its
last usage when we are done. This is done also across
IRQs and DMA callbacks.
4. We reuse the infrastructure in place for suspend and
resume, so we do not need to redo wakeup configuration,
or context save and restore.

After this change, the clocks are still sane, in the sense
of having balanced clock prepare and enable.

Cc: Fabio Estevam <festevam@gmail.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Jiri Slaby <jslaby@suse.com>
Cc: linux-serial@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Eduardo Valentin <edubezval@gmail.com>
---
 drivers/tty/serial/imx.c | 224 +++++++++++++++++++++++++++++++++++++----------
 1 file changed, 178 insertions(+), 46 deletions(-)

diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c
index 50abb60..9447a55 100644
--- a/drivers/tty/serial/imx.c
+++ b/drivers/tty/serial/imx.c
@@ -39,6 +39,9 @@
 #include <linux/of_device.h>
 #include <linux/io.h>
 #include <linux/dma-mapping.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
+#include <linux/pm_wakeup.h>
 
 #include <asm/irq.h>
 #include <linux/platform_data/serial-imx.h>
@@ -219,6 +222,7 @@ struct imx_port {
 	unsigned int            saved_reg[10];
 	bool			context_saved;
 
+	struct device		*dev;
 	bool			is_suspending;
 };
 
@@ -369,6 +373,7 @@ static void imx_stop_tx(struct uart_port *port)
 	if (sport->dma_is_enabled && sport->dma_is_txing)
 		return;
 
+	pm_runtime_get_sync(sport->dev);
 	temp = readl(port->membase + UCR1);
 	writel(temp & ~UCR1_TXMPTYEN, port->membase + UCR1);
 
@@ -386,6 +391,8 @@ static void imx_stop_tx(struct uart_port *port)
 		temp &= ~UCR4_TCEN;
 		writel(temp, port->membase + UCR4);
 	}
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 }
 
 /*
@@ -405,12 +412,15 @@ static void imx_stop_rx(struct uart_port *port)
 		}
 	}
 
+	pm_runtime_get_sync(sport->dev);
 	temp = readl(sport->port.membase + UCR2);
 	writel(temp & ~UCR2_RXEN, sport->port.membase + UCR2);
 
 	/* disable the `Receiver Ready Interrrupt` */
 	temp = readl(sport->port.membase + UCR1);
 	writel(temp & ~UCR1_RRDYEN, sport->port.membase + UCR1);
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 }
 
 /*
@@ -482,6 +492,7 @@ static void dma_tx_callback(void *data)
 	unsigned long flags;
 	unsigned long temp;
 
+	pm_runtime_get_sync(sport->dev);
 	spin_lock_irqsave(&sport->port.lock, flags);
 
 	dma_unmap_sg(sport->port.dev, sgl, sport->dma_tx_nents, DMA_TO_DEVICE);
@@ -506,13 +517,17 @@ static void dma_tx_callback(void *data)
 	if (waitqueue_active(&sport->dma_wait)) {
 		wake_up(&sport->dma_wait);
 		dev_dbg(sport->port.dev, "exit in %s.\n", __func__);
-		return;
+		goto mark_last;
 	}
 
 	spin_lock_irqsave(&sport->port.lock, flags);
 	if (!uart_circ_empty(xmit) && !uart_tx_stopped(&sport->port))
 		imx_dma_tx(sport);
 	spin_unlock_irqrestore(&sport->port.lock, flags);
+
+mark_last:
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 }
 
 static void imx_dma_tx(struct imx_port *sport)
@@ -579,6 +594,7 @@ static void imx_start_tx(struct uart_port *port)
 	struct imx_port *sport = (struct imx_port *)port;
 	unsigned long temp;
 
+	pm_runtime_get_sync(sport->dev);
 	if (port->rs485.flags & SER_RS485_ENABLED) {
 		/* enable transmitter and shifter empty irq */
 		temp = readl(port->membase + UCR2);
@@ -606,14 +622,18 @@ static void imx_start_tx(struct uart_port *port)
 			temp &= ~UCR1_TDMAEN;
 			temp |= UCR1_TXMPTYEN;
 			writel(temp, sport->port.membase + UCR1);
-			return;
+			goto mark_last;
 		}
 
 		if (!uart_circ_empty(&port->state->xmit) &&
 		    !uart_tx_stopped(port))
 			imx_dma_tx(sport);
-		return;
+		goto mark_last;
 	}
+
+mark_last:
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 }
 
 static irqreturn_t imx_rtsint(int irq, void *dev_id)
@@ -622,6 +642,7 @@ static irqreturn_t imx_rtsint(int irq, void *dev_id)
 	unsigned int val;
 	unsigned long flags;
 
+	pm_runtime_get_sync(sport->dev);
 	spin_lock_irqsave(&sport->port.lock, flags);
 
 	writel(USR1_RTSD, sport->port.membase + USR1);
@@ -630,6 +651,9 @@ static irqreturn_t imx_rtsint(int irq, void *dev_id)
 	wake_up_interruptible(&sport->port.state->port.delta_msr_wait);
 
 	spin_unlock_irqrestore(&sport->port.lock, flags);
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
+
 	return IRQ_HANDLED;
 }
 
@@ -638,9 +662,13 @@ static irqreturn_t imx_txint(int irq, void *dev_id)
 	struct imx_port *sport = dev_id;
 	unsigned long flags;
 
+	pm_runtime_get_sync(sport->dev);
 	spin_lock_irqsave(&sport->port.lock, flags);
 	imx_transmit_buffer(sport);
 	spin_unlock_irqrestore(&sport->port.lock, flags);
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
+
 	return IRQ_HANDLED;
 }
 
@@ -651,6 +679,7 @@ static irqreturn_t imx_rxint(int irq, void *dev_id)
 	struct tty_port *port = &sport->port.state->port;
 	unsigned long flags, temp;
 
+	pm_runtime_get_sync(sport->dev);
 	spin_lock_irqsave(&sport->port.lock, flags);
 
 	while (readl(sport->port.membase + USR2) & USR2_RDR) {
@@ -711,6 +740,8 @@ static irqreturn_t imx_rxint(int irq, void *dev_id)
 out:
 	spin_unlock_irqrestore(&sport->port.lock, flags);
 	tty_flip_buffer_push(port);
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 	return IRQ_HANDLED;
 }
 
@@ -748,6 +779,7 @@ static irqreturn_t imx_int(int irq, void *dev_id)
 	unsigned int sts;
 	unsigned int sts2;
 
+	pm_runtime_get_sync(sport->dev);
 	sts = readl(sport->port.membase + USR1);
 	sts2 = readl(sport->port.membase + USR2);
 
@@ -774,6 +806,8 @@ static irqreturn_t imx_int(int irq, void *dev_id)
 		sport->port.icount.overrun++;
 		writel(USR2_ORE, sport->port.membase + USR2);
 	}
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 
 	return IRQ_HANDLED;
 }
@@ -786,11 +820,14 @@ static unsigned int imx_tx_empty(struct uart_port *port)
 	struct imx_port *sport = (struct imx_port *)port;
 	unsigned int ret;
 
+	pm_runtime_get_sync(sport->dev);
 	ret = (readl(sport->port.membase + USR2) & USR2_TXDC) ?  TIOCSER_TEMT : 0;
 
 	/* If the TX DMA is working, return 0. */
 	if (sport->dma_is_enabled && sport->dma_is_txing)
 		ret = 0;
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 
 	return ret;
 }
@@ -803,6 +840,7 @@ static unsigned int imx_get_mctrl(struct uart_port *port)
 	struct imx_port *sport = (struct imx_port *)port;
 	unsigned int tmp = TIOCM_DSR | TIOCM_CAR;
 
+	pm_runtime_get_sync(sport->dev);
 	if (readl(sport->port.membase + USR1) & USR1_RTSS)
 		tmp |= TIOCM_CTS;
 
@@ -811,6 +849,8 @@ static unsigned int imx_get_mctrl(struct uart_port *port)
 
 	if (readl(sport->port.membase + uts_reg(sport)) & UTS_LOOP)
 		tmp |= TIOCM_LOOP;
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 
 	return tmp;
 }
@@ -820,6 +860,7 @@ static void imx_set_mctrl(struct uart_port *port, unsigned int mctrl)
 	struct imx_port *sport = (struct imx_port *)port;
 	unsigned long temp;
 
+	pm_runtime_get_sync(sport->dev);
 	if (!(port->rs485.flags & SER_RS485_ENABLED)) {
 		temp = readl(sport->port.membase + UCR2);
 		temp &= ~(UCR2_CTS | UCR2_CTSC);
@@ -832,6 +873,8 @@ static void imx_set_mctrl(struct uart_port *port, unsigned int mctrl)
 	if (mctrl & TIOCM_LOOP)
 		temp |= UTS_LOOP;
 	writel(temp, sport->port.membase + uts_reg(sport));
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 }
 
 /*
@@ -842,6 +885,7 @@ static void imx_break_ctl(struct uart_port *port, int break_state)
 	struct imx_port *sport = (struct imx_port *)port;
 	unsigned long flags, temp;
 
+	pm_runtime_get_sync(sport->dev);
 	spin_lock_irqsave(&sport->port.lock, flags);
 
 	temp = readl(sport->port.membase + UCR1) & ~UCR1_SNDBRK;
@@ -852,6 +896,8 @@ static void imx_break_ctl(struct uart_port *port, int break_state)
 	writel(temp, sport->port.membase + UCR1);
 
 	spin_unlock_irqrestore(&sport->port.lock, flags);
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 }
 
 #define TXTL 2 /* reset default */
@@ -909,6 +955,7 @@ static void dma_rx_callback(void *data)
 	enum dma_status status;
 	unsigned int count;
 
+	pm_runtime_get_sync(sport->dev);
 	/* unmap it first */
 	dma_unmap_sg(sport->port.dev, sgl, 1, DMA_FROM_DEVICE);
 
@@ -950,6 +997,8 @@ static void dma_rx_callback(void *data)
 		 */
 		imx_rx_dma_done(sport);
 	}
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 }
 
 static int start_rx_dma(struct imx_port *sport)
@@ -1105,18 +1154,10 @@ static void imx_disable_dma(struct imx_port *sport)
 static int imx_startup(struct uart_port *port)
 {
 	struct imx_port *sport = (struct imx_port *)port;
-	int retval, i;
+	int i;
 	unsigned long flags, temp;
 
-	retval = clk_prepare_enable(sport->clk_per);
-	if (retval)
-		return retval;
-	retval = clk_prepare_enable(sport->clk_ipg);
-	if (retval) {
-		clk_disable_unprepare(sport->clk_per);
-		return retval;
-	}
-
+	pm_runtime_get_sync(sport->dev);
 	imx_setup_ufcr(sport, 0);
 
 	/* disable the DREN bit (Data Ready interrupt enable) before
@@ -1173,6 +1214,8 @@ static int imx_startup(struct uart_port *port)
 	 */
 	imx_enable_ms(&sport->port);
 	spin_unlock_irqrestore(&sport->port.lock, flags);
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 
 	return 0;
 }
@@ -1183,6 +1226,7 @@ static void imx_shutdown(struct uart_port *port)
 	unsigned long temp;
 	unsigned long flags;
 
+	pm_runtime_get_sync(sport->dev);
 	if (sport->dma_is_enabled) {
 		int ret;
 
@@ -1225,8 +1269,8 @@ static void imx_shutdown(struct uart_port *port)
 	writel(temp, sport->port.membase + UCR1);
 	spin_unlock_irqrestore(&sport->port.lock, flags);
 
-	clk_disable_unprepare(sport->clk_per);
-	clk_disable_unprepare(sport->clk_ipg);
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 }
 
 static void imx_flush_buffer(struct uart_port *port)
@@ -1239,6 +1283,7 @@ static void imx_flush_buffer(struct uart_port *port)
 	if (!sport->dma_chan_tx)
 		return;
 
+	pm_runtime_get_sync(sport->dev);
 	sport->tx_bytes = 0;
 	dmaengine_terminate_all(sport->dma_chan_tx);
 	if (sport->dma_is_txing) {
@@ -1272,6 +1317,8 @@ static void imx_flush_buffer(struct uart_port *port)
 	writel(ubir, sport->port.membase + UBIR);
 	writel(ubmr, sport->port.membase + UBMR);
 	writel(uts, sport->port.membase + IMX21_UTS);
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 }
 
 static void
@@ -1286,6 +1333,7 @@ imx_set_termios(struct uart_port *port, struct ktermios *termios,
 	unsigned long num, denom;
 	uint64_t tdiv64;
 
+	pm_runtime_get_sync(sport->dev);
 	/*
 	 * We only support CS7 and CS8.
 	 */
@@ -1441,6 +1489,8 @@ imx_set_termios(struct uart_port *port, struct ktermios *termios,
 	if (sport->dma_is_inited && !sport->dma_is_enabled)
 		imx_enable_dma(sport);
 	spin_unlock_irqrestore(&sport->port.lock, flags);
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 }
 
 static const char *imx_type(struct uart_port *port)
@@ -1498,13 +1548,7 @@ static int imx_poll_init(struct uart_port *port)
 	unsigned long temp;
 	int retval;
 
-	retval = clk_prepare_enable(sport->clk_ipg);
-	if (retval)
-		return retval;
-	retval = clk_prepare_enable(sport->clk_per);
-	if (retval)
-		clk_disable_unprepare(sport->clk_ipg);
-
+	pm_runtime_get_sync(sport->dev);
 	imx_setup_ufcr(sport, 0);
 
 	spin_lock_irqsave(&sport->port.lock, flags);
@@ -1521,22 +1565,36 @@ static int imx_poll_init(struct uart_port *port)
 	writel(temp, sport->port.membase + UCR2);
 
 	spin_unlock_irqrestore(&sport->port.lock, flags);
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 
 	return 0;
 }
 
 static int imx_poll_get_char(struct uart_port *port)
 {
-	if (!(readl_relaxed(port->membase + USR2) & USR2_RDR))
-		return NO_POLL_CHAR;
+	int ret;
+
+	pm_runtime_get_sync(sport->dev);
+	if (!(readl_relaxed(port->membase + USR2) & USR2_RDR)) {
+		ret = NO_POLL_CHAR;
+		goto mark_last;
+	}
+
+	ret = readl_relaxed(port->membase + URXD0) & URXD_RX_DATA;
+
+mark_last:
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 
-	return readl_relaxed(port->membase + URXD0) & URXD_RX_DATA;
+	return ret;
 }
 
 static void imx_poll_put_char(struct uart_port *port, unsigned char c)
 {
 	unsigned int status;
 
+	pm_runtime_get_sync(sport->dev);
 	/* drain */
 	do {
 		status = readl_relaxed(port->membase + USR1);
@@ -1549,6 +1607,8 @@ static void imx_poll_put_char(struct uart_port *port, unsigned char c)
 	do {
 		status = readl_relaxed(port->membase + USR2);
 	} while (~status & USR2_TXDC);
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 }
 #endif
 
@@ -1569,6 +1629,7 @@ static int imx_rs485_config(struct uart_port *port,
 	if (rs485conf->flags & SER_RS485_ENABLED) {
 		unsigned long temp;
 
+		pm_runtime_get_sync(sport->dev);
 		/* disable transmitter */
 		temp = readl(sport->port.membase + UCR2);
 		temp &= ~UCR2_CTSC;
@@ -1577,6 +1638,8 @@ static int imx_rs485_config(struct uart_port *port,
 		else
 			temp |= UCR2_CTS;
 		writel(temp, sport->port.membase + UCR2);
+		pm_runtime_mark_last_busy(sport->dev);
+		pm_runtime_put_autosuspend(sport->dev);
 	}
 
 	port->rs485 = *rs485conf;
@@ -1631,17 +1694,8 @@ imx_console_write(struct console *co, const char *s, unsigned int count)
 	unsigned int ucr1;
 	unsigned long flags = 0;
 	int locked = 1;
-	int retval;
-
-	retval = clk_prepare_enable(sport->clk_per);
-	if (retval)
-		return;
-	retval = clk_prepare_enable(sport->clk_ipg);
-	if (retval) {
-		clk_disable_unprepare(sport->clk_per);
-		return;
-	}
 
+	pm_runtime_get_sync(sport->dev);
 	if (sport->port.sysrq)
 		locked = 0;
 	else if (oops_in_progress)
@@ -1677,8 +1731,8 @@ imx_console_write(struct console *co, const char *s, unsigned int count)
 	if (locked)
 		spin_unlock_irqrestore(&sport->port.lock, flags);
 
-	clk_disable_unprepare(sport->clk_ipg);
-	clk_disable_unprepare(sport->clk_per);
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 }
 
 /*
@@ -1765,10 +1819,7 @@ imx_console_setup(struct console *co, char *options)
 	if (sport == NULL)
 		return -ENODEV;
 
-	/* For setting the registers, we only need to enable the ipg clock. */
-	retval = clk_prepare_enable(sport->clk_ipg);
-	if (retval)
-		goto error_console;
+	pm_runtime_get_sync(sport->dev);
 
 	if (options)
 		uart_parse_options(options, &baud, &parity, &bits, &flow);
@@ -1779,9 +1830,8 @@ imx_console_setup(struct console *co, char *options)
 
 	retval = uart_set_options(&sport->port, co, baud, parity, bits, flow);
 
-	clk_disable_unprepare(sport->clk_ipg);
-
-error_console:
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
 	return retval;
 }
 
@@ -1963,16 +2013,39 @@ static int serial_imx_probe(struct platform_device *pdev)
 
 	imx_ports[sport->port.line] = sport;
 
+	sport->dev = &pdev->dev;
 	platform_set_drvdata(pdev, sport);
 
-	return uart_add_one_port(&imx_reg, &sport->port);
+	device_init_wakeup(sport->dev, true);
+	pm_runtime_use_autosuspend(sport->dev);
+	pm_runtime_set_autosuspend_delay(sport->dev, 5000);
+
+	pm_runtime_irq_safe(sport->dev);
+	pm_runtime_enable(sport->dev);
+
+	clk_prepare(sport->clk_per);
+	clk_prepare(sport->clk_ipg);
+	pm_runtime_get_sync(sport->dev);
+	ret = uart_add_one_port(&imx_reg, &sport->port);
+	pm_runtime_mark_last_busy(sport->dev);
+	pm_runtime_put_autosuspend(sport->dev);
+
+	return ret;
 }
 
 static int serial_imx_remove(struct platform_device *pdev)
 {
 	struct imx_port *sport = platform_get_drvdata(pdev);
+	int ret;
+
+	pm_runtime_put_sync(sport->dev);
+	pm_runtime_disable(sport->dev);
+	clk_unprepare(sport->clk_per);
+	clk_unprepare(sport->clk_ipg);
+	ret = uart_remove_one_port(&imx_reg, &sport->port);
+	device_init_wakeup(&pdev->dev, false);
 
-	return uart_remove_one_port(&imx_reg, &sport->port);
+	return ret;
 }
 
 static void serial_imx_restore_context(struct imx_port *sport)
@@ -2028,6 +2101,52 @@ static void serial_imx_enable_wakeup(struct imx_port *sport, bool on)
 	writel(val, sport->port.membase + UCR1);
 }
 
+static int serial_imx_runtime_suspend(struct device *dev)
+{
+	struct imx_port *sport = dev_get_drvdata(dev);
+
+	if (!sport)
+		return -EINVAL;
+
+	/*
+	* When using 'no_console_suspend', the console UART must not be
+	* suspended. Since driver suspend is managed by runtime suspend,
+	* preventing runtime suspend (by returning error) will keep device
+	* active during suspend.
+	*/
+	if (sport->is_suspending && !console_suspend_enabled &&
+	    uart_console(&sport->port))
+		return -EBUSY;
+
+	serial_imx_save_context(sport);
+	serial_imx_enable_wakeup(sport, true);
+
+	clk_disable(sport->clk_per);
+	clk_disable(sport->clk_ipg);
+
+	return 0;
+}
+
+static int serial_imx_runtime_resume(struct device *dev)
+{
+	struct imx_port *sport = dev_get_drvdata(dev);
+	int ret;
+
+	ret = clk_enable(sport->clk_per);
+	if (ret)
+		return ret;
+	ret = clk_enable(sport->clk_ipg);
+	if (ret) {
+		clk_disable(sport->clk_per);
+		return ret;
+	}
+	serial_imx_enable_wakeup(sport, false);
+
+	serial_imx_restore_context(sport);
+
+	return 0;
+}
+
 static int serial_imx_prepare(struct device *dev)
 {
 	struct imx_port *sport = dev_get_drvdata(dev);
@@ -2087,6 +2206,8 @@ static int imx_serial_port_suspend(struct device *dev)
 	serial_imx_enable_wakeup(sport, true);
 
 	uart_suspend_port(&imx_reg, &sport->port);
+	clk_disable_unprepare(sport->clk_per);
+	clk_disable_unprepare(sport->clk_ipg);
 
 	return 0;
 }
@@ -2095,7 +2216,16 @@ static int imx_serial_port_resume(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
 	struct imx_port *sport = platform_get_drvdata(pdev);
+	int ret;
 
+	ret = clk_prepare_enable(sport->clk_per);
+	if (ret)
+		return ret;
+	ret = clk_prepare_enable(sport->clk_ipg);
+	if (ret) {
+		clk_disable_unprepare(sport->clk_per);
+		return ret;
+	}
 	/* disable wakeup from i.MX UART */
 	serial_imx_enable_wakeup(sport, false);
 
@@ -2105,6 +2235,8 @@ static int imx_serial_port_resume(struct device *dev)
 }
 
 static const struct dev_pm_ops imx_serial_port_pm_ops = {
+	SET_RUNTIME_PM_OPS(serial_imx_runtime_suspend,
+			   serial_imx_runtime_resume, NULL)
 	.suspend_noirq = imx_serial_port_suspend_noirq,
 	.resume_noirq = imx_serial_port_resume_noirq,
 	.suspend = imx_serial_port_suspend,
-- 
2.5.0

Re: [PATCHv3 6/8] serial: imx: add runtime pm support

[Greg Kroah-Hartman]

On Tue, Aug 11, 2015 at 10:21:25AM -0700, Eduardo Valentin wrote:
> This change introduces the runtime pm support on imx serial
> driver. The objective is to be able to idle the uart
> port whenever it is not in use while still being able
> to wake it up when needed. The key changes in this patch are:
> 1. Move the clock handling to runtime pm. Both, ipg and per,
> are now handled in the suspend and resume callbacks. Only
> enabling and disabling the clocks are handled in runtime
> suspend and resume, so we are able to use runtime pm
> in IRQ context.
> 2. Clocks are prepared in probe and unprepared in remove,
> so we do not need to prepare (may sleep) in runtime pm.
> 3. We mark the device activity based on uart and console
> callbacks. Whenever the device is needed and we want to
> access registers, we runtime_pm_get and then mark its
> last usage when we are done. This is done also across
> IRQs and DMA callbacks.
> 4. We reuse the infrastructure in place for suspend and
> resume, so we do not need to redo wakeup configuration,
> or context save and restore.
> 
> After this change, the clocks are still sane, in the sense
> of having balanced clock prepare and enable.
> 
> Cc: Fabio Estevam <festevam@gmail.com>
> Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
> Cc: Jiri Slaby <jslaby@suse.com>
> Cc: linux-serial@vger.kernel.org
> Cc: linux-kernel@vger.kernel.org
> Signed-off-by: Eduardo Valentin <edubezval@gmail.com>
> ---
>  drivers/tty/serial/imx.c | 224 +++++++++++++++++++++++++++++++++++++----------
>  1 file changed, 178 insertions(+), 46 deletions(-)
> 
> diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c
> index 50abb60..9447a55 100644
> --- a/drivers/tty/serial/imx.c
> +++ b/drivers/tty/serial/imx.c
> @@ -39,6 +39,9 @@
>  #include <linux/of_device.h>
>  #include <linux/io.h>
>  #include <linux/dma-mapping.h>
> +#include <linux/pm.h>
> +#include <linux/pm_runtime.h>
> +#include <linux/pm_wakeup.h>
>  
>  #include <asm/irq.h>
>  #include <linux/platform_data/serial-imx.h>
> @@ -219,6 +222,7 @@ struct imx_port {
>  	unsigned int            saved_reg[10];
>  	bool			context_saved;
>  
> +	struct device		*dev;

Do you really need this pointer?  Can't you get it from the platform
device that you have access to that sport is the data?

thanks,

greg k-h

Re: [PATCHv3 6/8] serial: imx: add runtime pm support

[Eduardo Valentin]

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

On Fri, Aug 14, 2015 at 05:23:12PM -0700, Greg Kroah-Hartman wrote:
> On Tue, Aug 11, 2015 at 10:21:25AM -0700, Eduardo Valentin wrote:
> > This change introduces the runtime pm support on imx serial
> > driver. The objective is to be able to idle the uart
> > port whenever it is not in use while still being able
> > to wake it up when needed. The key changes in this patch are:
> > 1. Move the clock handling to runtime pm. Both, ipg and per,
> > are now handled in the suspend and resume callbacks. Only
> > enabling and disabling the clocks are handled in runtime
> > suspend and resume, so we are able to use runtime pm
> > in IRQ context.
> > 2. Clocks are prepared in probe and unprepared in remove,
> > so we do not need to prepare (may sleep) in runtime pm.
> > 3. We mark the device activity based on uart and console
> > callbacks. Whenever the device is needed and we want to
> > access registers, we runtime_pm_get and then mark its
> > last usage when we are done. This is done also across
> > IRQs and DMA callbacks.
> > 4. We reuse the infrastructure in place for suspend and
> > resume, so we do not need to redo wakeup configuration,
> > or context save and restore.
> > 
> > After this change, the clocks are still sane, in the sense
> > of having balanced clock prepare and enable.
> > 
> > Cc: Fabio Estevam <festevam@gmail.com>
> > Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
> > Cc: Jiri Slaby <jslaby@suse.com>
> > Cc: linux-serial@vger.kernel.org
> > Cc: linux-kernel@vger.kernel.org
> > Signed-off-by: Eduardo Valentin <edubezval@gmail.com>
> > ---
> >  drivers/tty/serial/imx.c | 224 +++++++++++++++++++++++++++++++++++++----------
> >  1 file changed, 178 insertions(+), 46 deletions(-)
> > 
> > diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c
> > index 50abb60..9447a55 100644
> > --- a/drivers/tty/serial/imx.c
> > +++ b/drivers/tty/serial/imx.c
> > @@ -39,6 +39,9 @@
> >  #include <linux/of_device.h>
> >  #include <linux/io.h>
> >  #include <linux/dma-mapping.h>
> > +#include <linux/pm.h>
> > +#include <linux/pm_runtime.h>
> > +#include <linux/pm_wakeup.h>
> >  
> >  #include <asm/irq.h>
> >  #include <linux/platform_data/serial-imx.h>
> > @@ -219,6 +222,7 @@ struct imx_port {
> >  	unsigned int            saved_reg[10];
> >  	bool			context_saved;
> >  
> > +	struct device		*dev;
> 
> Do you really need this pointer?  Can't you get it from the platform
> device that you have access to that sport is the data?

Actually, not really. I can change the code to the one in sport. I will
be resending soon.

> 
> thanks,
> 
> greg k-h

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 490 bytes --]

[PATCHv3 7/8] serial: imx: add pm_qos request

[Eduardo Valentin]

This change introduces pm_qos requests in the imx serial driver.
The idea is to skip deeper C-state in case we need a strict
latency requirement in the uart port. The latency is
computed based on the buffer size and the current baud rate.
We schedule a work queue to set the pm qos requirement.

Cc: Fabio Estevam <festevam@gmail.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Jiri Slaby <jslaby@suse.com>
Cc: linux-serial@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Eduardo Valentin <edubezval@gmail.com>
---
 drivers/tty/serial/imx.c | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c
index 9447a55..4aab9fc 100644
--- a/drivers/tty/serial/imx.c
+++ b/drivers/tty/serial/imx.c
@@ -42,6 +42,7 @@
 #include <linux/pm.h>
 #include <linux/pm_runtime.h>
 #include <linux/pm_wakeup.h>
+#include <linux/pm_qos.h>
 
 #include <asm/irq.h>
 #include <linux/platform_data/serial-imx.h>
@@ -223,6 +224,10 @@ struct imx_port {
 	bool			context_saved;
 
 	struct device		*dev;
+	struct pm_qos_request	pm_qos_request;
+	u32			latency;
+	u32			calc_latency;
+	struct work_struct	qos_work;
 	bool			is_suspending;
 };
 
@@ -1321,6 +1326,14 @@ static void imx_flush_buffer(struct uart_port *port)
 	pm_runtime_put_autosuspend(sport->dev);
 }
 
+static void serial_imx_uart_qos_work(struct work_struct *work)
+{
+	struct imx_port *sport = container_of(work, struct imx_port,
+						qos_work);
+
+	pm_qos_update_request(&sport->pm_qos_request, sport->latency);
+}
+
 static void
 imx_set_termios(struct uart_port *port, struct ktermios *termios,
 		   struct ktermios *old)
@@ -1394,6 +1407,12 @@ imx_set_termios(struct uart_port *port, struct ktermios *termios,
 	baud = uart_get_baud_rate(port, termios, old, 50, port->uartclk / 16);
 	quot = uart_get_divisor(port, baud);
 
+	/* calculate wakeup latency constraint */
+	sport->calc_latency = (USEC_PER_SEC * sport->port.fifosize) /
+								(baud / 8);
+	sport->latency = sport->calc_latency;
+	schedule_work(&sport->qos_work);
+
 	spin_lock_irqsave(&sport->port.lock, flags);
 
 	sport->port.read_status_mask = 0;
@@ -2013,7 +2032,12 @@ static int serial_imx_probe(struct platform_device *pdev)
 
 	imx_ports[sport->port.line] = sport;
 
+	sport->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
+	sport->calc_latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
 	sport->dev = &pdev->dev;
+	pm_qos_add_request(&sport->pm_qos_request, PM_QOS_CPU_DMA_LATENCY,
+			   sport->latency);
+	INIT_WORK(&sport->qos_work, serial_imx_uart_qos_work);
 	platform_set_drvdata(pdev, sport);
 
 	device_init_wakeup(sport->dev, true);
@@ -2043,6 +2067,7 @@ static int serial_imx_remove(struct platform_device *pdev)
 	clk_unprepare(sport->clk_per);
 	clk_unprepare(sport->clk_ipg);
 	ret = uart_remove_one_port(&imx_reg, &sport->port);
+	pm_qos_remove_request(&sport->pm_qos_request);
 	device_init_wakeup(&pdev->dev, false);
 
 	return ret;
@@ -2121,6 +2146,8 @@ static int serial_imx_runtime_suspend(struct device *dev)
 	serial_imx_save_context(sport);
 	serial_imx_enable_wakeup(sport, true);
 
+	sport->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
+	schedule_work(&sport->qos_work);
 	clk_disable(sport->clk_per);
 	clk_disable(sport->clk_ipg);
 
@@ -2142,6 +2169,8 @@ static int serial_imx_runtime_resume(struct device *dev)
 	}
 	serial_imx_enable_wakeup(sport, false);
 
+	sport->latency = sport->calc_latency;
+	schedule_work(&sport->qos_work);
 	serial_imx_restore_context(sport);
 
 	return 0;
-- 
2.5.0

[PATCHv3 8/8] serial: imx: use SET_*SYSTEM_PM_OPS helper functions

[Eduardo Valentin]

Instead of setting manually each field, use the helper functions
provided by the PM subsystem.

Signed-off-by: Eduardo Valentin <edubezval@gmail.com>
---
 drivers/tty/serial/imx.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c
index 4aab9fc..4c3cd62 100644
--- a/drivers/tty/serial/imx.c
+++ b/drivers/tty/serial/imx.c
@@ -2266,10 +2266,10 @@ static int imx_serial_port_resume(struct device *dev)
 static const struct dev_pm_ops imx_serial_port_pm_ops = {
 	SET_RUNTIME_PM_OPS(serial_imx_runtime_suspend,
 			   serial_imx_runtime_resume, NULL)
-	.suspend_noirq = imx_serial_port_suspend_noirq,
-	.resume_noirq = imx_serial_port_resume_noirq,
-	.suspend = imx_serial_port_suspend,
-	.resume = imx_serial_port_resume,
+	SET_SYSTEM_SLEEP_PM_OPS(imx_serial_port_suspend_noirq,
+				imx_serial_port_resume_noirq)
+	SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(imx_serial_port_suspend,
+				      imx_serial_port_resume)
 	.prepare = serial_imx_prepare,
 	.complete = serial_imx_complete,
 };
-- 
2.5.0