On 10/16/20 3:43 PM, Joakim Zhang wrote: > The System Controller Firmware (SCFW) is a low-level system function > which runs on a dedicated Cortex-M core to provide power, clock, and > resource management. It exists on some i.MX8 processors. e.g. i.MX8QM > (QM, QP), and i.MX8QX (QXP, DX). SCU driver manages the IPC interface > between host CPU and the SCU firmware running on M4. > > For i.MX8QM, stop mode request is controlled by System Controller Unit(SCU) > firmware, this patch introduces FLEXCAN_QUIRK_SETUP_STOP_MODE_SCFW quirk > for this function. > > Signed-off-by: Joakim Zhang > --- > drivers/net/can/flexcan.c | 125 ++++++++++++++++++++++++++++++++------ > 1 file changed, 107 insertions(+), 18 deletions(-) > > diff --git a/drivers/net/can/flexcan.c b/drivers/net/can/flexcan.c > index e708e7bf28db..a55ea8f27f7c 100644 > --- a/drivers/net/can/flexcan.c > +++ b/drivers/net/can/flexcan.c > @@ -9,6 +9,7 @@ > // > // Based on code originally by Andrey Volkov > > +#include > #include > #include > #include > @@ -17,6 +18,7 @@ > #include > #include > #include > +#include > #include > #include > #include > @@ -242,6 +244,8 @@ > #define FLEXCAN_QUIRK_SUPPORT_FD BIT(9) > /* support memory detection and correction */ > #define FLEXCAN_QUIRK_SUPPORT_ECC BIT(10) > +/* Setup stop mode with SCU firmware to support wakeup */ > +#define FLEXCAN_QUIRK_SETUP_STOP_MODE_SCFW BIT(11) > > /* Structure of the message buffer */ > struct flexcan_mb { > @@ -347,6 +351,7 @@ struct flexcan_priv { > u8 mb_count; > u8 mb_size; > u8 clk_src; /* clock source of CAN Protocol Engine */ > + u8 can_idx; > > u64 rx_mask; > u64 tx_mask; > @@ -358,6 +363,9 @@ struct flexcan_priv { > struct regulator *reg_xceiver; > struct flexcan_stop_mode stm; > > + /* IPC handle when setup stop mode by System Controller firmware(scfw) */ > + struct imx_sc_ipc *sc_ipc_handle; > + > /* Read and Write APIs */ > u32 (*read)(void __iomem *addr); > void (*write)(u32 val, void __iomem *addr); > @@ -387,7 +395,7 @@ static const struct flexcan_devtype_data fsl_imx6q_devtype_data = { > static const struct flexcan_devtype_data fsl_imx8qm_devtype_data = { > .quirks = FLEXCAN_QUIRK_DISABLE_RXFG | FLEXCAN_QUIRK_ENABLE_EACEN_RRS | > FLEXCAN_QUIRK_USE_OFF_TIMESTAMP | FLEXCAN_QUIRK_BROKEN_PERR_STATE | > - FLEXCAN_QUIRK_SUPPORT_FD, > + FLEXCAN_QUIRK_SUPPORT_FD | FLEXCAN_QUIRK_SETUP_STOP_MODE_SCFW, > }; > > static struct flexcan_devtype_data fsl_imx8mp_devtype_data = { > @@ -546,18 +554,46 @@ static void flexcan_enable_wakeup_irq(struct flexcan_priv *priv, bool enable) > priv->write(reg_mcr, ®s->mcr); > } > > +static int flexcan_stop_mode_enable_scfw(struct flexcan_priv *priv, bool enabled) > +{ > + u8 idx = priv->can_idx; > + u32 rsrc_id, val; > + > + if (idx == 0) > + rsrc_id = IMX_SC_R_CAN_0; > + else if (idx == 1) > + rsrc_id = IMX_SC_R_CAN_1; > + else > + rsrc_id = IMX_SC_R_CAN_2; > + > + if (enabled) > + val = 1; > + else > + val = 0; > + > + /* stop mode request via scu firmware */ > + return imx_sc_misc_set_control(priv->sc_ipc_handle, rsrc_id, IMX_SC_C_IPG_STOP, val); > +} > + > static inline int flexcan_enter_stop_mode(struct flexcan_priv *priv) > { > struct flexcan_regs __iomem *regs = priv->regs; > u32 reg_mcr; > + int ret; > > reg_mcr = priv->read(®s->mcr); > reg_mcr |= FLEXCAN_MCR_SLF_WAK; > priv->write(reg_mcr, ®s->mcr); > > /* enable stop request */ > - regmap_update_bits(priv->stm.gpr, priv->stm.req_gpr, > - 1 << priv->stm.req_bit, 1 << priv->stm.req_bit); > + if (priv->devtype_data->quirks & FLEXCAN_QUIRK_SETUP_STOP_MODE_SCFW) { > + ret = flexcan_stop_mode_enable_scfw(priv, true); > + if (ret < 0) > + return ret; > + } else { > + regmap_update_bits(priv->stm.gpr, priv->stm.req_gpr, > + 1 << priv->stm.req_bit, 1 << priv->stm.req_bit); > + } > > return flexcan_low_power_enter_ack(priv); > } > @@ -566,10 +602,17 @@ static inline int flexcan_exit_stop_mode(struct flexcan_priv *priv) > { > struct flexcan_regs __iomem *regs = priv->regs; > u32 reg_mcr; > + int ret; > > /* remove stop request */ > - regmap_update_bits(priv->stm.gpr, priv->stm.req_gpr, > - 1 << priv->stm.req_bit, 0); > + if (priv->devtype_data->quirks & FLEXCAN_QUIRK_SETUP_STOP_MODE_SCFW) { > + ret = flexcan_stop_mode_enable_scfw(priv, false); > + if (ret < 0) > + return ret; > + } else { > + regmap_update_bits(priv->stm.gpr, priv->stm.req_gpr, > + 1 << priv->stm.req_bit, 0); > + } > > reg_mcr = priv->read(®s->mcr); > reg_mcr &= ~FLEXCAN_MCR_SLF_WAK; > @@ -1838,7 +1881,7 @@ static void unregister_flexcandev(struct net_device *dev) > unregister_candev(dev); > } > > -static int flexcan_setup_stop_mode(struct platform_device *pdev) > +static int flexcan_setup_stop_mode_gpr(struct platform_device *pdev) > { > struct net_device *dev = platform_get_drvdata(pdev); > struct device_node *np = pdev->dev.of_node; > @@ -1883,11 +1926,6 @@ static int flexcan_setup_stop_mode(struct platform_device *pdev) > "gpr %s req_gpr=0x02%x req_bit=%u\n", > gpr_np->full_name, priv->stm.req_gpr, priv->stm.req_bit); > > - device_set_wakeup_capable(&pdev->dev, true); > - > - if (of_property_read_bool(np, "wakeup-source")) > - device_set_wakeup_enable(&pdev->dev, true); > - > return 0; > > out_put_node: > @@ -1895,6 +1933,56 @@ static int flexcan_setup_stop_mode(struct platform_device *pdev) > return ret; > } > > +static int flexcan_setup_stop_mode_scfw(struct platform_device *pdev) > +{ > + struct net_device *dev = platform_get_drvdata(pdev); > + struct flexcan_priv *priv; > + int ret; > + > + priv = netdev_priv(dev); > + > + /* this function could be defer probe, return -EPROBE_DEFER */ > + ret = imx_scu_get_handle(&priv->sc_ipc_handle); > + if (ret < 0) > + dev_dbg(&pdev->dev, "get ipc handle used by SCU failed\n"); > + > + return ret; > +} > + > +/* flexcan_setup_stop_mode - Setup stop mode > + * > + * Return: 0 setup stop mode successfully or doesn't support this feature > + * -EPROBE_DEFER defer probe > + * < 0 fail to setup stop mode > + */ > +static int flexcan_setup_stop_mode(struct platform_device *pdev) > +{ > + struct net_device *dev = platform_get_drvdata(pdev); > + struct flexcan_priv *priv; > + int ret; > + > + priv = netdev_priv(dev); > + > + if (priv->devtype_data->quirks & FLEXCAN_QUIRK_SETUP_STOP_MODE_SCFW) > + ret = flexcan_setup_stop_mode_scfw(pdev); > + else if (priv->devtype_data->quirks & FLEXCAN_QUIRK_SETUP_STOP_MODE_GPR) > + ret = flexcan_setup_stop_mode_gpr(pdev); > + else > + /* return 0 directly if stop mode is unsupport */ > + return 0; > + > + if (ret) { > + dev_warn(&pdev->dev, "failed to setup stop mode\n"); > + } else { > + device_set_wakeup_capable(&pdev->dev, true); > + > + if (of_property_read_bool(pdev->dev.of_node, "wakeup-source")) > + device_set_wakeup_enable(&pdev->dev, true); > + } > + > + return ret; > +} > + > static const struct of_device_id flexcan_of_match[] = { > { .compatible = "fsl,imx8qm-flexcan", .data = &fsl_imx8qm_devtype_data, }, > { .compatible = "fsl,imx8mp-flexcan", .data = &fsl_imx8mp_devtype_data, }, > @@ -1927,7 +2015,7 @@ static int flexcan_probe(struct platform_device *pdev) > struct clk *clk_ipg = NULL, *clk_per = NULL; > struct flexcan_regs __iomem *regs; > int err, irq; > - u8 clk_src = 1; > + u8 clk_src = 1, can_idx = 0; > u32 clock_freq = 0; > > reg_xceiver = devm_regulator_get_optional(&pdev->dev, "xceiver"); > @@ -1943,6 +2031,8 @@ static int flexcan_probe(struct platform_device *pdev) > "clock-frequency", &clock_freq); > of_property_read_u8(pdev->dev.of_node, > "fsl,clk-source", &clk_src); > + of_property_read_u8(pdev->dev.of_node, > + "fsl,can-index", &can_idx); > } > > if (!clock_freq) { > @@ -2019,6 +2109,7 @@ static int flexcan_probe(struct platform_device *pdev) > priv->clk_src = clk_src; > priv->devtype_data = devtype_data; > priv->reg_xceiver = reg_xceiver; > + priv->can_idx = can_idx; > > if (priv->devtype_data->quirks & FLEXCAN_QUIRK_SUPPORT_FD) { > priv->can.ctrlmode_supported |= CAN_CTRLMODE_FD | > @@ -2030,6 +2121,10 @@ static int flexcan_probe(struct platform_device *pdev) > priv->can.bittiming_const = &flexcan_bittiming_const; > } > > + err = flexcan_setup_stop_mode(pdev); > + if (err == -EPROBE_DEFER) > + return -EPROBE_DEFER; You need to free "dev". What about moving this directly before allocating dev. Do you have to undo device_set_wakeup_capable() and device_set_wakeup_enable() in case of a failure and/or on flexcan_remove()? > + > pm_runtime_get_noresume(&pdev->dev); > pm_runtime_set_active(&pdev->dev); > pm_runtime_enable(&pdev->dev); > @@ -2043,12 +2138,6 @@ static int flexcan_probe(struct platform_device *pdev) > of_can_transceiver(dev); > devm_can_led_init(dev); > > - if (priv->devtype_data->quirks & FLEXCAN_QUIRK_SETUP_STOP_MODE_GPR) { > - err = flexcan_setup_stop_mode(pdev); > - if (err) > - dev_dbg(&pdev->dev, "failed to setup stop-mode\n"); > - } > - > return 0; > > failed_register: > Marc -- Pengutronix e.K. | Marc Kleine-Budde | Embedded Linux | https://www.pengutronix.de | Vertretung West/Dortmund | Phone: +49-231-2826-924 | Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |