12bb70056SOleksij Rempel // SPDX-License-Identifier: GPL-2.0
22bb70056SOleksij Rempel /*
32bb70056SOleksij Rempel * Copyright (c) 2018 Pengutronix, Oleksij Rempel <o.rempel@pengutronix.de>
4a5cb407aSPeng Fan * Copyright 2022 NXP, Peng Fan <peng.fan@nxp.com>
52bb70056SOleksij Rempel */
62bb70056SOleksij Rempel
72bb70056SOleksij Rempel #include <linux/clk.h>
80a67003bSPeng Fan #include <linux/firmware/imx/ipc.h>
997961f78SPeng Fan #include <linux/firmware/imx/s4.h>
102bb70056SOleksij Rempel #include <linux/interrupt.h>
112bb70056SOleksij Rempel #include <linux/io.h>
120a67003bSPeng Fan #include <linux/iopoll.h>
1311dac1d3SFranck LENORMAND #include <linux/jiffies.h>
142bb70056SOleksij Rempel #include <linux/kernel.h>
152bb70056SOleksij Rempel #include <linux/mailbox_controller.h>
162bb70056SOleksij Rempel #include <linux/module.h>
17*e9803aacSRob Herring #include <linux/of.h>
18*e9803aacSRob Herring #include <linux/platform_device.h>
19676f23eaSAnson Huang #include <linux/pm_runtime.h>
20892cb524SRobin Gong #include <linux/suspend.h>
212bb70056SOleksij Rempel #include <linux/slab.h>
222bb70056SOleksij Rempel
2382ab513bSPeng Fan #define IMX_MU_CHANS 17
240a67003bSPeng Fan /* TX0/RX0/RXDB[0-3] */
250a67003bSPeng Fan #define IMX_MU_SCU_CHANS 6
2697961f78SPeng Fan /* TX0/RX0 */
2797961f78SPeng Fan #define IMX_MU_S4_CHANS 2
282bb70056SOleksij Rempel #define IMX_MU_CHAN_NAME_SIZE 20
292bb70056SOleksij Rempel
308a8dc2b9SPeng Fan #define IMX_MU_NUM_RR 4
318a8dc2b9SPeng Fan
3211dac1d3SFranck LENORMAND #define IMX_MU_SECO_TX_TOUT (msecs_to_jiffies(3000))
3311dac1d3SFranck LENORMAND #define IMX_MU_SECO_RX_TOUT (msecs_to_jiffies(3000))
3411dac1d3SFranck LENORMAND
35a5cb407aSPeng Fan /* Please not change TX & RX */
362bb70056SOleksij Rempel enum imx_mu_chan_type {
37a5cb407aSPeng Fan IMX_MU_TYPE_TX = 0, /* Tx */
38a5cb407aSPeng Fan IMX_MU_TYPE_RX = 1, /* Rx */
39a5cb407aSPeng Fan IMX_MU_TYPE_TXDB = 2, /* Tx doorbell */
40a5cb407aSPeng Fan IMX_MU_TYPE_RXDB = 3, /* Rx doorbell */
4182ab513bSPeng Fan IMX_MU_TYPE_RST = 4, /* Reset */
422bb70056SOleksij Rempel };
432bb70056SOleksij Rempel
44f689a7cfSPeng Fan enum imx_mu_xcr {
4582ab513bSPeng Fan IMX_MU_CR,
464f0b776eSPeng Fan IMX_MU_GIER,
47f689a7cfSPeng Fan IMX_MU_GCR,
48f689a7cfSPeng Fan IMX_MU_TCR,
49f689a7cfSPeng Fan IMX_MU_RCR,
50f689a7cfSPeng Fan IMX_MU_xCR_MAX,
51f689a7cfSPeng Fan };
52f689a7cfSPeng Fan
53f689a7cfSPeng Fan enum imx_mu_xsr {
54f689a7cfSPeng Fan IMX_MU_SR,
55f689a7cfSPeng Fan IMX_MU_GSR,
56f689a7cfSPeng Fan IMX_MU_TSR,
57f689a7cfSPeng Fan IMX_MU_RSR,
5882ab513bSPeng Fan IMX_MU_xSR_MAX,
59f689a7cfSPeng Fan };
60f689a7cfSPeng Fan
610a67003bSPeng Fan struct imx_sc_rpc_msg_max {
620a67003bSPeng Fan struct imx_sc_rpc_msg hdr;
6311dac1d3SFranck LENORMAND u32 data[30];
640a67003bSPeng Fan };
650a67003bSPeng Fan
6697961f78SPeng Fan struct imx_s4_rpc_msg_max {
6797961f78SPeng Fan struct imx_s4_rpc_msg hdr;
6897961f78SPeng Fan u32 data[254];
6997961f78SPeng Fan };
7097961f78SPeng Fan
712bb70056SOleksij Rempel struct imx_mu_con_priv {
722bb70056SOleksij Rempel unsigned int idx;
732bb70056SOleksij Rempel char irq_desc[IMX_MU_CHAN_NAME_SIZE];
742bb70056SOleksij Rempel enum imx_mu_chan_type type;
752bb70056SOleksij Rempel struct mbox_chan *chan;
762bb70056SOleksij Rempel struct tasklet_struct txdb_tasklet;
772bb70056SOleksij Rempel };
782bb70056SOleksij Rempel
792bb70056SOleksij Rempel struct imx_mu_priv {
802bb70056SOleksij Rempel struct device *dev;
812bb70056SOleksij Rempel void __iomem *base;
8297961f78SPeng Fan void *msg;
832bb70056SOleksij Rempel spinlock_t xcr_lock; /* control register lock */
842bb70056SOleksij Rempel
852bb70056SOleksij Rempel struct mbox_controller mbox;
862bb70056SOleksij Rempel struct mbox_chan mbox_chans[IMX_MU_CHANS];
872bb70056SOleksij Rempel
882bb70056SOleksij Rempel struct imx_mu_con_priv con_priv[IMX_MU_CHANS];
89c6c6bc6eSRichard Zhu const struct imx_mu_dcfg *dcfg;
902bb70056SOleksij Rempel struct clk *clk;
91cfd162f6SPeng Fan int irq[IMX_MU_CHANS];
92892cb524SRobin Gong bool suspend;
932bb70056SOleksij Rempel
9482ab513bSPeng Fan u32 xcr[IMX_MU_xCR_MAX];
95ba5f9fa0SDong Aisheng
962bb70056SOleksij Rempel bool side_b;
972bb70056SOleksij Rempel };
982bb70056SOleksij Rempel
994f0b776eSPeng Fan enum imx_mu_type {
1004f0b776eSPeng Fan IMX_MU_V1,
10197961f78SPeng Fan IMX_MU_V2 = BIT(1),
10297961f78SPeng Fan IMX_MU_V2_S4 = BIT(15),
103a5cb407aSPeng Fan IMX_MU_V2_IRQ = BIT(16),
1044f0b776eSPeng Fan };
1054f0b776eSPeng Fan
10663b38357SPeng Fan struct imx_mu_dcfg {
10763b38357SPeng Fan int (*tx)(struct imx_mu_priv *priv, struct imx_mu_con_priv *cp, void *data);
10863b38357SPeng Fan int (*rx)(struct imx_mu_priv *priv, struct imx_mu_con_priv *cp);
109315d2e56SPeng Fan int (*rxdb)(struct imx_mu_priv *priv, struct imx_mu_con_priv *cp);
11063b38357SPeng Fan void (*init)(struct imx_mu_priv *priv);
1114f0b776eSPeng Fan enum imx_mu_type type;
11232f7443dSPeng Fan u32 xTR; /* Transmit Register0 */
11332f7443dSPeng Fan u32 xRR; /* Receive Register0 */
11482ab513bSPeng Fan u32 xSR[IMX_MU_xSR_MAX]; /* Status Registers */
11582ab513bSPeng Fan u32 xCR[IMX_MU_xCR_MAX]; /* Control Registers */
116c6c6bc6eSRichard Zhu };
117c6c6bc6eSRichard Zhu
11897961f78SPeng Fan #define IMX_MU_xSR_GIPn(type, x) (type & IMX_MU_V2 ? BIT(x) : BIT(28 + (3 - (x))))
11997961f78SPeng Fan #define IMX_MU_xSR_RFn(type, x) (type & IMX_MU_V2 ? BIT(x) : BIT(24 + (3 - (x))))
12097961f78SPeng Fan #define IMX_MU_xSR_TEn(type, x) (type & IMX_MU_V2 ? BIT(x) : BIT(20 + (3 - (x))))
1214f0b776eSPeng Fan
1224f0b776eSPeng Fan /* General Purpose Interrupt Enable */
12397961f78SPeng Fan #define IMX_MU_xCR_GIEn(type, x) (type & IMX_MU_V2 ? BIT(x) : BIT(28 + (3 - (x))))
1244f0b776eSPeng Fan /* Receive Interrupt Enable */
12597961f78SPeng Fan #define IMX_MU_xCR_RIEn(type, x) (type & IMX_MU_V2 ? BIT(x) : BIT(24 + (3 - (x))))
1264f0b776eSPeng Fan /* Transmit Interrupt Enable */
12797961f78SPeng Fan #define IMX_MU_xCR_TIEn(type, x) (type & IMX_MU_V2 ? BIT(x) : BIT(20 + (3 - (x))))
1284f0b776eSPeng Fan /* General Purpose Interrupt Request */
12997961f78SPeng Fan #define IMX_MU_xCR_GIRn(type, x) (type & IMX_MU_V2 ? BIT(x) : BIT(16 + (3 - (x))))
13082ab513bSPeng Fan /* MU reset */
13182ab513bSPeng Fan #define IMX_MU_xCR_RST(type) (type & IMX_MU_V2 ? BIT(0) : BIT(5))
13282ab513bSPeng Fan #define IMX_MU_xSR_RST(type) (type & IMX_MU_V2 ? BIT(0) : BIT(7))
1334f0b776eSPeng Fan
1344f0b776eSPeng Fan
to_imx_mu_priv(struct mbox_controller * mbox)1352bb70056SOleksij Rempel static struct imx_mu_priv *to_imx_mu_priv(struct mbox_controller *mbox)
1362bb70056SOleksij Rempel {
1372bb70056SOleksij Rempel return container_of(mbox, struct imx_mu_priv, mbox);
1382bb70056SOleksij Rempel }
1392bb70056SOleksij Rempel
imx_mu_write(struct imx_mu_priv * priv,u32 val,u32 offs)1402bb70056SOleksij Rempel static void imx_mu_write(struct imx_mu_priv *priv, u32 val, u32 offs)
1412bb70056SOleksij Rempel {
1422bb70056SOleksij Rempel iowrite32(val, priv->base + offs);
1432bb70056SOleksij Rempel }
1442bb70056SOleksij Rempel
imx_mu_read(struct imx_mu_priv * priv,u32 offs)1452bb70056SOleksij Rempel static u32 imx_mu_read(struct imx_mu_priv *priv, u32 offs)
1462bb70056SOleksij Rempel {
1472bb70056SOleksij Rempel return ioread32(priv->base + offs);
1482bb70056SOleksij Rempel }
1492bb70056SOleksij Rempel
imx_mu_tx_waiting_write(struct imx_mu_priv * priv,u32 val,u32 idx)15011dac1d3SFranck LENORMAND static int imx_mu_tx_waiting_write(struct imx_mu_priv *priv, u32 val, u32 idx)
15111dac1d3SFranck LENORMAND {
15211dac1d3SFranck LENORMAND u64 timeout_time = get_jiffies_64() + IMX_MU_SECO_TX_TOUT;
15311dac1d3SFranck LENORMAND u32 status;
15411dac1d3SFranck LENORMAND u32 can_write;
15511dac1d3SFranck LENORMAND
15611dac1d3SFranck LENORMAND dev_dbg(priv->dev, "Trying to write %.8x to idx %d\n", val, idx);
15711dac1d3SFranck LENORMAND
15811dac1d3SFranck LENORMAND do {
15911dac1d3SFranck LENORMAND status = imx_mu_read(priv, priv->dcfg->xSR[IMX_MU_TSR]);
16011dac1d3SFranck LENORMAND can_write = status & IMX_MU_xSR_TEn(priv->dcfg->type, idx % 4);
16111dac1d3SFranck LENORMAND } while (!can_write && time_is_after_jiffies64(timeout_time));
16211dac1d3SFranck LENORMAND
16311dac1d3SFranck LENORMAND if (!can_write) {
16411dac1d3SFranck LENORMAND dev_err(priv->dev, "timeout trying to write %.8x at %d(%.8x)\n",
16511dac1d3SFranck LENORMAND val, idx, status);
16611dac1d3SFranck LENORMAND return -ETIME;
16711dac1d3SFranck LENORMAND }
16811dac1d3SFranck LENORMAND
16911dac1d3SFranck LENORMAND imx_mu_write(priv, val, priv->dcfg->xTR + (idx % 4) * 4);
17011dac1d3SFranck LENORMAND
17111dac1d3SFranck LENORMAND return 0;
17211dac1d3SFranck LENORMAND }
17311dac1d3SFranck LENORMAND
imx_mu_rx_waiting_read(struct imx_mu_priv * priv,u32 * val,u32 idx)17411dac1d3SFranck LENORMAND static int imx_mu_rx_waiting_read(struct imx_mu_priv *priv, u32 *val, u32 idx)
17511dac1d3SFranck LENORMAND {
17611dac1d3SFranck LENORMAND u64 timeout_time = get_jiffies_64() + IMX_MU_SECO_RX_TOUT;
17711dac1d3SFranck LENORMAND u32 status;
17811dac1d3SFranck LENORMAND u32 can_read;
17911dac1d3SFranck LENORMAND
18011dac1d3SFranck LENORMAND dev_dbg(priv->dev, "Trying to read from idx %d\n", idx);
18111dac1d3SFranck LENORMAND
18211dac1d3SFranck LENORMAND do {
18311dac1d3SFranck LENORMAND status = imx_mu_read(priv, priv->dcfg->xSR[IMX_MU_RSR]);
18411dac1d3SFranck LENORMAND can_read = status & IMX_MU_xSR_RFn(priv->dcfg->type, idx % 4);
18511dac1d3SFranck LENORMAND } while (!can_read && time_is_after_jiffies64(timeout_time));
18611dac1d3SFranck LENORMAND
18711dac1d3SFranck LENORMAND if (!can_read) {
18811dac1d3SFranck LENORMAND dev_err(priv->dev, "timeout trying to read idx %d (%.8x)\n",
18911dac1d3SFranck LENORMAND idx, status);
19011dac1d3SFranck LENORMAND return -ETIME;
19111dac1d3SFranck LENORMAND }
19211dac1d3SFranck LENORMAND
19311dac1d3SFranck LENORMAND *val = imx_mu_read(priv, priv->dcfg->xRR + (idx % 4) * 4);
19411dac1d3SFranck LENORMAND dev_dbg(priv->dev, "Read %.8x\n", *val);
19511dac1d3SFranck LENORMAND
19611dac1d3SFranck LENORMAND return 0;
19711dac1d3SFranck LENORMAND }
19811dac1d3SFranck LENORMAND
imx_mu_xcr_rmw(struct imx_mu_priv * priv,enum imx_mu_xcr type,u32 set,u32 clr)199f689a7cfSPeng Fan static u32 imx_mu_xcr_rmw(struct imx_mu_priv *priv, enum imx_mu_xcr type, u32 set, u32 clr)
2002bb70056SOleksij Rempel {
2012bb70056SOleksij Rempel unsigned long flags;
2022bb70056SOleksij Rempel u32 val;
2032bb70056SOleksij Rempel
2042bb70056SOleksij Rempel spin_lock_irqsave(&priv->xcr_lock, flags);
205f689a7cfSPeng Fan val = imx_mu_read(priv, priv->dcfg->xCR[type]);
2062bb70056SOleksij Rempel val &= ~clr;
2072bb70056SOleksij Rempel val |= set;
208f689a7cfSPeng Fan imx_mu_write(priv, val, priv->dcfg->xCR[type]);
2092bb70056SOleksij Rempel spin_unlock_irqrestore(&priv->xcr_lock, flags);
2102bb70056SOleksij Rempel
2112bb70056SOleksij Rempel return val;
2122bb70056SOleksij Rempel }
2132bb70056SOleksij Rempel
imx_mu_generic_tx(struct imx_mu_priv * priv,struct imx_mu_con_priv * cp,void * data)21463b38357SPeng Fan static int imx_mu_generic_tx(struct imx_mu_priv *priv,
21563b38357SPeng Fan struct imx_mu_con_priv *cp,
21663b38357SPeng Fan void *data)
21763b38357SPeng Fan {
21863b38357SPeng Fan u32 *arg = data;
21963b38357SPeng Fan
22063b38357SPeng Fan switch (cp->type) {
22163b38357SPeng Fan case IMX_MU_TYPE_TX:
22232f7443dSPeng Fan imx_mu_write(priv, *arg, priv->dcfg->xTR + cp->idx * 4);
2234f0b776eSPeng Fan imx_mu_xcr_rmw(priv, IMX_MU_TCR, IMX_MU_xCR_TIEn(priv->dcfg->type, cp->idx), 0);
22463b38357SPeng Fan break;
22563b38357SPeng Fan case IMX_MU_TYPE_TXDB:
2264f0b776eSPeng Fan imx_mu_xcr_rmw(priv, IMX_MU_GCR, IMX_MU_xCR_GIRn(priv->dcfg->type, cp->idx), 0);
22763b38357SPeng Fan tasklet_schedule(&cp->txdb_tasklet);
22863b38357SPeng Fan break;
22963b38357SPeng Fan default:
23063b38357SPeng Fan dev_warn_ratelimited(priv->dev, "Send data on wrong channel type: %d\n", cp->type);
23163b38357SPeng Fan return -EINVAL;
23263b38357SPeng Fan }
23363b38357SPeng Fan
23463b38357SPeng Fan return 0;
23563b38357SPeng Fan }
23663b38357SPeng Fan
imx_mu_generic_rx(struct imx_mu_priv * priv,struct imx_mu_con_priv * cp)23763b38357SPeng Fan static int imx_mu_generic_rx(struct imx_mu_priv *priv,
23863b38357SPeng Fan struct imx_mu_con_priv *cp)
23963b38357SPeng Fan {
24063b38357SPeng Fan u32 dat;
24163b38357SPeng Fan
24232f7443dSPeng Fan dat = imx_mu_read(priv, priv->dcfg->xRR + (cp->idx) * 4);
24363b38357SPeng Fan mbox_chan_received_data(cp->chan, (void *)&dat);
24463b38357SPeng Fan
24563b38357SPeng Fan return 0;
24663b38357SPeng Fan }
24763b38357SPeng Fan
imx_mu_generic_rxdb(struct imx_mu_priv * priv,struct imx_mu_con_priv * cp)248315d2e56SPeng Fan static int imx_mu_generic_rxdb(struct imx_mu_priv *priv,
249315d2e56SPeng Fan struct imx_mu_con_priv *cp)
250315d2e56SPeng Fan {
251315d2e56SPeng Fan imx_mu_write(priv, IMX_MU_xSR_GIPn(priv->dcfg->type, cp->idx),
252315d2e56SPeng Fan priv->dcfg->xSR[IMX_MU_GSR]);
253315d2e56SPeng Fan mbox_chan_received_data(cp->chan, NULL);
254315d2e56SPeng Fan
255315d2e56SPeng Fan return 0;
256315d2e56SPeng Fan }
257315d2e56SPeng Fan
imx_mu_specific_tx(struct imx_mu_priv * priv,struct imx_mu_con_priv * cp,void * data)25897961f78SPeng Fan static int imx_mu_specific_tx(struct imx_mu_priv *priv, struct imx_mu_con_priv *cp, void *data)
2590a67003bSPeng Fan {
2600a67003bSPeng Fan u32 *arg = data;
2610a67003bSPeng Fan int i, ret;
2620a67003bSPeng Fan u32 xsr;
26397961f78SPeng Fan u32 size, max_size, num_tr;
26497961f78SPeng Fan
26597961f78SPeng Fan if (priv->dcfg->type & IMX_MU_V2_S4) {
26697961f78SPeng Fan size = ((struct imx_s4_rpc_msg_max *)data)->hdr.size;
26797961f78SPeng Fan max_size = sizeof(struct imx_s4_rpc_msg_max);
26897961f78SPeng Fan num_tr = 8;
26997961f78SPeng Fan } else {
27097961f78SPeng Fan size = ((struct imx_sc_rpc_msg_max *)data)->hdr.size;
27197961f78SPeng Fan max_size = sizeof(struct imx_sc_rpc_msg_max);
27297961f78SPeng Fan num_tr = 4;
27397961f78SPeng Fan }
2740a67003bSPeng Fan
2750a67003bSPeng Fan switch (cp->type) {
2760a67003bSPeng Fan case IMX_MU_TYPE_TX:
2779d8ca628SPeng Fan /*
2789d8ca628SPeng Fan * msg->hdr.size specifies the number of u32 words while
2799d8ca628SPeng Fan * sizeof yields bytes.
2809d8ca628SPeng Fan */
2819d8ca628SPeng Fan
28297961f78SPeng Fan if (size > max_size / 4) {
2830a67003bSPeng Fan /*
2840a67003bSPeng Fan * The real message size can be different to
28597961f78SPeng Fan * struct imx_sc_rpc_msg_max/imx_s4_rpc_msg_max size
2860a67003bSPeng Fan */
28797961f78SPeng Fan dev_err(priv->dev, "Maximal message size (%u bytes) exceeded on TX; got: %i bytes\n", max_size, size << 2);
2880a67003bSPeng Fan return -EINVAL;
2890a67003bSPeng Fan }
2900a67003bSPeng Fan
29197961f78SPeng Fan for (i = 0; i < num_tr && i < size; i++)
29297961f78SPeng Fan imx_mu_write(priv, *arg++, priv->dcfg->xTR + (i % num_tr) * 4);
29397961f78SPeng Fan for (; i < size; i++) {
294f689a7cfSPeng Fan ret = readl_poll_timeout(priv->base + priv->dcfg->xSR[IMX_MU_TSR],
2950a67003bSPeng Fan xsr,
29697961f78SPeng Fan xsr & IMX_MU_xSR_TEn(priv->dcfg->type, i % num_tr),
29781a9d3b9SRanjani Vaidyanathan 0, 5 * USEC_PER_SEC);
2980a67003bSPeng Fan if (ret) {
2990a67003bSPeng Fan dev_err(priv->dev, "Send data index: %d timeout\n", i);
3000a67003bSPeng Fan return ret;
3010a67003bSPeng Fan }
30297961f78SPeng Fan imx_mu_write(priv, *arg++, priv->dcfg->xTR + (i % num_tr) * 4);
3030a67003bSPeng Fan }
3040a67003bSPeng Fan
3054f0b776eSPeng Fan imx_mu_xcr_rmw(priv, IMX_MU_TCR, IMX_MU_xCR_TIEn(priv->dcfg->type, cp->idx), 0);
3060a67003bSPeng Fan break;
3070a67003bSPeng Fan default:
3080a67003bSPeng Fan dev_warn_ratelimited(priv->dev, "Send data on wrong channel type: %d\n", cp->type);
3090a67003bSPeng Fan return -EINVAL;
3100a67003bSPeng Fan }
3110a67003bSPeng Fan
3120a67003bSPeng Fan return 0;
3130a67003bSPeng Fan }
3140a67003bSPeng Fan
imx_mu_specific_rx(struct imx_mu_priv * priv,struct imx_mu_con_priv * cp)31597961f78SPeng Fan static int imx_mu_specific_rx(struct imx_mu_priv *priv, struct imx_mu_con_priv *cp)
3160a67003bSPeng Fan {
31797961f78SPeng Fan u32 *data;
3180a67003bSPeng Fan int i, ret;
3190a67003bSPeng Fan u32 xsr;
32097961f78SPeng Fan u32 size, max_size;
32197961f78SPeng Fan
32297961f78SPeng Fan data = (u32 *)priv->msg;
3230a67003bSPeng Fan
3244f0b776eSPeng Fan imx_mu_xcr_rmw(priv, IMX_MU_RCR, 0, IMX_MU_xCR_RIEn(priv->dcfg->type, 0));
32532f7443dSPeng Fan *data++ = imx_mu_read(priv, priv->dcfg->xRR);
3260a67003bSPeng Fan
32797961f78SPeng Fan if (priv->dcfg->type & IMX_MU_V2_S4) {
32897961f78SPeng Fan size = ((struct imx_s4_rpc_msg_max *)priv->msg)->hdr.size;
32997961f78SPeng Fan max_size = sizeof(struct imx_s4_rpc_msg_max);
33097961f78SPeng Fan } else {
33197961f78SPeng Fan size = ((struct imx_sc_rpc_msg_max *)priv->msg)->hdr.size;
33297961f78SPeng Fan max_size = sizeof(struct imx_sc_rpc_msg_max);
33397961f78SPeng Fan }
33497961f78SPeng Fan
33597961f78SPeng Fan if (size > max_size / 4) {
33697961f78SPeng Fan dev_err(priv->dev, "Maximal message size (%u bytes) exceeded on RX; got: %i bytes\n", max_size, size << 2);
3370a67003bSPeng Fan return -EINVAL;
3380a67003bSPeng Fan }
3390a67003bSPeng Fan
34097961f78SPeng Fan for (i = 1; i < size; i++) {
341f689a7cfSPeng Fan ret = readl_poll_timeout(priv->base + priv->dcfg->xSR[IMX_MU_RSR], xsr,
34281a9d3b9SRanjani Vaidyanathan xsr & IMX_MU_xSR_RFn(priv->dcfg->type, i % 4), 0,
34381a9d3b9SRanjani Vaidyanathan 5 * USEC_PER_SEC);
3440a67003bSPeng Fan if (ret) {
3450a67003bSPeng Fan dev_err(priv->dev, "timeout read idx %d\n", i);
3460a67003bSPeng Fan return ret;
3470a67003bSPeng Fan }
34832f7443dSPeng Fan *data++ = imx_mu_read(priv, priv->dcfg->xRR + (i % 4) * 4);
3490a67003bSPeng Fan }
3500a67003bSPeng Fan
3514f0b776eSPeng Fan imx_mu_xcr_rmw(priv, IMX_MU_RCR, IMX_MU_xCR_RIEn(priv->dcfg->type, 0), 0);
35297961f78SPeng Fan mbox_chan_received_data(cp->chan, (void *)priv->msg);
3530a67003bSPeng Fan
3540a67003bSPeng Fan return 0;
3550a67003bSPeng Fan }
3560a67003bSPeng Fan
imx_mu_seco_tx(struct imx_mu_priv * priv,struct imx_mu_con_priv * cp,void * data)35711dac1d3SFranck LENORMAND static int imx_mu_seco_tx(struct imx_mu_priv *priv, struct imx_mu_con_priv *cp,
35811dac1d3SFranck LENORMAND void *data)
35911dac1d3SFranck LENORMAND {
36011dac1d3SFranck LENORMAND struct imx_sc_rpc_msg_max *msg = data;
36111dac1d3SFranck LENORMAND u32 *arg = data;
36211dac1d3SFranck LENORMAND u32 byte_size;
36311dac1d3SFranck LENORMAND int err;
36411dac1d3SFranck LENORMAND int i;
36511dac1d3SFranck LENORMAND
36611dac1d3SFranck LENORMAND dev_dbg(priv->dev, "Sending message\n");
36711dac1d3SFranck LENORMAND
36811dac1d3SFranck LENORMAND switch (cp->type) {
36911dac1d3SFranck LENORMAND case IMX_MU_TYPE_TXDB:
37011dac1d3SFranck LENORMAND byte_size = msg->hdr.size * sizeof(u32);
37111dac1d3SFranck LENORMAND if (byte_size > sizeof(*msg)) {
37211dac1d3SFranck LENORMAND /*
37311dac1d3SFranck LENORMAND * The real message size can be different to
37411dac1d3SFranck LENORMAND * struct imx_sc_rpc_msg_max size
37511dac1d3SFranck LENORMAND */
37611dac1d3SFranck LENORMAND dev_err(priv->dev,
37711dac1d3SFranck LENORMAND "Exceed max msg size (%zu) on TX, got: %i\n",
37811dac1d3SFranck LENORMAND sizeof(*msg), byte_size);
37911dac1d3SFranck LENORMAND return -EINVAL;
38011dac1d3SFranck LENORMAND }
38111dac1d3SFranck LENORMAND
38211dac1d3SFranck LENORMAND print_hex_dump_debug("from client ", DUMP_PREFIX_OFFSET, 4, 4,
38311dac1d3SFranck LENORMAND data, byte_size, false);
38411dac1d3SFranck LENORMAND
38511dac1d3SFranck LENORMAND /* Send first word */
38611dac1d3SFranck LENORMAND dev_dbg(priv->dev, "Sending header\n");
38711dac1d3SFranck LENORMAND imx_mu_write(priv, *arg++, priv->dcfg->xTR);
38811dac1d3SFranck LENORMAND
38911dac1d3SFranck LENORMAND /* Send signaling */
39011dac1d3SFranck LENORMAND dev_dbg(priv->dev, "Sending signaling\n");
39111dac1d3SFranck LENORMAND imx_mu_xcr_rmw(priv, IMX_MU_GCR,
39211dac1d3SFranck LENORMAND IMX_MU_xCR_GIRn(priv->dcfg->type, cp->idx), 0);
39311dac1d3SFranck LENORMAND
39411dac1d3SFranck LENORMAND /* Send words to fill the mailbox */
39511dac1d3SFranck LENORMAND for (i = 1; i < 4 && i < msg->hdr.size; i++) {
39611dac1d3SFranck LENORMAND dev_dbg(priv->dev, "Sending word %d\n", i);
39711dac1d3SFranck LENORMAND imx_mu_write(priv, *arg++,
39811dac1d3SFranck LENORMAND priv->dcfg->xTR + (i % 4) * 4);
39911dac1d3SFranck LENORMAND }
40011dac1d3SFranck LENORMAND
40111dac1d3SFranck LENORMAND /* Send rest of message waiting for remote read */
40211dac1d3SFranck LENORMAND for (; i < msg->hdr.size; i++) {
40311dac1d3SFranck LENORMAND dev_dbg(priv->dev, "Sending word %d\n", i);
40411dac1d3SFranck LENORMAND err = imx_mu_tx_waiting_write(priv, *arg++, i);
40511dac1d3SFranck LENORMAND if (err) {
40611dac1d3SFranck LENORMAND dev_err(priv->dev, "Timeout tx %d\n", i);
40711dac1d3SFranck LENORMAND return err;
40811dac1d3SFranck LENORMAND }
40911dac1d3SFranck LENORMAND }
41011dac1d3SFranck LENORMAND
41111dac1d3SFranck LENORMAND /* Simulate hack for mbox framework */
41211dac1d3SFranck LENORMAND tasklet_schedule(&cp->txdb_tasklet);
41311dac1d3SFranck LENORMAND
41411dac1d3SFranck LENORMAND break;
41511dac1d3SFranck LENORMAND default:
41611dac1d3SFranck LENORMAND dev_warn_ratelimited(priv->dev,
41711dac1d3SFranck LENORMAND "Send data on wrong channel type: %d\n",
41811dac1d3SFranck LENORMAND cp->type);
41911dac1d3SFranck LENORMAND return -EINVAL;
42011dac1d3SFranck LENORMAND }
42111dac1d3SFranck LENORMAND
42211dac1d3SFranck LENORMAND return 0;
42311dac1d3SFranck LENORMAND }
42411dac1d3SFranck LENORMAND
imx_mu_seco_rxdb(struct imx_mu_priv * priv,struct imx_mu_con_priv * cp)42511dac1d3SFranck LENORMAND static int imx_mu_seco_rxdb(struct imx_mu_priv *priv, struct imx_mu_con_priv *cp)
42611dac1d3SFranck LENORMAND {
42711dac1d3SFranck LENORMAND struct imx_sc_rpc_msg_max msg;
42811dac1d3SFranck LENORMAND u32 *data = (u32 *)&msg;
42911dac1d3SFranck LENORMAND u32 byte_size;
43011dac1d3SFranck LENORMAND int err = 0;
43111dac1d3SFranck LENORMAND int i;
43211dac1d3SFranck LENORMAND
43311dac1d3SFranck LENORMAND dev_dbg(priv->dev, "Receiving message\n");
43411dac1d3SFranck LENORMAND
43511dac1d3SFranck LENORMAND /* Read header */
43611dac1d3SFranck LENORMAND dev_dbg(priv->dev, "Receiving header\n");
43711dac1d3SFranck LENORMAND *data++ = imx_mu_read(priv, priv->dcfg->xRR);
43811dac1d3SFranck LENORMAND byte_size = msg.hdr.size * sizeof(u32);
43911dac1d3SFranck LENORMAND if (byte_size > sizeof(msg)) {
44011dac1d3SFranck LENORMAND dev_err(priv->dev, "Exceed max msg size (%zu) on RX, got: %i\n",
44111dac1d3SFranck LENORMAND sizeof(msg), byte_size);
44211dac1d3SFranck LENORMAND err = -EINVAL;
44311dac1d3SFranck LENORMAND goto error;
44411dac1d3SFranck LENORMAND }
44511dac1d3SFranck LENORMAND
44611dac1d3SFranck LENORMAND /* Read message waiting they are written */
44711dac1d3SFranck LENORMAND for (i = 1; i < msg.hdr.size; i++) {
44811dac1d3SFranck LENORMAND dev_dbg(priv->dev, "Receiving word %d\n", i);
44911dac1d3SFranck LENORMAND err = imx_mu_rx_waiting_read(priv, data++, i);
45011dac1d3SFranck LENORMAND if (err) {
45111dac1d3SFranck LENORMAND dev_err(priv->dev, "Timeout rx %d\n", i);
45211dac1d3SFranck LENORMAND goto error;
45311dac1d3SFranck LENORMAND }
45411dac1d3SFranck LENORMAND }
45511dac1d3SFranck LENORMAND
45611dac1d3SFranck LENORMAND /* Clear GIP */
45711dac1d3SFranck LENORMAND imx_mu_write(priv, IMX_MU_xSR_GIPn(priv->dcfg->type, cp->idx),
45811dac1d3SFranck LENORMAND priv->dcfg->xSR[IMX_MU_GSR]);
45911dac1d3SFranck LENORMAND
46011dac1d3SFranck LENORMAND print_hex_dump_debug("to client ", DUMP_PREFIX_OFFSET, 4, 4,
46111dac1d3SFranck LENORMAND &msg, byte_size, false);
46211dac1d3SFranck LENORMAND
46311dac1d3SFranck LENORMAND /* send data to client */
46411dac1d3SFranck LENORMAND dev_dbg(priv->dev, "Sending message to client\n");
46511dac1d3SFranck LENORMAND mbox_chan_received_data(cp->chan, (void *)&msg);
46611dac1d3SFranck LENORMAND
46711dac1d3SFranck LENORMAND goto exit;
46811dac1d3SFranck LENORMAND
46911dac1d3SFranck LENORMAND error:
47011dac1d3SFranck LENORMAND mbox_chan_received_data(cp->chan, ERR_PTR(err));
47111dac1d3SFranck LENORMAND
47211dac1d3SFranck LENORMAND exit:
47311dac1d3SFranck LENORMAND return err;
47411dac1d3SFranck LENORMAND }
47511dac1d3SFranck LENORMAND
imx_mu_txdb_tasklet(unsigned long data)4762bb70056SOleksij Rempel static void imx_mu_txdb_tasklet(unsigned long data)
4772bb70056SOleksij Rempel {
4782bb70056SOleksij Rempel struct imx_mu_con_priv *cp = (struct imx_mu_con_priv *)data;
4792bb70056SOleksij Rempel
4802bb70056SOleksij Rempel mbox_chan_txdone(cp->chan, 0);
4812bb70056SOleksij Rempel }
4822bb70056SOleksij Rempel
imx_mu_isr(int irq,void * p)4832bb70056SOleksij Rempel static irqreturn_t imx_mu_isr(int irq, void *p)
4842bb70056SOleksij Rempel {
4852bb70056SOleksij Rempel struct mbox_chan *chan = p;
4862bb70056SOleksij Rempel struct imx_mu_priv *priv = to_imx_mu_priv(chan->mbox);
4872bb70056SOleksij Rempel struct imx_mu_con_priv *cp = chan->con_priv;
48863b38357SPeng Fan u32 val, ctrl;
4892bb70056SOleksij Rempel
4902bb70056SOleksij Rempel switch (cp->type) {
4912bb70056SOleksij Rempel case IMX_MU_TYPE_TX:
492f689a7cfSPeng Fan ctrl = imx_mu_read(priv, priv->dcfg->xCR[IMX_MU_TCR]);
493f689a7cfSPeng Fan val = imx_mu_read(priv, priv->dcfg->xSR[IMX_MU_TSR]);
4944f0b776eSPeng Fan val &= IMX_MU_xSR_TEn(priv->dcfg->type, cp->idx) &
4954f0b776eSPeng Fan (ctrl & IMX_MU_xCR_TIEn(priv->dcfg->type, cp->idx));
4962bb70056SOleksij Rempel break;
4972bb70056SOleksij Rempel case IMX_MU_TYPE_RX:
498f689a7cfSPeng Fan ctrl = imx_mu_read(priv, priv->dcfg->xCR[IMX_MU_RCR]);
499f689a7cfSPeng Fan val = imx_mu_read(priv, priv->dcfg->xSR[IMX_MU_RSR]);
5004f0b776eSPeng Fan val &= IMX_MU_xSR_RFn(priv->dcfg->type, cp->idx) &
5014f0b776eSPeng Fan (ctrl & IMX_MU_xCR_RIEn(priv->dcfg->type, cp->idx));
5022bb70056SOleksij Rempel break;
5032bb70056SOleksij Rempel case IMX_MU_TYPE_RXDB:
5044f0b776eSPeng Fan ctrl = imx_mu_read(priv, priv->dcfg->xCR[IMX_MU_GIER]);
505f689a7cfSPeng Fan val = imx_mu_read(priv, priv->dcfg->xSR[IMX_MU_GSR]);
5064f0b776eSPeng Fan val &= IMX_MU_xSR_GIPn(priv->dcfg->type, cp->idx) &
5074f0b776eSPeng Fan (ctrl & IMX_MU_xCR_GIEn(priv->dcfg->type, cp->idx));
5082bb70056SOleksij Rempel break;
50982ab513bSPeng Fan case IMX_MU_TYPE_RST:
51082ab513bSPeng Fan return IRQ_NONE;
5112bb70056SOleksij Rempel default:
512e80a7e7eSNathan Chancellor dev_warn_ratelimited(priv->dev, "Unhandled channel type %d\n",
513e80a7e7eSNathan Chancellor cp->type);
514e80a7e7eSNathan Chancellor return IRQ_NONE;
5152bb70056SOleksij Rempel }
5162bb70056SOleksij Rempel
5172bb70056SOleksij Rempel if (!val)
5182bb70056SOleksij Rempel return IRQ_NONE;
5192bb70056SOleksij Rempel
5204f0b776eSPeng Fan if ((val == IMX_MU_xSR_TEn(priv->dcfg->type, cp->idx)) &&
5214f0b776eSPeng Fan (cp->type == IMX_MU_TYPE_TX)) {
5224f0b776eSPeng Fan imx_mu_xcr_rmw(priv, IMX_MU_TCR, 0, IMX_MU_xCR_TIEn(priv->dcfg->type, cp->idx));
5232bb70056SOleksij Rempel mbox_chan_txdone(chan, 0);
5244f0b776eSPeng Fan } else if ((val == IMX_MU_xSR_RFn(priv->dcfg->type, cp->idx)) &&
5254f0b776eSPeng Fan (cp->type == IMX_MU_TYPE_RX)) {
52663b38357SPeng Fan priv->dcfg->rx(priv, cp);
5274f0b776eSPeng Fan } else if ((val == IMX_MU_xSR_GIPn(priv->dcfg->type, cp->idx)) &&
5284f0b776eSPeng Fan (cp->type == IMX_MU_TYPE_RXDB)) {
529315d2e56SPeng Fan priv->dcfg->rxdb(priv, cp);
5302bb70056SOleksij Rempel } else {
5312bb70056SOleksij Rempel dev_warn_ratelimited(priv->dev, "Not handled interrupt\n");
5322bb70056SOleksij Rempel return IRQ_NONE;
5332bb70056SOleksij Rempel }
5342bb70056SOleksij Rempel
535892cb524SRobin Gong if (priv->suspend)
536892cb524SRobin Gong pm_system_wakeup();
537892cb524SRobin Gong
5382bb70056SOleksij Rempel return IRQ_HANDLED;
5392bb70056SOleksij Rempel }
5402bb70056SOleksij Rempel
imx_mu_send_data(struct mbox_chan * chan,void * data)5412bb70056SOleksij Rempel static int imx_mu_send_data(struct mbox_chan *chan, void *data)
5422bb70056SOleksij Rempel {
5432bb70056SOleksij Rempel struct imx_mu_priv *priv = to_imx_mu_priv(chan->mbox);
5442bb70056SOleksij Rempel struct imx_mu_con_priv *cp = chan->con_priv;
5452bb70056SOleksij Rempel
54663b38357SPeng Fan return priv->dcfg->tx(priv, cp, data);
5472bb70056SOleksij Rempel }
5482bb70056SOleksij Rempel
imx_mu_startup(struct mbox_chan * chan)5492bb70056SOleksij Rempel static int imx_mu_startup(struct mbox_chan *chan)
5502bb70056SOleksij Rempel {
5512bb70056SOleksij Rempel struct imx_mu_priv *priv = to_imx_mu_priv(chan->mbox);
5522bb70056SOleksij Rempel struct imx_mu_con_priv *cp = chan->con_priv;
553a5cb407aSPeng Fan unsigned long irq_flag = 0;
5542bb70056SOleksij Rempel int ret;
5552bb70056SOleksij Rempel
556676f23eaSAnson Huang pm_runtime_get_sync(priv->dev);
5572bb70056SOleksij Rempel if (cp->type == IMX_MU_TYPE_TXDB) {
5582bb70056SOleksij Rempel /* Tx doorbell don't have ACK support */
5592bb70056SOleksij Rempel tasklet_init(&cp->txdb_tasklet, imx_mu_txdb_tasklet,
5602bb70056SOleksij Rempel (unsigned long)cp);
5612bb70056SOleksij Rempel return 0;
5622bb70056SOleksij Rempel }
5632bb70056SOleksij Rempel
564b7b2796bSAnson Huang /* IPC MU should be with IRQF_NO_SUSPEND set */
565b7b2796bSAnson Huang if (!priv->dev->pm_domain)
566b7b2796bSAnson Huang irq_flag |= IRQF_NO_SUSPEND;
567b7b2796bSAnson Huang
568a5cb407aSPeng Fan if (!(priv->dcfg->type & IMX_MU_V2_IRQ))
569a5cb407aSPeng Fan irq_flag |= IRQF_SHARED;
570a5cb407aSPeng Fan
571a5cb407aSPeng Fan ret = request_irq(priv->irq[cp->type], imx_mu_isr, irq_flag, cp->irq_desc, chan);
5722bb70056SOleksij Rempel if (ret) {
573a5cb407aSPeng Fan dev_err(priv->dev, "Unable to acquire IRQ %d\n", priv->irq[cp->type]);
5742bb70056SOleksij Rempel return ret;
5752bb70056SOleksij Rempel }
5762bb70056SOleksij Rempel
5772bb70056SOleksij Rempel switch (cp->type) {
5782bb70056SOleksij Rempel case IMX_MU_TYPE_RX:
5794f0b776eSPeng Fan imx_mu_xcr_rmw(priv, IMX_MU_RCR, IMX_MU_xCR_RIEn(priv->dcfg->type, cp->idx), 0);
5802bb70056SOleksij Rempel break;
5812bb70056SOleksij Rempel case IMX_MU_TYPE_RXDB:
5824f0b776eSPeng Fan imx_mu_xcr_rmw(priv, IMX_MU_GIER, IMX_MU_xCR_GIEn(priv->dcfg->type, cp->idx), 0);
5832bb70056SOleksij Rempel break;
5842bb70056SOleksij Rempel default:
5852bb70056SOleksij Rempel break;
5862bb70056SOleksij Rempel }
5872bb70056SOleksij Rempel
5882bb70056SOleksij Rempel return 0;
5892bb70056SOleksij Rempel }
5902bb70056SOleksij Rempel
imx_mu_shutdown(struct mbox_chan * chan)5912bb70056SOleksij Rempel static void imx_mu_shutdown(struct mbox_chan *chan)
5922bb70056SOleksij Rempel {
5932bb70056SOleksij Rempel struct imx_mu_priv *priv = to_imx_mu_priv(chan->mbox);
5942bb70056SOleksij Rempel struct imx_mu_con_priv *cp = chan->con_priv;
59582ab513bSPeng Fan int ret;
59682ab513bSPeng Fan u32 sr;
5972bb70056SOleksij Rempel
598bf159d15SDaniel Baluta if (cp->type == IMX_MU_TYPE_TXDB) {
5992bb70056SOleksij Rempel tasklet_kill(&cp->txdb_tasklet);
600676f23eaSAnson Huang pm_runtime_put_sync(priv->dev);
601bf159d15SDaniel Baluta return;
602bf159d15SDaniel Baluta }
6032bb70056SOleksij Rempel
6045f0af07eSDaniel Baluta switch (cp->type) {
6055f0af07eSDaniel Baluta case IMX_MU_TYPE_TX:
6064f0b776eSPeng Fan imx_mu_xcr_rmw(priv, IMX_MU_TCR, 0, IMX_MU_xCR_TIEn(priv->dcfg->type, cp->idx));
6075f0af07eSDaniel Baluta break;
6085f0af07eSDaniel Baluta case IMX_MU_TYPE_RX:
6094f0b776eSPeng Fan imx_mu_xcr_rmw(priv, IMX_MU_RCR, 0, IMX_MU_xCR_RIEn(priv->dcfg->type, cp->idx));
6105f0af07eSDaniel Baluta break;
6115f0af07eSDaniel Baluta case IMX_MU_TYPE_RXDB:
6124f0b776eSPeng Fan imx_mu_xcr_rmw(priv, IMX_MU_GIER, 0, IMX_MU_xCR_GIEn(priv->dcfg->type, cp->idx));
6135f0af07eSDaniel Baluta break;
61482ab513bSPeng Fan case IMX_MU_TYPE_RST:
61582ab513bSPeng Fan imx_mu_xcr_rmw(priv, IMX_MU_CR, IMX_MU_xCR_RST(priv->dcfg->type), 0);
61682ab513bSPeng Fan ret = readl_poll_timeout(priv->base + priv->dcfg->xSR[IMX_MU_SR], sr,
61782ab513bSPeng Fan !(sr & IMX_MU_xSR_RST(priv->dcfg->type)), 1, 5);
61882ab513bSPeng Fan if (ret)
61982ab513bSPeng Fan dev_warn(priv->dev, "RST channel timeout\n");
62082ab513bSPeng Fan break;
6215f0af07eSDaniel Baluta default:
6225f0af07eSDaniel Baluta break;
6235f0af07eSDaniel Baluta }
6242bb70056SOleksij Rempel
625a5cb407aSPeng Fan free_irq(priv->irq[cp->type], chan);
626676f23eaSAnson Huang pm_runtime_put_sync(priv->dev);
6272bb70056SOleksij Rempel }
6282bb70056SOleksij Rempel
6292bb70056SOleksij Rempel static const struct mbox_chan_ops imx_mu_ops = {
6302bb70056SOleksij Rempel .send_data = imx_mu_send_data,
6312bb70056SOleksij Rempel .startup = imx_mu_startup,
6322bb70056SOleksij Rempel .shutdown = imx_mu_shutdown,
6332bb70056SOleksij Rempel };
6342bb70056SOleksij Rempel
imx_mu_specific_xlate(struct mbox_controller * mbox,const struct of_phandle_args * sp)63597961f78SPeng Fan static struct mbox_chan *imx_mu_specific_xlate(struct mbox_controller *mbox,
6360a67003bSPeng Fan const struct of_phandle_args *sp)
6370a67003bSPeng Fan {
6380a67003bSPeng Fan u32 type, idx, chan;
6390a67003bSPeng Fan
6400a67003bSPeng Fan if (sp->args_count != 2) {
6410a67003bSPeng Fan dev_err(mbox->dev, "Invalid argument count %d\n", sp->args_count);
6420a67003bSPeng Fan return ERR_PTR(-EINVAL);
6430a67003bSPeng Fan }
6440a67003bSPeng Fan
6450a67003bSPeng Fan type = sp->args[0]; /* channel type */
6460a67003bSPeng Fan idx = sp->args[1]; /* index */
6470a67003bSPeng Fan
6480a67003bSPeng Fan switch (type) {
6490a67003bSPeng Fan case IMX_MU_TYPE_TX:
6500a67003bSPeng Fan case IMX_MU_TYPE_RX:
6510a67003bSPeng Fan if (idx != 0)
6520a67003bSPeng Fan dev_err(mbox->dev, "Invalid chan idx: %d\n", idx);
6530a67003bSPeng Fan chan = type;
6540a67003bSPeng Fan break;
6550a67003bSPeng Fan case IMX_MU_TYPE_RXDB:
6560a67003bSPeng Fan chan = 2 + idx;
6570a67003bSPeng Fan break;
6580a67003bSPeng Fan default:
6590a67003bSPeng Fan dev_err(mbox->dev, "Invalid chan type: %d\n", type);
6601b3a347bSDan Carpenter return ERR_PTR(-EINVAL);
6610a67003bSPeng Fan }
6620a67003bSPeng Fan
6630a67003bSPeng Fan if (chan >= mbox->num_chans) {
6640a67003bSPeng Fan dev_err(mbox->dev, "Not supported channel number: %d. (type: %d, idx: %d)\n", chan, type, idx);
6650a67003bSPeng Fan return ERR_PTR(-EINVAL);
6660a67003bSPeng Fan }
6670a67003bSPeng Fan
6680a67003bSPeng Fan return &mbox->chans[chan];
6690a67003bSPeng Fan }
6700a67003bSPeng Fan
imx_mu_xlate(struct mbox_controller * mbox,const struct of_phandle_args * sp)6712bb70056SOleksij Rempel static struct mbox_chan * imx_mu_xlate(struct mbox_controller *mbox,
6722bb70056SOleksij Rempel const struct of_phandle_args *sp)
6732bb70056SOleksij Rempel {
6742bb70056SOleksij Rempel u32 type, idx, chan;
6752bb70056SOleksij Rempel
6762bb70056SOleksij Rempel if (sp->args_count != 2) {
6772bb70056SOleksij Rempel dev_err(mbox->dev, "Invalid argument count %d\n", sp->args_count);
6782bb70056SOleksij Rempel return ERR_PTR(-EINVAL);
6792bb70056SOleksij Rempel }
6802bb70056SOleksij Rempel
6812bb70056SOleksij Rempel type = sp->args[0]; /* channel type */
6822bb70056SOleksij Rempel idx = sp->args[1]; /* index */
6832bb70056SOleksij Rempel chan = type * 4 + idx;
6842bb70056SOleksij Rempel
6852bb70056SOleksij Rempel if (chan >= mbox->num_chans) {
6862bb70056SOleksij Rempel dev_err(mbox->dev, "Not supported channel number: %d. (type: %d, idx: %d)\n", chan, type, idx);
6872bb70056SOleksij Rempel return ERR_PTR(-EINVAL);
6882bb70056SOleksij Rempel }
6892bb70056SOleksij Rempel
6902bb70056SOleksij Rempel return &mbox->chans[chan];
6912bb70056SOleksij Rempel }
6922bb70056SOleksij Rempel
imx_mu_seco_xlate(struct mbox_controller * mbox,const struct of_phandle_args * sp)69311dac1d3SFranck LENORMAND static struct mbox_chan *imx_mu_seco_xlate(struct mbox_controller *mbox,
69411dac1d3SFranck LENORMAND const struct of_phandle_args *sp)
69511dac1d3SFranck LENORMAND {
69611dac1d3SFranck LENORMAND u32 type;
69711dac1d3SFranck LENORMAND
69811dac1d3SFranck LENORMAND if (sp->args_count < 1) {
69911dac1d3SFranck LENORMAND dev_err(mbox->dev, "Invalid argument count %d\n", sp->args_count);
70011dac1d3SFranck LENORMAND return ERR_PTR(-EINVAL);
70111dac1d3SFranck LENORMAND }
70211dac1d3SFranck LENORMAND
70311dac1d3SFranck LENORMAND type = sp->args[0]; /* channel type */
70411dac1d3SFranck LENORMAND
70511dac1d3SFranck LENORMAND /* Only supports TXDB and RXDB */
70611dac1d3SFranck LENORMAND if (type == IMX_MU_TYPE_TX || type == IMX_MU_TYPE_RX) {
70711dac1d3SFranck LENORMAND dev_err(mbox->dev, "Invalid type: %d\n", type);
70811dac1d3SFranck LENORMAND return ERR_PTR(-EINVAL);
70911dac1d3SFranck LENORMAND }
71011dac1d3SFranck LENORMAND
71111dac1d3SFranck LENORMAND return imx_mu_xlate(mbox, sp);
71211dac1d3SFranck LENORMAND }
71311dac1d3SFranck LENORMAND
imx_mu_init_generic(struct imx_mu_priv * priv)7142bb70056SOleksij Rempel static void imx_mu_init_generic(struct imx_mu_priv *priv)
7152bb70056SOleksij Rempel {
71663b38357SPeng Fan unsigned int i;
7178a8dc2b9SPeng Fan unsigned int val;
71863b38357SPeng Fan
71963b38357SPeng Fan for (i = 0; i < IMX_MU_CHANS; i++) {
72063b38357SPeng Fan struct imx_mu_con_priv *cp = &priv->con_priv[i];
72163b38357SPeng Fan
72263b38357SPeng Fan cp->idx = i % 4;
72363b38357SPeng Fan cp->type = i >> 2;
72463b38357SPeng Fan cp->chan = &priv->mbox_chans[i];
72563b38357SPeng Fan priv->mbox_chans[i].con_priv = cp;
72663b38357SPeng Fan snprintf(cp->irq_desc, sizeof(cp->irq_desc),
72763b38357SPeng Fan "imx_mu_chan[%i-%i]", cp->type, cp->idx);
72863b38357SPeng Fan }
72963b38357SPeng Fan
73063b38357SPeng Fan priv->mbox.num_chans = IMX_MU_CHANS;
73163b38357SPeng Fan priv->mbox.of_xlate = imx_mu_xlate;
73263b38357SPeng Fan
7332bb70056SOleksij Rempel if (priv->side_b)
7342bb70056SOleksij Rempel return;
7352bb70056SOleksij Rempel
7362bb70056SOleksij Rempel /* Set default MU configuration */
737f689a7cfSPeng Fan for (i = 0; i < IMX_MU_xCR_MAX; i++)
738f689a7cfSPeng Fan imx_mu_write(priv, 0, priv->dcfg->xCR[i]);
7398a8dc2b9SPeng Fan
7408a8dc2b9SPeng Fan /* Clear any pending GIP */
7418a8dc2b9SPeng Fan val = imx_mu_read(priv, priv->dcfg->xSR[IMX_MU_GSR]);
7428a8dc2b9SPeng Fan imx_mu_write(priv, val, priv->dcfg->xSR[IMX_MU_GSR]);
7438a8dc2b9SPeng Fan
7448a8dc2b9SPeng Fan /* Clear any pending RSR */
7458a8dc2b9SPeng Fan for (i = 0; i < IMX_MU_NUM_RR; i++)
7468a8dc2b9SPeng Fan imx_mu_read(priv, priv->dcfg->xRR + (i % 4) * 4);
7472bb70056SOleksij Rempel }
7482bb70056SOleksij Rempel
imx_mu_init_specific(struct imx_mu_priv * priv)74997961f78SPeng Fan static void imx_mu_init_specific(struct imx_mu_priv *priv)
7500a67003bSPeng Fan {
7510a67003bSPeng Fan unsigned int i;
75297961f78SPeng Fan int num_chans = priv->dcfg->type & IMX_MU_V2_S4 ? IMX_MU_S4_CHANS : IMX_MU_SCU_CHANS;
7530a67003bSPeng Fan
75497961f78SPeng Fan for (i = 0; i < num_chans; i++) {
7550a67003bSPeng Fan struct imx_mu_con_priv *cp = &priv->con_priv[i];
7560a67003bSPeng Fan
7570a67003bSPeng Fan cp->idx = i < 2 ? 0 : i - 2;
7580a67003bSPeng Fan cp->type = i < 2 ? i : IMX_MU_TYPE_RXDB;
7590a67003bSPeng Fan cp->chan = &priv->mbox_chans[i];
7600a67003bSPeng Fan priv->mbox_chans[i].con_priv = cp;
7610a67003bSPeng Fan snprintf(cp->irq_desc, sizeof(cp->irq_desc),
7620a67003bSPeng Fan "imx_mu_chan[%i-%i]", cp->type, cp->idx);
7630a67003bSPeng Fan }
7640a67003bSPeng Fan
76597961f78SPeng Fan priv->mbox.num_chans = num_chans;
76697961f78SPeng Fan priv->mbox.of_xlate = imx_mu_specific_xlate;
7670a67003bSPeng Fan
7680a67003bSPeng Fan /* Set default MU configuration */
769f689a7cfSPeng Fan for (i = 0; i < IMX_MU_xCR_MAX; i++)
770f689a7cfSPeng Fan imx_mu_write(priv, 0, priv->dcfg->xCR[i]);
7710a67003bSPeng Fan }
7720a67003bSPeng Fan
imx_mu_init_seco(struct imx_mu_priv * priv)77311dac1d3SFranck LENORMAND static void imx_mu_init_seco(struct imx_mu_priv *priv)
77411dac1d3SFranck LENORMAND {
77511dac1d3SFranck LENORMAND imx_mu_init_generic(priv);
77611dac1d3SFranck LENORMAND priv->mbox.of_xlate = imx_mu_seco_xlate;
77711dac1d3SFranck LENORMAND }
77811dac1d3SFranck LENORMAND
imx_mu_probe(struct platform_device * pdev)7792bb70056SOleksij Rempel static int imx_mu_probe(struct platform_device *pdev)
7802bb70056SOleksij Rempel {
7812bb70056SOleksij Rempel struct device *dev = &pdev->dev;
7822bb70056SOleksij Rempel struct device_node *np = dev->of_node;
7832bb70056SOleksij Rempel struct imx_mu_priv *priv;
784c6c6bc6eSRichard Zhu const struct imx_mu_dcfg *dcfg;
785a5cb407aSPeng Fan int i, ret;
78697961f78SPeng Fan u32 size;
7872bb70056SOleksij Rempel
7882bb70056SOleksij Rempel priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
7892bb70056SOleksij Rempel if (!priv)
7902bb70056SOleksij Rempel return -ENOMEM;
7912bb70056SOleksij Rempel
7922bb70056SOleksij Rempel priv->dev = dev;
7932bb70056SOleksij Rempel
7940c40e631SAnson Huang priv->base = devm_platform_ioremap_resource(pdev, 0);
7952bb70056SOleksij Rempel if (IS_ERR(priv->base))
7962bb70056SOleksij Rempel return PTR_ERR(priv->base);
7972bb70056SOleksij Rempel
798c6c6bc6eSRichard Zhu dcfg = of_device_get_match_data(dev);
799c6c6bc6eSRichard Zhu if (!dcfg)
800c6c6bc6eSRichard Zhu return -EINVAL;
801c6c6bc6eSRichard Zhu priv->dcfg = dcfg;
802a5cb407aSPeng Fan if (priv->dcfg->type & IMX_MU_V2_IRQ) {
803a5cb407aSPeng Fan priv->irq[IMX_MU_TYPE_TX] = platform_get_irq_byname(pdev, "tx");
804a5cb407aSPeng Fan if (priv->irq[IMX_MU_TYPE_TX] < 0)
805a5cb407aSPeng Fan return priv->irq[IMX_MU_TYPE_TX];
806a5cb407aSPeng Fan priv->irq[IMX_MU_TYPE_RX] = platform_get_irq_byname(pdev, "rx");
807a5cb407aSPeng Fan if (priv->irq[IMX_MU_TYPE_RX] < 0)
808a5cb407aSPeng Fan return priv->irq[IMX_MU_TYPE_RX];
809a5cb407aSPeng Fan } else {
810a5cb407aSPeng Fan ret = platform_get_irq(pdev, 0);
811a5cb407aSPeng Fan if (ret < 0)
812a5cb407aSPeng Fan return ret;
813a5cb407aSPeng Fan
814a5cb407aSPeng Fan for (i = 0; i < IMX_MU_CHANS; i++)
815a5cb407aSPeng Fan priv->irq[i] = ret;
816a5cb407aSPeng Fan }
817c6c6bc6eSRichard Zhu
81897961f78SPeng Fan if (priv->dcfg->type & IMX_MU_V2_S4)
81997961f78SPeng Fan size = sizeof(struct imx_s4_rpc_msg_max);
82097961f78SPeng Fan else
82197961f78SPeng Fan size = sizeof(struct imx_sc_rpc_msg_max);
82297961f78SPeng Fan
82397961f78SPeng Fan priv->msg = devm_kzalloc(dev, size, GFP_KERNEL);
82405d06f37SDan Carpenter if (!priv->msg)
82505d06f37SDan Carpenter return -ENOMEM;
82697961f78SPeng Fan
8272bb70056SOleksij Rempel priv->clk = devm_clk_get(dev, NULL);
8282bb70056SOleksij Rempel if (IS_ERR(priv->clk)) {
8292bb70056SOleksij Rempel if (PTR_ERR(priv->clk) != -ENOENT)
8302bb70056SOleksij Rempel return PTR_ERR(priv->clk);
8312bb70056SOleksij Rempel
8322bb70056SOleksij Rempel priv->clk = NULL;
8332bb70056SOleksij Rempel }
8342bb70056SOleksij Rempel
8352bb70056SOleksij Rempel ret = clk_prepare_enable(priv->clk);
8362bb70056SOleksij Rempel if (ret) {
8372bb70056SOleksij Rempel dev_err(dev, "Failed to enable clock\n");
8382bb70056SOleksij Rempel return ret;
8392bb70056SOleksij Rempel }
8402bb70056SOleksij Rempel
8412bb70056SOleksij Rempel priv->side_b = of_property_read_bool(np, "fsl,mu-side-b");
8422bb70056SOleksij Rempel
84363b38357SPeng Fan priv->dcfg->init(priv);
84463b38357SPeng Fan
8452bb70056SOleksij Rempel spin_lock_init(&priv->xcr_lock);
8462bb70056SOleksij Rempel
8472bb70056SOleksij Rempel priv->mbox.dev = dev;
8482bb70056SOleksij Rempel priv->mbox.ops = &imx_mu_ops;
8492bb70056SOleksij Rempel priv->mbox.chans = priv->mbox_chans;
8502bb70056SOleksij Rempel priv->mbox.txdone_irq = true;
8512bb70056SOleksij Rempel
8522bb70056SOleksij Rempel platform_set_drvdata(pdev, priv);
8532bb70056SOleksij Rempel
854676f23eaSAnson Huang ret = devm_mbox_controller_register(dev, &priv->mbox);
85547303f94SFabio Estevam if (ret) {
85647303f94SFabio Estevam clk_disable_unprepare(priv->clk);
857676f23eaSAnson Huang return ret;
85847303f94SFabio Estevam }
859676f23eaSAnson Huang
860676f23eaSAnson Huang pm_runtime_enable(dev);
861676f23eaSAnson Huang
862504ff5b0Sran jianping ret = pm_runtime_resume_and_get(dev);
863504ff5b0Sran jianping if (ret < 0)
864676f23eaSAnson Huang goto disable_runtime_pm;
865676f23eaSAnson Huang
866676f23eaSAnson Huang ret = pm_runtime_put_sync(dev);
867676f23eaSAnson Huang if (ret < 0)
868676f23eaSAnson Huang goto disable_runtime_pm;
869676f23eaSAnson Huang
870bb2b2624SAnson Huang clk_disable_unprepare(priv->clk);
871bb2b2624SAnson Huang
872676f23eaSAnson Huang return 0;
873676f23eaSAnson Huang
874676f23eaSAnson Huang disable_runtime_pm:
875676f23eaSAnson Huang pm_runtime_disable(dev);
876bb2b2624SAnson Huang clk_disable_unprepare(priv->clk);
877676f23eaSAnson Huang return ret;
8782bb70056SOleksij Rempel }
8792bb70056SOleksij Rempel
imx_mu_remove(struct platform_device * pdev)8802bb70056SOleksij Rempel static int imx_mu_remove(struct platform_device *pdev)
8812bb70056SOleksij Rempel {
8822bb70056SOleksij Rempel struct imx_mu_priv *priv = platform_get_drvdata(pdev);
8832bb70056SOleksij Rempel
884676f23eaSAnson Huang pm_runtime_disable(priv->dev);
8852bb70056SOleksij Rempel
8862bb70056SOleksij Rempel return 0;
8872bb70056SOleksij Rempel }
8882bb70056SOleksij Rempel
88963b38357SPeng Fan static const struct imx_mu_dcfg imx_mu_cfg_imx6sx = {
89063b38357SPeng Fan .tx = imx_mu_generic_tx,
89163b38357SPeng Fan .rx = imx_mu_generic_rx,
892315d2e56SPeng Fan .rxdb = imx_mu_generic_rxdb,
89363b38357SPeng Fan .init = imx_mu_init_generic,
89432f7443dSPeng Fan .xTR = 0x0,
89532f7443dSPeng Fan .xRR = 0x10,
896f689a7cfSPeng Fan .xSR = {0x20, 0x20, 0x20, 0x20},
89782ab513bSPeng Fan .xCR = {0x24, 0x24, 0x24, 0x24, 0x24},
89863b38357SPeng Fan };
89963b38357SPeng Fan
90063b38357SPeng Fan static const struct imx_mu_dcfg imx_mu_cfg_imx7ulp = {
90163b38357SPeng Fan .tx = imx_mu_generic_tx,
90263b38357SPeng Fan .rx = imx_mu_generic_rx,
903315d2e56SPeng Fan .rxdb = imx_mu_generic_rxdb,
90463b38357SPeng Fan .init = imx_mu_init_generic,
90532f7443dSPeng Fan .xTR = 0x20,
90632f7443dSPeng Fan .xRR = 0x40,
907f689a7cfSPeng Fan .xSR = {0x60, 0x60, 0x60, 0x60},
9087e5cd064SPeng Fan .xCR = {0x64, 0x64, 0x64, 0x64, 0x64},
90963b38357SPeng Fan };
91063b38357SPeng Fan
9114f0b776eSPeng Fan static const struct imx_mu_dcfg imx_mu_cfg_imx8ulp = {
9124f0b776eSPeng Fan .tx = imx_mu_generic_tx,
9134f0b776eSPeng Fan .rx = imx_mu_generic_rx,
914315d2e56SPeng Fan .rxdb = imx_mu_generic_rxdb,
9154f0b776eSPeng Fan .init = imx_mu_init_generic,
9164f0b776eSPeng Fan .type = IMX_MU_V2,
9174f0b776eSPeng Fan .xTR = 0x200,
9184f0b776eSPeng Fan .xRR = 0x280,
9194f0b776eSPeng Fan .xSR = {0xC, 0x118, 0x124, 0x12C},
92082ab513bSPeng Fan .xCR = {0x8, 0x110, 0x114, 0x120, 0x128},
9214f0b776eSPeng Fan };
9224f0b776eSPeng Fan
92397961f78SPeng Fan static const struct imx_mu_dcfg imx_mu_cfg_imx8ulp_s4 = {
92497961f78SPeng Fan .tx = imx_mu_specific_tx,
92597961f78SPeng Fan .rx = imx_mu_specific_rx,
92697961f78SPeng Fan .init = imx_mu_init_specific,
92797961f78SPeng Fan .type = IMX_MU_V2 | IMX_MU_V2_S4,
92897961f78SPeng Fan .xTR = 0x200,
92997961f78SPeng Fan .xRR = 0x280,
93097961f78SPeng Fan .xSR = {0xC, 0x118, 0x124, 0x12C},
9317e5cd064SPeng Fan .xCR = {0x8, 0x110, 0x114, 0x120, 0x128},
93297961f78SPeng Fan };
93397961f78SPeng Fan
9340184cc20SPeng Fan static const struct imx_mu_dcfg imx_mu_cfg_imx93_s4 = {
9350184cc20SPeng Fan .tx = imx_mu_specific_tx,
9360184cc20SPeng Fan .rx = imx_mu_specific_rx,
9370184cc20SPeng Fan .init = imx_mu_init_specific,
9380184cc20SPeng Fan .type = IMX_MU_V2 | IMX_MU_V2_S4 | IMX_MU_V2_IRQ,
9390184cc20SPeng Fan .xTR = 0x200,
9400184cc20SPeng Fan .xRR = 0x280,
9410184cc20SPeng Fan .xSR = {0xC, 0x118, 0x124, 0x12C},
9427e5cd064SPeng Fan .xCR = {0x8, 0x110, 0x114, 0x120, 0x128},
9430184cc20SPeng Fan };
9440184cc20SPeng Fan
9450a67003bSPeng Fan static const struct imx_mu_dcfg imx_mu_cfg_imx8_scu = {
94697961f78SPeng Fan .tx = imx_mu_specific_tx,
94797961f78SPeng Fan .rx = imx_mu_specific_rx,
94897961f78SPeng Fan .init = imx_mu_init_specific,
949315d2e56SPeng Fan .rxdb = imx_mu_generic_rxdb,
9504f0b776eSPeng Fan .xTR = 0x0,
9514f0b776eSPeng Fan .xRR = 0x10,
952f689a7cfSPeng Fan .xSR = {0x20, 0x20, 0x20, 0x20},
9537e5cd064SPeng Fan .xCR = {0x24, 0x24, 0x24, 0x24, 0x24},
9540a67003bSPeng Fan };
9550a67003bSPeng Fan
95611dac1d3SFranck LENORMAND static const struct imx_mu_dcfg imx_mu_cfg_imx8_seco = {
95711dac1d3SFranck LENORMAND .tx = imx_mu_seco_tx,
95811dac1d3SFranck LENORMAND .rx = imx_mu_generic_rx,
95911dac1d3SFranck LENORMAND .rxdb = imx_mu_seco_rxdb,
96011dac1d3SFranck LENORMAND .init = imx_mu_init_seco,
96111dac1d3SFranck LENORMAND .xTR = 0x0,
96211dac1d3SFranck LENORMAND .xRR = 0x10,
96311dac1d3SFranck LENORMAND .xSR = {0x20, 0x20, 0x20, 0x20},
9647e5cd064SPeng Fan .xCR = {0x24, 0x24, 0x24, 0x24, 0x24},
96511dac1d3SFranck LENORMAND };
96611dac1d3SFranck LENORMAND
9672bb70056SOleksij Rempel static const struct of_device_id imx_mu_dt_ids[] = {
968c6c6bc6eSRichard Zhu { .compatible = "fsl,imx7ulp-mu", .data = &imx_mu_cfg_imx7ulp },
969c6c6bc6eSRichard Zhu { .compatible = "fsl,imx6sx-mu", .data = &imx_mu_cfg_imx6sx },
9704f0b776eSPeng Fan { .compatible = "fsl,imx8ulp-mu", .data = &imx_mu_cfg_imx8ulp },
97197961f78SPeng Fan { .compatible = "fsl,imx8ulp-mu-s4", .data = &imx_mu_cfg_imx8ulp_s4 },
9720184cc20SPeng Fan { .compatible = "fsl,imx93-mu-s4", .data = &imx_mu_cfg_imx93_s4 },
9730a67003bSPeng Fan { .compatible = "fsl,imx8-mu-scu", .data = &imx_mu_cfg_imx8_scu },
97411dac1d3SFranck LENORMAND { .compatible = "fsl,imx8-mu-seco", .data = &imx_mu_cfg_imx8_seco },
9752bb70056SOleksij Rempel { },
9762bb70056SOleksij Rempel };
9772bb70056SOleksij Rempel MODULE_DEVICE_TABLE(of, imx_mu_dt_ids);
9782bb70056SOleksij Rempel
imx_mu_suspend_noirq(struct device * dev)97903b70130SNathan Chancellor static int __maybe_unused imx_mu_suspend_noirq(struct device *dev)
980ba5f9fa0SDong Aisheng {
981ba5f9fa0SDong Aisheng struct imx_mu_priv *priv = dev_get_drvdata(dev);
982f689a7cfSPeng Fan int i;
983ba5f9fa0SDong Aisheng
984f689a7cfSPeng Fan if (!priv->clk) {
985f689a7cfSPeng Fan for (i = 0; i < IMX_MU_xCR_MAX; i++)
986f689a7cfSPeng Fan priv->xcr[i] = imx_mu_read(priv, priv->dcfg->xCR[i]);
987f689a7cfSPeng Fan }
988ba5f9fa0SDong Aisheng
989892cb524SRobin Gong priv->suspend = true;
990892cb524SRobin Gong
991ba5f9fa0SDong Aisheng return 0;
992ba5f9fa0SDong Aisheng }
993ba5f9fa0SDong Aisheng
imx_mu_resume_noirq(struct device * dev)99403b70130SNathan Chancellor static int __maybe_unused imx_mu_resume_noirq(struct device *dev)
995ba5f9fa0SDong Aisheng {
996ba5f9fa0SDong Aisheng struct imx_mu_priv *priv = dev_get_drvdata(dev);
997f689a7cfSPeng Fan int i;
998ba5f9fa0SDong Aisheng
999ba5f9fa0SDong Aisheng /*
1000ba5f9fa0SDong Aisheng * ONLY restore MU when context lost, the TIE could
1001ba5f9fa0SDong Aisheng * be set during noirq resume as there is MU data
1002ba5f9fa0SDong Aisheng * communication going on, and restore the saved
1003ba5f9fa0SDong Aisheng * value will overwrite the TIE and cause MU data
1004ba5f9fa0SDong Aisheng * send failed, may lead to system freeze. This issue
1005ba5f9fa0SDong Aisheng * is observed by testing freeze mode suspend.
1006ba5f9fa0SDong Aisheng */
10078219efd0SRobin Gong if (!priv->clk && !imx_mu_read(priv, priv->dcfg->xCR[0])) {
1008f689a7cfSPeng Fan for (i = 0; i < IMX_MU_xCR_MAX; i++)
1009f689a7cfSPeng Fan imx_mu_write(priv, priv->xcr[i], priv->dcfg->xCR[i]);
1010f689a7cfSPeng Fan }
1011ba5f9fa0SDong Aisheng
1012892cb524SRobin Gong priv->suspend = false;
1013892cb524SRobin Gong
1014ba5f9fa0SDong Aisheng return 0;
1015ba5f9fa0SDong Aisheng }
1016ba5f9fa0SDong Aisheng
imx_mu_runtime_suspend(struct device * dev)101703b70130SNathan Chancellor static int __maybe_unused imx_mu_runtime_suspend(struct device *dev)
1018bb2b2624SAnson Huang {
1019bb2b2624SAnson Huang struct imx_mu_priv *priv = dev_get_drvdata(dev);
1020bb2b2624SAnson Huang
1021bb2b2624SAnson Huang clk_disable_unprepare(priv->clk);
1022bb2b2624SAnson Huang
1023bb2b2624SAnson Huang return 0;
1024bb2b2624SAnson Huang }
1025bb2b2624SAnson Huang
imx_mu_runtime_resume(struct device * dev)102603b70130SNathan Chancellor static int __maybe_unused imx_mu_runtime_resume(struct device *dev)
1027bb2b2624SAnson Huang {
1028bb2b2624SAnson Huang struct imx_mu_priv *priv = dev_get_drvdata(dev);
1029bb2b2624SAnson Huang int ret;
1030bb2b2624SAnson Huang
1031bb2b2624SAnson Huang ret = clk_prepare_enable(priv->clk);
1032bb2b2624SAnson Huang if (ret)
1033bb2b2624SAnson Huang dev_err(dev, "failed to enable clock\n");
1034bb2b2624SAnson Huang
1035bb2b2624SAnson Huang return ret;
1036bb2b2624SAnson Huang }
1037bb2b2624SAnson Huang
1038ba5f9fa0SDong Aisheng static const struct dev_pm_ops imx_mu_pm_ops = {
1039ba5f9fa0SDong Aisheng SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(imx_mu_suspend_noirq,
1040ba5f9fa0SDong Aisheng imx_mu_resume_noirq)
1041bb2b2624SAnson Huang SET_RUNTIME_PM_OPS(imx_mu_runtime_suspend,
1042bb2b2624SAnson Huang imx_mu_runtime_resume, NULL)
1043ba5f9fa0SDong Aisheng };
1044ba5f9fa0SDong Aisheng
10452bb70056SOleksij Rempel static struct platform_driver imx_mu_driver = {
10462bb70056SOleksij Rempel .probe = imx_mu_probe,
10472bb70056SOleksij Rempel .remove = imx_mu_remove,
10482bb70056SOleksij Rempel .driver = {
10492bb70056SOleksij Rempel .name = "imx_mu",
10502bb70056SOleksij Rempel .of_match_table = imx_mu_dt_ids,
1051ba5f9fa0SDong Aisheng .pm = &imx_mu_pm_ops,
10522bb70056SOleksij Rempel },
10532bb70056SOleksij Rempel };
10542bb70056SOleksij Rempel module_platform_driver(imx_mu_driver);
10552bb70056SOleksij Rempel
10562bb70056SOleksij Rempel MODULE_AUTHOR("Oleksij Rempel <o.rempel@pengutronix.de>");
10572bb70056SOleksij Rempel MODULE_DESCRIPTION("Message Unit driver for i.MX");
10582bb70056SOleksij Rempel MODULE_LICENSE("GPL v2");
1059