From mboxrd@z Thu Jan 1 00:00:00 1970 From: Joakim Zhang Subject: [PATCH] can: flexcan: Implement CAN Runtime PM Date: Fri, 19 Oct 2018 09:45:44 +0000 Message-ID: <20181019094326.28185-1-qiangqing.zhang@nxp.com> Mime-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: quoted-printable Return-path: Content-Language: en-US Sender: linux-kernel-owner@vger.kernel.org To: "wg@grandegger.com" , "mkl@pengutronix.de" , "davem@davemloft.net" Cc: "linux-can@vger.kernel.org" , "netdev@vger.kernel.org" , "linux-kernel@vger.kernel.org" , dl-linux-imx , "A.s. Dong" , Joakim Zhang List-Id: linux-can.vger.kernel.org From: Dong Aisheng Flexcan will be disabled during suspend if no wakeup function required and enabled after resume accordingly. During this period, we could explicitly disable clocks. Implement Runtime PM which will: 1) Keep device in suspend state (clocks disabled) if it's not openned 2) Make Power Domain framework be able to shutdown the corresponding power domain of this device. Signed-off-by: Dong Aisheng Signed-off-by: Joakim Zhang --- drivers/net/can/flexcan.c | 125 +++++++++++++++++++++++++------------- 1 file changed, 82 insertions(+), 43 deletions(-) diff --git a/drivers/net/can/flexcan.c b/drivers/net/can/flexcan.c index 8e972ef08637..3813f6708201 100644 --- a/drivers/net/can/flexcan.c +++ b/drivers/net/can/flexcan.c @@ -23,6 +23,7 @@ #include #include #include +#include #include =20 #define DRV_NAME "flexcan" @@ -266,6 +267,7 @@ struct flexcan_priv { u32 reg_imask1_default; u32 reg_imask2_default; =20 + struct device *dev; struct clk *clk_ipg; struct clk *clk_per; const struct flexcan_devtype_data *devtype_data; @@ -369,6 +371,27 @@ static inline void flexcan_error_irq_disable(const str= uct flexcan_priv *priv) priv->write(reg_ctrl, ®s->ctrl); } =20 +static int flexcan_clks_enable(const struct flexcan_priv *priv) +{ + int err; + + err =3D clk_prepare_enable(priv->clk_ipg); + if (err) + return err; + + err =3D clk_prepare_enable(priv->clk_per); + if (err) + clk_disable_unprepare(priv->clk_ipg); + + return err; +} + +static void flexcan_clks_disable(const struct flexcan_priv *priv) +{ + clk_disable_unprepare(priv->clk_ipg); + clk_disable_unprepare(priv->clk_per); +} + static inline int flexcan_transceiver_enable(const struct flexcan_priv *pr= iv) { if (!priv->reg_xceiver) @@ -495,19 +518,11 @@ static int flexcan_get_berr_counter(const struct net_= device *dev, const struct flexcan_priv *priv =3D netdev_priv(dev); int err; =20 - err =3D clk_prepare_enable(priv->clk_ipg); - if (err) - return err; - - err =3D clk_prepare_enable(priv->clk_per); - if (err) - goto out_disable_ipg; + pm_runtime_get_sync(priv->dev); =20 err =3D __flexcan_get_berr_counter(dev, bec); =20 - clk_disable_unprepare(priv->clk_per); - out_disable_ipg: - clk_disable_unprepare(priv->clk_ipg); + pm_runtime_put(priv->dev); =20 return err; } @@ -1096,17 +1111,13 @@ static int flexcan_open(struct net_device *dev) struct flexcan_priv *priv =3D netdev_priv(dev); int err; =20 - err =3D clk_prepare_enable(priv->clk_ipg); + err =3D pm_runtime_get_sync(priv->dev); if (err) return err; =20 - err =3D clk_prepare_enable(priv->clk_per); - if (err) - goto out_disable_ipg; - err =3D open_candev(dev); if (err) - goto out_disable_per; + goto out_pm_runtime; =20 err =3D request_irq(dev->irq, flexcan_irq, IRQF_SHARED, dev->name, dev); if (err) @@ -1128,10 +1139,8 @@ static int flexcan_open(struct net_device *dev) free_irq(dev->irq, dev); out_close: close_candev(dev); - out_disable_per: - clk_disable_unprepare(priv->clk_per); - out_disable_ipg: - clk_disable_unprepare(priv->clk_ipg); + out_pm_runtime: + pm_runtime_put(priv->dev); =20 return err; } @@ -1145,11 +1154,11 @@ static int flexcan_close(struct net_device *dev) flexcan_chip_stop(dev); =20 free_irq(dev->irq, dev); - clk_disable_unprepare(priv->clk_per); - clk_disable_unprepare(priv->clk_ipg); =20 close_candev(dev); =20 + pm_runtime_put(priv->dev); + can_led_event(dev, CAN_LED_EVENT_STOP); =20 return 0; @@ -1188,18 +1197,10 @@ static int register_flexcandev(struct net_device *d= ev) struct flexcan_regs __iomem *regs =3D priv->regs; u32 reg, err; =20 - err =3D clk_prepare_enable(priv->clk_ipg); - if (err) - return err; - - err =3D clk_prepare_enable(priv->clk_per); - if (err) - goto out_disable_ipg; - /* select "bus clock", chip must be disabled */ err =3D flexcan_chip_disable(priv); if (err) - goto out_disable_per; + return err; reg =3D priv->read(®s->ctrl); reg |=3D FLEXCAN_CTRL_CLK_SRC; priv->write(reg, ®s->ctrl); @@ -1228,13 +1229,8 @@ static int register_flexcandev(struct net_device *de= v) =20 err =3D register_candev(dev); =20 - /* disable core and turn off clocks */ out_chip_disable: flexcan_chip_disable(priv); - out_disable_per: - clk_disable_unprepare(priv->clk_per); - out_disable_ipg: - clk_disable_unprepare(priv->clk_ipg); =20 return err; } @@ -1342,6 +1338,7 @@ static int flexcan_probe(struct platform_device *pdev= ) priv->write =3D flexcan_write_le; } =20 + priv->dev =3D &pdev->dev; priv->can.clock.freq =3D clock_freq; priv->can.bittiming_const =3D &flexcan_bittiming_const; priv->can.do_set_mode =3D flexcan_set_mode; @@ -1388,22 +1385,35 @@ static int flexcan_probe(struct platform_device *pd= ev) if (err) goto failed_offload; =20 + pm_runtime_enable(&pdev->dev); + err =3D pm_runtime_get_sync(&pdev->dev); + if (err < 0) { + dev_err(&pdev->dev, "pm_runtime_get failed(%d)\n", err); + goto failed_rpm_disable; + } + err =3D register_flexcandev(dev); if (err) { dev_err(&pdev->dev, "registering netdev failed\n"); - goto failed_register; + goto failed_rpm_put; } =20 devm_can_led_init(dev); =20 + pm_runtime_put(&pdev->dev); + dev_info(&pdev->dev, "device registered (reg_base=3D%p, irq=3D%d)\n", priv->regs, dev->irq); =20 return 0; =20 + failed_rpm_put: + pm_runtime_put(&pdev->dev); + failed_rpm_disable: + pm_runtime_disable(&pdev->dev); failed_offload: - failed_register: free_candev(dev); + return err; } =20 @@ -1413,6 +1423,7 @@ static int flexcan_remove(struct platform_device *pde= v) struct flexcan_priv *priv =3D netdev_priv(dev); =20 unregister_flexcandev(dev); + pm_runtime_disable(&pdev->dev); can_rx_offload_del(&priv->offload); free_candev(dev); =20 @@ -1423,38 +1434,66 @@ static int __maybe_unused flexcan_suspend(struct de= vice *device) { struct net_device *dev =3D dev_get_drvdata(device); struct flexcan_priv *priv =3D netdev_priv(dev); - int err; + int err =3D 0; =20 if (netif_running(dev)) { err =3D flexcan_chip_disable(priv); if (err) return err; + err =3D pm_runtime_force_suspend(device); + netif_stop_queue(dev); netif_device_detach(dev); } priv->can.state =3D CAN_STATE_SLEEPING; =20 - return 0; + return err; } =20 static int __maybe_unused flexcan_resume(struct device *device) { struct net_device *dev =3D dev_get_drvdata(device); struct flexcan_priv *priv =3D netdev_priv(dev); - int err; + int err =3D 0; =20 priv->can.state =3D CAN_STATE_ERROR_ACTIVE; if (netif_running(dev)) { netif_device_attach(dev); netif_start_queue(dev); - err =3D flexcan_chip_enable(priv); + + err =3D pm_runtime_force_resume(device); if (err) return err; + err =3D flexcan_chip_enable(priv); } + return err; +} + +static int __maybe_unused flexcan_runtime_suspend(struct device *device) +{ + struct net_device *dev =3D dev_get_drvdata(device); + struct flexcan_priv *priv =3D netdev_priv(dev); + + flexcan_clks_disable(priv); + return 0; } =20 -static SIMPLE_DEV_PM_OPS(flexcan_pm_ops, flexcan_suspend, flexcan_resume); +static int __maybe_unused flexcan_runtime_resume(struct device *device) +{ + struct net_device *dev =3D dev_get_drvdata(device); + struct flexcan_priv *priv =3D netdev_priv(dev); + + flexcan_clks_enable(priv); + + return 0; +} + +static const struct dev_pm_ops flexcan_pm_ops =3D { + SET_SYSTEM_SLEEP_PM_OPS(flexcan_suspend, flexcan_resume) + SET_RUNTIME_PM_OPS(flexcan_runtime_suspend, flexcan_runtime_resume, + NULL) +}; =20 static struct platform_driver flexcan_driver =3D { .driver =3D { --=20 2.17.1