dt-bindings: add binding for i.MX8MQ CCM
PATCH v2 1/4 dt-bindings: add binding for i.MX8MQ CCM
This adds the binding for the i.MX8MQ Clock Controller Module.
---
v2:
- change vendor prefix to fsl
- pull dt-bindings header into this chance
- use SPDX tag for header
--- .../devicetree/bindings/clock/imx8mq-clock.txt | 20 + include/dt-bindings/clock/imx8mq-clock.h | 629 +++++++++++++++++++++ 2 files changed, 649 insertions(+) create mode 100644 Documentation/devicetree/bindings/clock/imx8mq-clock.txt create mode 100644 include/dt-bindings/clock/imx8mq-clock.h
Documentation/devicetree/bindings/clock/imx8mq-clock.txt new file +20 -0
@@ -0,0 +1,20 @@ +* Clock bindings for NXP i.MX8M Quad + +Required properties: +- compatible: Should be "fsl,imx8mq-ccm" +- reg: Address and length of the register set +- #clock-cells: Should be <1> +- clocks: list of clock specifiers, must contain an entry for each required + entry in clock-names +- clock-names: should include the following entries: + - "ckil" + - "osc_25m" + - "osc_27m" + - "clk_ext1" + - "clk_ext2" + - "clk_ext3" + - "clk_ext4" + +The clock consumer should specify the desired clock by having the clock +ID in its "clocks" phandle cell. See include/dt-bindings/clock/imx8mq-clock.h +for the full list of i.MX8M Quad clock IDs.
include/dt-bindings/clock/imx8mq-clock.h new file +629 -0
629 lines not on this page · raw message
Signature · 1 line
2.15.1
PATCH v2 2/4 clk: imx: add fractional PLL output clock
This is a new clock type introduced on i.MX8.
--- drivers/clk/imx/Makefile | 1 + drivers/clk/imx/clk-frac-pll.c | 229 +++++++++++++++++++++++++++++++++++++++++ drivers/clk/imx/clk.h | 3 + 3 files changed, 233 insertions(+) create mode 100644 drivers/clk/imx/clk-frac-pll.c
drivers/clk/imx/Makefile +1 -0
@@ -6,6 +6,7 @@ obj-y += \ clk-cpu.o \ clk-fixup-div.o \ clk-fixup-mux.o \ + clk-frac-pll.o \ clk-gate-exclusive.o \ clk-gate2.o \ clk-pllv1.o \
drivers/clk/imx/clk-frac-pll.c new file +229 -0
229 lines not on this page · raw message
drivers/clk/imx/clk.h +3 -0
@@ -27,6 +27,9 @@ struct clk *imx_clk_pllv1(enum imx_pllv1_type type, const char *name,struct clk *imx_clk_pllv2 (const char *name,const char *parent,void __iomem *base); +struct clk *imx_clk_frac_pll (const char *name,const char *parent_name, +void __iomem *base); +enum imx_pllv3_type {IMX_PLLV3_GENERIC ,IMX_PLLV3_SYS ,
Signature · 1 line
2.15.1
PATCH v2 2/4 clk: imx: add fractional PLL output clock
Quoted 28 lines · Lucas Stach
This is a new clock type introduced on i.MX8.
Signed-off-by Lucas Stach <[email protected]>--- drivers/clk/imx/Makefile | 1 + drivers/clk/imx/clk-frac-pll.c | 229 +++++++++++++++++++++++++++++++++++++++++ drivers/clk/imx/clk.h | 3 + 3 files changed, 233 insertions(+) create mode 100644 drivers/clk/imx/clk-frac-pll.cdrivers/clk/imx/Makefile +1
-0@@ -6,6 +6,7 @@ obj-y += \ clk-cpu.o \ clk-fixup-div.o \ clk-fixup-mux.o \ + clk-frac-pll.o \ clk-gate-exclusive.o \ clk-gate2.o \ clk-pllv1.o \drivers/clk/imx/clk-frac-pll.c new file +0
-0
drivers/clk/imx/clk-frac-pll.c line 9
Quoted 9 lines
drivers/clk/imx/clk-frac-pll.c new file +9
-0@@ -0,0 +1,229 @@ +/* +* Copyright 2017 NXP. +* +* The code contained herein is licensed under the GNU General Public +* License. You may obtain a copy of the GNU General Public License +* Version 2 or later at the following locations: +* +* http://www.opensource.org/licenses/gpl-license.html +* http://www.gnu.org/copyleft/gpl.html
The SPDX tag is being used for include/dt-bindings/clock/imx8mq-clock.h. It may be good for all clock driver new files as well?
drivers/clk/imx/clk-frac-pll.c line 16
Quoted 7 lines
drivers/clk/imx/clk-frac-pll.c new file +7
-0+*/ + +#include <linux/clk-provider.h> +#include <linux/err.h> +#include <linux/io.h> +#include <linux/slab.h> +#include <linux/jiffies.h>
Sort them alphabetically?
drivers/clk/imx/clk-frac-pll.c line 24
Quoted 8 lines
drivers/clk/imx/clk-frac-pll.c new file +8
-0+ +#include "clk.h" + +#define PLL_CFG0 0x0 +#define PLL_CFG1 0x4 + +#define PLL_LOCK_STATUS (0x1 << 31) +#define PLL_CLKE 21
Unused define?
drivers/clk/imx/clk-frac-pll.c line 28
Quoted 4 lines
drivers/clk/imx/clk-frac-pll.c new file +4
-0+#define PLL_PD 19 +#define PLL_BYPASS 14 +#define PLL_NEWDIV_VAL (1 << 12) +#define PLL_NEWDIV_ACK (1 << 11)
0x1 in PLL_LOCK_STATUS and 1 here lack consistency. Maybe BIT() even better?
drivers/clk/imx/clk-frac-pll.c line 31
Quoted 3 lines
drivers/clk/imx/clk-frac-pll.c new file +3
-0+#define PLL_FRAC_DIV_MASK 0xffffff +#define PLL_INT_DIV_MASK 0x7f +#define PLL_FRAC_DENOM 0x1000000
Can we make the indentation of all these defines consistent?
Quoted 19 lines
drivers/clk/imx/clk-frac-pll.c new file +19
-0+ +struct clk_frac_pll { +struct clk_hw hw; +void __iomem *base; +}; + +#define to_clk_frac_pll (_hw) container_of(_hw, struct clk_frac_pll, hw) + +static int clk_wait_lock (struct clk_frac_pll *pll) +{ +unsigned long timeout = jiffies +msecs_to_jiffies (10 ); + +/* Wait for PLL to lock */ +do { +if (readl_relaxed (pll->base) &PLL_LOCK_STATUS ) +break ; +if (time_after (jiffies, timeout)) +break ; + }while (1 );
drivers/clk/imx/clk-frac-pll.c line 60
Quoted 10 lines
drivers/clk/imx/clk-frac-pll.c new file +10
-0+ +return readl_relaxed (pll->base) &PLL_LOCK_STATUS ?0 : -ETIMEDOUT ; +} + +static int clk_wait_ack (struct clk_frac_pll *pll) +{ +unsigned long timeout = jiffies +msecs_to_jiffies (50 ); + +/* return directly if the pll is in powerdown or in bypass */ +if (readl_relaxed (pll->base) & ((1 <<PLL_PD ) | (1 <<PLL_BYPASS )))
Instead of bit shift, it seems that defining PLL_PD and PLL_BYPASS as bit mask will make the code a bit simpler.
Quoted 103 lines
drivers/clk/imx/clk-frac-pll.c new file +103
-0+return 0 ; + +/* Wait for the pll's divfi and divff to be reloaded */ +do { +if (readl_relaxed (pll->base) &PLL_NEWDIV_ACK ) +break ; +if (time_after (jiffies, timeout)) +break ; + }while (1 ); + +return readl_relaxed (pll->base) &PLL_NEWDIV_ACK ?0 :ETIMEDOUT ; +} + +static int clk_pll_prepare (struct clk_hw *hw) +{ +struct clk_frac_pll *pll =to_clk_frac_pll (hw); +u32 val; + + val =readl_relaxed (pll->base +PLL_CFG0 ); + val &= ~(1 <<PLL_PD ); +writel_relaxed (val, pll->base +PLL_CFG0 ); + +return clk_wait_lock (pll); +} + +static void clk_pll_unprepare (struct clk_hw *hw) +{ +struct clk_frac_pll *pll =to_clk_frac_pll (hw); +u32 val; + + val =readl_relaxed (pll->base +PLL_CFG0 ); + val |= (1 <<PLL_PD ); +writel_relaxed (val, pll->base +PLL_CFG0 ); +} + +static int clk_pll_is_prepared (struct clk_hw *hw) +{ +struct clk_frac_pll *pll =to_clk_frac_pll (hw); +u32 val; + + val =readl_relaxed (pll->base +PLL_CFG0 ); +return (val & (1 <<PLL_PD )) ?0 :1 ; +} + +static unsigned long clk_pll_recalc_rate (struct clk_hw *hw, +unsigned long parent_rate) +{ +struct clk_frac_pll *pll =to_clk_frac_pll (hw); +u32 val, divff, divfi, divq; +u64 temp64; + + val =readl_relaxed (pll->base +PLL_CFG0 ); + divq = ((val &0x1f ) +1 ) *2 ; + val =readl_relaxed (pll->base +PLL_CFG1 ); + divff = (val >>7 ) &PLL_FRAC_DIV_MASK ; + divfi = (val &PLL_INT_DIV_MASK ); + + temp64 = (u64 )parent_rate *8 ; + temp64 *= divff; +do_div (temp64,PLL_FRAC_DENOM ); + temp64 /= divq; + +return parent_rate *8 * (divfi +1 ) / divq + (unsigned long )temp64; +} + +static long clk_pll_round_rate (struct clk_hw *hw,unsigned long rate, +unsigned long *prate) +{ +u32 divff, divfi; +u64 temp64; +unsigned long parent_rate = *prate; + + parent_rate *=8 ; + rate *=2 ; + divfi = rate / parent_rate; + temp64 = (u64)(rate - divfi * parent_rate); + temp64 *=PLL_FRAC_DENOM ; +do_div (temp64, parent_rate); + divff = temp64; + + temp64 = (u64 )parent_rate; + temp64 *= divff; +do_div (temp64,PLL_FRAC_DENOM ); + +return (parent_rate * divfi + (unsigned long )temp64) /2 ; +} + +/* +* To simplify the clock calculation, we can keep the 'PLL_OUTPUT_VAL' at zero +* (means the PLL output will be divided by 2). So the PLL output can use +* the below formula: +* pllout = parent_rate * 8 / 2 * DIVF_VAL; +* where DIVF_VAL = 1 + DIVFI + DIVFF / 2^24. +*/ +static int clk_pll_set_rate (struct clk_hw *hw,unsigned long rate, +unsigned long parent_rate) +{ +struct clk_frac_pll *pll =to_clk_frac_pll (hw); +u32 val, divfi, divff; +u64 temp64; +int ret; + + parent_rate *=8 ;
drivers/clk/imx/clk-frac-pll.c line 173
Quoted 10 lines
drivers/clk/imx/clk-frac-pll.c new file +10
-0+ rate *=2 ; + divfi = rate / parent_rate; + temp64 = (u64) (rate - divfi * parent_rate); + temp64 *=PLL_FRAC_DENOM ; +do_div (temp64, parent_rate); + divff = temp64; + + val =readl_relaxed (pll->base +PLL_CFG1 ); + val &= ~((PLL_FRAC_DIV_MASK <<7 ) | (PLL_INT_DIV_MASK )); + val |= ((divff <<7 ) | (divfi -1 ));
val |= (divff << 7) | (divfi - 1);
Shawn
Quoted 73 lines
drivers/clk/imx/clk-frac-pll.c new file +56
-0+writel_relaxed (val, pll->base +PLL_CFG1 ); + + val =readl_relaxed (pll->base +PLL_CFG0 ); + val &= ~0x1f ; +writel_relaxed (val, pll->base +PLL_CFG0 ); + +/* Set the NEV_DIV_VAL to reload the DIVFI and DIVFF */ + val =readl_relaxed (pll->base +PLL_CFG0 ); + val |=PLL_NEWDIV_VAL ; +writel_relaxed (val, pll->base +PLL_CFG0 ); + + ret =clk_wait_ack (pll); + +/* clear the NEV_DIV_VAL */ + val =readl_relaxed (pll->base +PLL_CFG0 ); + val &= ~PLL_NEWDIV_VAL ; +writel_relaxed (val, pll->base +PLL_CFG0 ); + +return ret; +} + +static const struct clk_ops clk_frac_pll_ops = { + .prepare = clk_pll_prepare, + .unprepare = clk_pll_unprepare, + .is_prepared = clk_pll_is_prepared, + .recalc_rate = clk_pll_recalc_rate, + .round_rate = clk_pll_round_rate, + .set_rate = clk_pll_set_rate, +}; + +struct clk *imx_clk_frac_pll (const char *name,const char *parent_name, +void __iomem *base) +{ +struct clk_frac_pll *pll; +struct clk *clk; +struct clk_init_data init; + + pll =kzalloc (sizeof (*pll),GFP_KERNEL ); +if (!pll) +return ERR_PTR (-ENOMEM ); + + pll->base = base; + init.name = name; + init.ops = &clk_frac_pll_ops; + init.flags =0 ; + init.parent_names = &parent_name; + init.num_parents =1 ; + + pll->hw.init = &init; + + clk =clk_register (NULL , &pll->hw); +if (IS_ERR (clk)) +kfree (pll); + +return clk; +}drivers/clk/imx/clk.h +3
-0@@ -27,6 +27,9 @@ struct clk *imx_clk_pllv1(enum imx_pllv1_type type, const char *name,struct clk *imx_clk_pllv2 (const char *name,const char *parent,void __iomem *base); +struct clk *imx_clk_frac_pll (const char *name,const char *parent_name, +void __iomem *base); +enum imx_pllv3_type {IMX_PLLV3_GENERIC ,IMX_PLLV3_SYS ,Signature · 1 line
2.15.1
PATCH v2 2/4 clk: imx: add fractional PLL output clock
In reply to Lucas StachQuoted 28 lines · Lucas Stach
This is a new clock type introduced on i.MX8.
Signed-off-by Lucas Stach <[email protected]>--- drivers/clk/imx/Makefile | 1 + drivers/clk/imx/clk-frac-pll.c | 229 +++++++++++++++++++++++++++++++++++++++++ drivers/clk/imx/clk.h | 3 + 3 files changed, 233 insertions(+) create mode 100644 drivers/clk/imx/clk-frac-pll.cdrivers/clk/imx/Makefile +1
-0@@ -6,6 +6,7 @@ obj-y += \ clk-cpu.o \ clk-fixup-div.o \ clk-fixup-mux.o \ + clk-frac-pll.o \ clk-gate-exclusive.o \ clk-gate2.o \ clk-pllv1.o \drivers/clk/imx/clk-frac-pll.c new file +0
-0
drivers/clk/imx/clk-frac-pll.c line 2
Quoted 2 lines
drivers/clk/imx/clk-frac-pll.c new file +2
-0@@ -0,0 +1,229 @@ +/* +* Copyright 2017 NXP.
Maybe SPDX?
Quoted 16 lines
drivers/clk/imx/clk-frac-pll.c new file +16
-0+* +* The code contained herein is licensed under the GNU General Public +* License. You may obtain a copy of the GNU General Public License +* Version 2 or later at the following locations: +* +* http://www.opensource.org/licenses/gpl-license.html +* http://www.gnu.org/copyleft/gpl.html +*/ + +#include <linux/clk-provider.h> +#include <linux/err.h> +#include <linux/io.h> +#include <linux/slab.h> +#include <linux/jiffies.h> + +#include "clk.h"
drivers/clk/imx/clk-frac-pll.c line 28
Quoted 10 lines
drivers/clk/imx/clk-frac-pll.c new file +10
-0+ +#define PLL_CFG0 0x0 +#define PLL_CFG1 0x4 + +#define PLL_LOCK_STATUS (0x1 << 31) +#define PLL_CLKE 21 +#define PLL_PD 19 +#define PLL_BYPASS 14 +#define PLL_NEWDIV_VAL (1 << 12) +#define PLL_NEWDIV_ACK (1 << 11)
BIT()?
Quoted 15 lines
drivers/clk/imx/clk-frac-pll.c new file +15
-0+#define PLL_FRAC_DIV_MASK 0xffffff +#define PLL_INT_DIV_MASK 0x7f +#define PLL_FRAC_DENOM 0x1000000 + +struct clk_frac_pll { +struct clk_hw hw; +void __iomem *base; +}; + +#define to_clk_frac_pll (_hw) container_of(_hw, struct clk_frac_pll, hw) + +static int clk_wait_lock (struct clk_frac_pll *pll) +{ +unsigned long timeout = jiffies +msecs_to_jiffies (10 ); +
drivers/clk/imx/clk-frac-pll.c line 53
Quoted 10 lines
drivers/clk/imx/clk-frac-pll.c new file +10
-0+/* Wait for PLL to lock */ +do { +if (readl_relaxed (pll->base) &PLL_LOCK_STATUS ) +break ; +if (time_after (jiffies, timeout)) +break ; + }while (1 ); + +return readl_relaxed (pll->base) &PLL_LOCK_STATUS ?0 : -ETIMEDOUT ; +}
how about readl_poll_timeout?
Quoted 9 lines
drivers/clk/imx/clk-frac-pll.c new file +9
-0+ +static int clk_wait_ack (struct clk_frac_pll *pll) +{ +unsigned long timeout = jiffies +msecs_to_jiffies (50 ); + +/* return directly if the pll is in powerdown or in bypass */ +if (readl_relaxed (pll->base) & ((1 <<PLL_PD ) | (1 <<PLL_BYPASS ))) +return 0 ; +
drivers/clk/imx/clk-frac-pll.c line 72
Quoted 10 lines
drivers/clk/imx/clk-frac-pll.c new file +10
-0+/* Wait for the pll's divfi and divff to be reloaded */ +do { +if (readl_relaxed (pll->base) &PLL_NEWDIV_ACK ) +break ; +if (time_after (jiffies, timeout)) +break ; + }while (1 ); + +return readl_relaxed (pll->base) &PLL_NEWDIV_ACK ?0 :ETIMEDOUT ; +}
ditto
drivers/clk/imx/clk-frac-pll.c line 80
Quoted 8 lines
drivers/clk/imx/clk-frac-pll.c new file +8
-0+ +static int clk_pll_prepare (struct clk_hw *hw) +{ +struct clk_frac_pll *pll =to_clk_frac_pll (hw); +u32 val; + + val =readl_relaxed (pll->base +PLL_CFG0 ); + val &= ~(1 <<PLL_PD );
Bitmask
drivers/clk/imx/clk-frac-pll.c line 92
Quoted 12 lines
drivers/clk/imx/clk-frac-pll.c new file +12
-0+writel_relaxed (val, pll->base +PLL_CFG0 ); + +return clk_wait_lock (pll); +} + +static void clk_pll_unprepare (struct clk_hw *hw) +{ +struct clk_frac_pll *pll =to_clk_frac_pll (hw); +u32 val; + + val =readl_relaxed (pll->base +PLL_CFG0 ); + val |= (1 <<PLL_PD );
ditto
drivers/clk/imx/clk-frac-pll.c line 102
Quoted 10 lines
drivers/clk/imx/clk-frac-pll.c new file +10
-0+writel_relaxed (val, pll->base +PLL_CFG0 ); +} + +static int clk_pll_is_prepared (struct clk_hw *hw) +{ +struct clk_frac_pll *pll =to_clk_frac_pll (hw); +u32 val; + + val =readl_relaxed (pll->base +PLL_CFG0 ); +return (val & (1 <<PLL_PD )) ?0 :1 ;
ditto
drivers/clk/imx/clk-frac-pll.c line 113
Quoted 11 lines
drivers/clk/imx/clk-frac-pll.c new file +11
-0+} + +static unsigned long clk_pll_recalc_rate (struct clk_hw *hw, +unsigned long parent_rate) +{ +struct clk_frac_pll *pll =to_clk_frac_pll (hw); +u32 val, divff, divfi, divq; +u64 temp64; + + val =readl_relaxed (pll->base +PLL_CFG0 ); + divq = ((val &0x1f ) +1 ) *2 ;
change 0x1f to PLL_OUTPUT_DIV_MASK?
Quoted 8 lines
drivers/clk/imx/clk-frac-pll.c new file +8
-0+ val =readl_relaxed (pll->base +PLL_CFG1 ); + divff = (val >>7 ) &PLL_FRAC_DIV_MASK ; + divfi = (val &PLL_INT_DIV_MASK ); + + temp64 = (u64 )parent_rate *8 ; + temp64 *= divff; +do_div (temp64,PLL_FRAC_DENOM ); + temp64 /= divq;
drivers/clk/imx/clk-frac-pll.c line 131
Quoted 10 lines
drivers/clk/imx/clk-frac-pll.c new file +10
-0+ +return parent_rate *8 * (divfi +1 ) / divq + (unsigned long )temp64; +} + +static long clk_pll_round_rate (struct clk_hw *hw,unsigned long rate, +unsigned long *prate) +{ +u32 divff, divfi; +u64 temp64; +unsigned long parent_rate = *prate;
sort from long to short?
Quoted 77 lines
drivers/clk/imx/clk-frac-pll.c new file +77
-0+ + parent_rate *=8 ; + rate *=2 ; + divfi = rate / parent_rate; + temp64 = (u64)(rate - divfi * parent_rate); + temp64 *=PLL_FRAC_DENOM ; +do_div (temp64, parent_rate); + divff = temp64; + + temp64 = (u64 )parent_rate; + temp64 *= divff; +do_div (temp64,PLL_FRAC_DENOM ); + +return (parent_rate * divfi + (unsigned long )temp64) /2 ; +} + +/* +* To simplify the clock calculation, we can keep the 'PLL_OUTPUT_VAL' at zero +* (means the PLL output will be divided by 2). So the PLL output can use +* the below formula: +* pllout = parent_rate * 8 / 2 * DIVF_VAL; +* where DIVF_VAL = 1 + DIVFI + DIVFF / 2^24. +*/ +static int clk_pll_set_rate (struct clk_hw *hw,unsigned long rate, +unsigned long parent_rate) +{ +struct clk_frac_pll *pll =to_clk_frac_pll (hw); +u32 val, divfi, divff; +u64 temp64; +int ret; + + parent_rate *=8 ; + rate *=2 ; + divfi = rate / parent_rate; + temp64 = (u64) (rate - divfi * parent_rate); + temp64 *=PLL_FRAC_DENOM ; +do_div (temp64, parent_rate); + divff = temp64; + + val =readl_relaxed (pll->base +PLL_CFG1 ); + val &= ~((PLL_FRAC_DIV_MASK <<7 ) | (PLL_INT_DIV_MASK )); + val |= ((divff <<7 ) | (divfi -1 )); +writel_relaxed (val, pll->base +PLL_CFG1 ); + + val =readl_relaxed (pll->base +PLL_CFG0 ); + val &= ~0x1f ; +writel_relaxed (val, pll->base +PLL_CFG0 ); + +/* Set the NEV_DIV_VAL to reload the DIVFI and DIVFF */ + val =readl_relaxed (pll->base +PLL_CFG0 ); + val |=PLL_NEWDIV_VAL ; +writel_relaxed (val, pll->base +PLL_CFG0 ); + + ret =clk_wait_ack (pll); + +/* clear the NEV_DIV_VAL */ + val =readl_relaxed (pll->base +PLL_CFG0 ); + val &= ~PLL_NEWDIV_VAL ; +writel_relaxed (val, pll->base +PLL_CFG0 ); + +return ret; +} + +static const struct clk_ops clk_frac_pll_ops = { + .prepare = clk_pll_prepare, + .unprepare = clk_pll_unprepare, + .is_prepared = clk_pll_is_prepared, + .recalc_rate = clk_pll_recalc_rate, + .round_rate = clk_pll_round_rate, + .set_rate = clk_pll_set_rate, +}; + +struct clk *imx_clk_frac_pll (const char *name,const char *parent_name, +void __iomem *base) +{ +struct clk_frac_pll *pll; +struct clk *clk;
drivers/clk/imx/clk-frac-pll.c line 218
Quoted 10 lines
drivers/clk/imx/clk-frac-pll.c new file +10
-0+struct clk_init_data init; + + pll =kzalloc (sizeof (*pll),GFP_KERNEL ); +if (!pll) +return ERR_PTR (-ENOMEM ); + + pll->base = base; + init.name = name; + init.ops = &clk_frac_pll_ops; + init.flags =0 ;
unneeded
drivers/clk/imx/clk-frac-pll.c line 224
Quoted 6 lines
drivers/clk/imx/clk-frac-pll.c new file +6
-0+ init.parent_names = &parent_name; + init.num_parents =1 ; + + pll->hw.init = &init; + + clk =clk_register (NULL , &pll->hw);
clk_hw_register?
CLK maintainer requested to use clk_hw APIs before, so i guess you may need change all other as well.
Regards
Dong Aisheng
Quoted 26 lines
drivers/clk/imx/clk-frac-pll.c new file +5
-0+if (IS_ERR (clk)) +kfree (pll); + +return clk; +}drivers/clk/imx/clk.h +3
-0@@ -27,6 +27,9 @@ struct clk *imx_clk_pllv1(enum imx_pllv1_type type, const char *name,struct clk *imx_clk_pllv2 (const char *name,const char *parent,void __iomem *base); +struct clk *imx_clk_frac_pll (const char *name,const char *parent_name, +void __iomem *base); +enum imx_pllv3_type {IMX_PLLV3_GENERIC ,IMX_PLLV3_SYS ,Signature · 6 lines
2.15.1 -- To unsubscribe from this list: send the line "unsubscribe linux-clk" in the body of a message to majordomo at vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH v2 3/4 clk: imx: add SCCG PLL type
In reply to Lucas StachThe SCCG is a new PLL type introduced on i.MX8. Add support for this. The driver currently misses the PLL lock check, as the preliminary documentation mentions lock configurations, but is quiet about where to find the actual lock status signal.
--- drivers/clk/imx/Makefile | 3 +- drivers/clk/imx/clk-sccg-pll.c | 235 +++++++++++++++++++++++++++++++++++++++++ drivers/clk/imx/clk.h | 9 ++ 3 files changed, 246 insertions(+), 1 deletion(-) create mode 100644 drivers/clk/imx/clk-sccg-pll.c
drivers/clk/imx/Makefile +2 -1
@@ -12,7 +12,8 @@ obj-y += \ clk-pllv1.o \ clk-pllv2.o \ clk-pllv3.o \ - clk-pfd.o + clk-pfd.o \ + clk-sccg-pll.o obj-$(CONFIG_SOC_IMX1) += clk-imx1.o obj-$(CONFIG_SOC_IMX21) += clk-imx21.o
drivers/clk/imx/clk-sccg-pll.c new file +235 -0
235 lines not on this page · raw message
drivers/clk/imx/clk.h +9 -0
@@ -21,6 +21,11 @@ enum imx_pllv1_type { IMX_PLLV1_IMX35, }; +enum imx_sccg_pll_type { +SCCG_PLL1 , +SCCG_PLL2 , +}; +struct clk *imx_clk_pllv1 (enum imx_pllv1_type type,const char *name,const char *parent,void __iomem *base);
@@ -30,6 +35,10 @@ struct clk *imx_clk_pllv2(const char *name, const char *parent,struct clk *imx_clk_frac_pll (const char *name,const char *parent_name,void __iomem *base); +struct clk *imx_clk_sccg_pll (const char *name,const char *parent_name, +void __iomem *base, +enum imx_sccg_pll_type pll_type); +enum imx_pllv3_type {IMX_PLLV3_GENERIC ,IMX_PLLV3_SYS ,
Signature · 1 line
2.15.1
PATCH v2 3/4 clk: imx: add SCCG PLL type
Quoted 81 lines · Lucas Stach
The SCCG is a new PLL type introduced on i.MX8. Add support for this. The driver currently misses the PLL lock check, as the preliminary documentation mentions lock configurations, but is quiet about where to find the actual lock status signal.
Signed-off-by Lucas Stach <[email protected]>--- drivers/clk/imx/Makefile | 3 +- drivers/clk/imx/clk-sccg-pll.c | 235 +++++++++++++++++++++++++++++++++++++++++ drivers/clk/imx/clk.h | 9 ++ 3 files changed, 246 insertions(+), 1 deletion(-) create mode 100644 drivers/clk/imx/clk-sccg-pll.cdrivers/clk/imx/Makefile +2
-1@@ -12,7 +12,8 @@ obj-y += \ clk-pllv1.o \ clk-pllv2.o \ clk-pllv3.o \ - clk-pfd.o + clk-pfd.o \ + clk-sccg-pll.o obj-$(CONFIG_SOC_IMX1) += clk-imx1.o obj-$(CONFIG_SOC_IMX21) += clk-imx21.odrivers/clk/imx/clk-sccg-pll.c new file +48
-0@@ -0,0 +1,235 @@ +/* +* Copyright 2017 NXP. +* +* The code contained herein is licensed under the GNU General Public +* License. You may obtain a copy of the GNU General Public License +* Version 2 or later at the following locations: +* +* http://www.opensource.org/licenses/gpl-license.html +* http://www.gnu.org/copyleft/gpl.html +*/ + +#include <linux/clk.h> +#include <linux/err.h> +#include <linux/io.h> +#include <linux/slab.h> + +#include "clk.h" + +/* PLL CFGs */ +#define PLL_CFG0 0x0 +#define PLL_CFG1 0x4 +#define PLL_CFG2 0x8 + +#define PLL_DIVF1_SHIFT 13 +#define PLL_DIVF2_SHIFT 7 +#define PLL_DIVF_MASK 0x3f + +#define PLL_DIVR1_SHIFT 25 +#define PLL_DIVR2_SHIFT 19 +#define PLL_DIVR1_MASK 0x3 +#define PLL_DIVR2_MASK 0x3f +#define PLL_REF_SHIFT 0 +#define PLL_REF_MASK 0x3 + +#define PLL_LOCK 31 +#define PLL_PD 7 + +#define OSC_25M 25000000 +#define OSC_27M 27000000 + +struct clk_sccg_pll { +struct clk_hw hw; +void __iomem *base; +}; + +#define to_clk_sccg_pll (_hw) container_of(_hw, struct clk_sccg_pll, hw) + +static int clk_pll1_is_prepared (struct clk_hw *hw)
drivers/clk/imx/clk-sccg-pll.c line 58
Quoted 10 lines
drivers/clk/imx/clk-sccg-pll.c new file +10
-0+{ +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); +u32 val; + + val =readl_relaxed (pll->base +PLL_CFG0 ); +return (val & (1 <<PLL_PD )) ?0 :1 ; +} + +static unsigned long clk_pll1_recalc_rate (struct clk_hw *hw, +unsigned long parent_rate)
I found the indentation of multi-lines arguments is strange, i.e. it always missing one space. Please check.
Quoted 51 lines
drivers/clk/imx/clk-sccg-pll.c new file +51
-0+{ +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); +u32 val, divf; + + val =readl_relaxed (pll->base +PLL_CFG2 ); + divf = (val >>PLL_DIVF1_SHIFT ) &PLL_DIVF_MASK ; + +return parent_rate *2 * (divf +1 ); +} + +static long clk_pll1_round_rate (struct clk_hw *hw,unsigned long rate, +unsigned long *prate) +{ +unsigned long parent_rate = *prate; +u32 div; + + div = rate / (parent_rate *2 ); + +return parent_rate * div *2 ; +} + +static int clk_pll1_set_rate (struct clk_hw *hw,unsigned long rate, +unsigned long parent_rate) +{ +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); +u32 val; +u32 divf; + + divf = rate / (parent_rate *2 ); + + val =readl_relaxed (pll->base +PLL_CFG2 ); + val &= ~(PLL_DIVF_MASK <<PLL_DIVF1_SHIFT ); + val |= (divf -1 ) <<PLL_DIVF1_SHIFT ; +writel_relaxed (val, pll->base +PLL_CFG2 ); + +/* FIXME: PLL lock check */ + +return 0 ; +} + +static int clk_pll1_prepare (struct clk_hw *hw) +{ +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); +u32 val; + + val =readl_relaxed (pll->base); + val &= ~(1 <<PLL_PD ); +writel_relaxed (val, pll->base); + +/* FIXME: PLL lock check */ +
drivers/clk/imx/clk-sccg-pll.c line 119
Quoted 10 lines
drivers/clk/imx/clk-sccg-pll.c new file +10
-0+return 0 ; +} + +static void clk_pll1_unprepare (struct clk_hw *hw) +{ +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); +u32 val; + + val =readl_relaxed (pll->base); + val |= (1 <<PLL_PD );
Unnecessary parentheses.
Quoted 32 lines
drivers/clk/imx/clk-sccg-pll.c new file +32
-0+writel_relaxed (val, pll->base); +} + +static unsigned long clk_pll2_recalc_rate (struct clk_hw *hw, +unsigned long parent_rate) +{ +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); +u32 val, ref, divr1, divf1, divr2, divf2; +u64 temp64; + + val =readl_relaxed (pll->base +PLL_CFG0 ); +switch ((val >>PLL_REF_SHIFT ) &PLL_REF_MASK ) { +case 0 : + ref =OSC_25M ; +break ; +case 1 : + ref =OSC_27M ; +break ; +default : + ref =OSC_25M ; +break ; + } + + val =readl_relaxed (pll->base +PLL_CFG2 ); + divr1 = (val >>PLL_DIVR1_SHIFT ) &PLL_DIVR1_MASK ; + divr2 = (val >>PLL_DIVR2_SHIFT ) &PLL_DIVR2_MASK ; + divf1 = (val >>PLL_DIVF1_SHIFT ) &PLL_DIVF_MASK ; + divf2 = (val >>PLL_DIVF2_SHIFT ) &PLL_DIVF_MASK ; + + temp64 = ref *2 ; + temp64 *= (divf1 +1 ) * (divf2 +1 ); +
drivers/clk/imx/clk-sccg-pll.c line 161
Quoted 10 lines
drivers/clk/imx/clk-sccg-pll.c new file +10
-0+do_div (temp64, (divr1 +1 ) * (divr2 +1 )); + +return (unsigned long )temp64; +} + +static long clk_pll2_round_rate (struct clk_hw *hw,unsigned long rate, +unsigned long *prate) +{ +u32 div; +unsigned long parent_rate = *prate;
Can we consistently sort variables lines from the long ones to the short?
drivers/clk/imx/clk-sccg-pll.c line 163
Quoted 2 lines
drivers/clk/imx/clk-sccg-pll.c new file +2
-0+ + div = rate / (parent_rate);
Unnecessary parentheses.
drivers/clk/imx/clk-sccg-pll.c line 175
Quoted 12 lines
drivers/clk/imx/clk-sccg-pll.c new file +12
-0+ +return parent_rate * div; +} + +static int clk_pll2_set_rate (struct clk_hw *hw,unsigned long rate, +unsigned long parent_rate) +{ +u32 val; +u32 divf; +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); + + divf = rate / (parent_rate);
Ditto
Shawn
Quoted 90 lines
drivers/clk/imx/clk-sccg-pll.c new file +60
-0+ + val =readl_relaxed (pll->base +PLL_CFG2 ); + val &= ~(PLL_DIVF_MASK <<PLL_DIVF2_SHIFT ); + val |= (divf -1 ) <<PLL_DIVF2_SHIFT ; +writel_relaxed (val, pll->base +PLL_CFG2 ); + +/* FIXME: PLL lock check */ + +return 0 ; +} + +static const struct clk_ops clk_sccg_pll1_ops = { + .is_prepared = clk_pll1_is_prepared, + .recalc_rate = clk_pll1_recalc_rate, + .round_rate = clk_pll1_round_rate, + .set_rate = clk_pll1_set_rate, +}; + +static const struct clk_ops clk_sccg_pll2_ops = { + .prepare = clk_pll1_prepare, + .unprepare = clk_pll1_unprepare, + .recalc_rate = clk_pll2_recalc_rate, + .round_rate = clk_pll2_round_rate, + .set_rate = clk_pll2_set_rate, +}; + +struct clk *imx_clk_sccg_pll (const char *name,const char *parent_name, +void __iomem *base,enum imx_sccg_pll_type pll_type) +{ +struct clk_sccg_pll *pll; +struct clk *clk; +struct clk_init_data init; + + pll =kzalloc (sizeof (*pll),GFP_KERNEL ); +if (!pll) +return ERR_PTR (-ENOMEM ); + + pll->base = base; + init.name = name; +switch (pll_type) { +case SCCG_PLL1 : + init.ops = &clk_sccg_pll1_ops; +break ; +case SCCG_PLL2 : + init.ops = &clk_sccg_pll2_ops; +break ; + } + + init.flags =0 ; + init.parent_names = &parent_name; + init.num_parents =1 ; + + pll->hw.init = &init; + + clk =clk_register (NULL , &pll->hw); +if (IS_ERR (clk)) +kfree (pll); + +return clk; +}drivers/clk/imx/clk.h +9
-0@@ -21,6 +21,11 @@ enum imx_pllv1_type { IMX_PLLV1_IMX35, }; +enum imx_sccg_pll_type { +SCCG_PLL1 , +SCCG_PLL2 , +}; +struct clk *imx_clk_pllv1 (enum imx_pllv1_type type,const char *name,const char *parent,void __iomem *base);@@ -30,6 +35,10 @@ struct clk *imx_clk_pllv2(const char *name, const char *parent,struct clk *imx_clk_frac_pll (const char *name,const char *parent_name,void __iomem *base); +struct clk *imx_clk_sccg_pll (const char *name,const char *parent_name, +void __iomem *base, +enum imx_sccg_pll_type pll_type); +enum imx_pllv3_type {IMX_PLLV3_GENERIC ,IMX_PLLV3_SYS ,Signature · 1 line
2.15.1
PATCH v2 3/4 clk: imx: add SCCG PLL type
In reply to Lucas StachQuoted 5 lines · Lucas Stach
The SCCG is a new PLL type introduced on i.MX8. Add support for this. The driver currently misses the PLL lock check, as the preliminary documentation mentions lock configurations, but is quiet about where to find the actual lock status signal.
Why? Can't use PLL_LOCK bit?
BTW, i think the comments should mention that it breaks down the SSCG PLL into two PLLS part with a few extra dividers.
The easiest way for user may compose them into one. But as this PLL indeed is much complicated, i'm ok to divide them tempoparily at this stage.
Quoted 72 lines
Signed-off-by Lucas Stach <[email protected]>--- drivers/clk/imx/Makefile | 3 +- drivers/clk/imx/clk-sccg-pll.c | 235 +++++++++++++++++++++++++++++++++++++++++ drivers/clk/imx/clk.h | 9 ++ 3 files changed, 246 insertions(+), 1 deletion(-) create mode 100644 drivers/clk/imx/clk-sccg-pll.cdrivers/clk/imx/Makefile +2
-1@@ -12,7 +12,8 @@ obj-y += \ clk-pllv1.o \ clk-pllv2.o \ clk-pllv3.o \ - clk-pfd.o + clk-pfd.o \ + clk-sccg-pll.o obj-$(CONFIG_SOC_IMX1) += clk-imx1.o obj-$(CONFIG_SOC_IMX21) += clk-imx21.odrivers/clk/imx/clk-sccg-pll.c new file +44
-0@@ -0,0 +1,235 @@ +/* +* Copyright 2017 NXP. +* +* The code contained herein is licensed under the GNU General Public +* License. You may obtain a copy of the GNU General Public License +* Version 2 or later at the following locations: +* +* http://www.opensource.org/licenses/gpl-license.html +* http://www.gnu.org/copyleft/gpl.html +*/ + +#include <linux/clk.h> +#include <linux/err.h> +#include <linux/io.h> +#include <linux/slab.h> + +#include "clk.h" + +/* PLL CFGs */ +#define PLL_CFG0 0x0 +#define PLL_CFG1 0x4 +#define PLL_CFG2 0x8 + +#define PLL_DIVF1_SHIFT 13 +#define PLL_DIVF2_SHIFT 7 +#define PLL_DIVF_MASK 0x3f + +#define PLL_DIVR1_SHIFT 25 +#define PLL_DIVR2_SHIFT 19 +#define PLL_DIVR1_MASK 0x3 +#define PLL_DIVR2_MASK 0x3f +#define PLL_REF_SHIFT 0 +#define PLL_REF_MASK 0x3 + +#define PLL_LOCK 31 +#define PLL_PD 7 + +#define OSC_25M 25000000 +#define OSC_27M 27000000 + +struct clk_sccg_pll { +struct clk_hw hw; +void __iomem *base; +};
drivers/clk/imx/clk-sccg-pll.c line 54
Quoted 10 lines
drivers/clk/imx/clk-sccg-pll.c new file +10
-0+ +#define to_clk_sccg_pll (_hw) container_of(_hw, struct clk_sccg_pll, hw) + +static int clk_pll1_is_prepared (struct clk_hw *hw) +{ +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); +u32 val; + + val =readl_relaxed (pll->base +PLL_CFG0 ); +return (val & (1 <<PLL_PD )) ?0 :1 ;
BM_PLL_PD BIT(7)
Quoted 89 lines
drivers/clk/imx/clk-sccg-pll.c new file +89
-0+} + +static unsigned long clk_pll1_recalc_rate (struct clk_hw *hw, +unsigned long parent_rate) +{ +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); +u32 val, divf; + + val =readl_relaxed (pll->base +PLL_CFG2 ); + divf = (val >>PLL_DIVF1_SHIFT ) &PLL_DIVF_MASK ; + +return parent_rate *2 * (divf +1 ); +} + +static long clk_pll1_round_rate (struct clk_hw *hw,unsigned long rate, +unsigned long *prate) +{ +unsigned long parent_rate = *prate; +u32 div; + + div = rate / (parent_rate *2 ); + +return parent_rate * div *2 ; +} + +static int clk_pll1_set_rate (struct clk_hw *hw,unsigned long rate, +unsigned long parent_rate) +{ +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); +u32 val; +u32 divf; + + divf = rate / (parent_rate *2 ); + + val =readl_relaxed (pll->base +PLL_CFG2 ); + val &= ~(PLL_DIVF_MASK <<PLL_DIVF1_SHIFT ); + val |= (divf -1 ) <<PLL_DIVF1_SHIFT ; +writel_relaxed (val, pll->base +PLL_CFG2 ); + +/* FIXME: PLL lock check */ + +return 0 ; +} + +static int clk_pll1_prepare (struct clk_hw *hw) +{ +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); +u32 val; + + val =readl_relaxed (pll->base); + val &= ~(1 <<PLL_PD ); +writel_relaxed (val, pll->base); + +/* FIXME: PLL lock check */ + +return 0 ; +} + +static void clk_pll1_unprepare (struct clk_hw *hw) +{ +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); +u32 val; + + val =readl_relaxed (pll->base); + val |= (1 <<PLL_PD ); +writel_relaxed (val, pll->base); +} + +static unsigned long clk_pll2_recalc_rate (struct clk_hw *hw, +unsigned long parent_rate) +{ +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); +u32 val, ref, divr1, divf1, divr2, divf2; +u64 temp64; + + val =readl_relaxed (pll->base +PLL_CFG0 ); +switch ((val >>PLL_REF_SHIFT ) &PLL_REF_MASK ) { +case 0 : + ref =OSC_25M ; +break ; +case 1 : + ref =OSC_27M ; +break ; +default : + ref =OSC_25M ; +break ; + } + + val =readl_relaxed (pll->base +PLL_CFG2 );
drivers/clk/imx/clk-sccg-pll.c line 153
Quoted 10 lines
drivers/clk/imx/clk-sccg-pll.c new file +10
-0+ divr1 = (val >>PLL_DIVR1_SHIFT ) &PLL_DIVR1_MASK ; + divr2 = (val >>PLL_DIVR2_SHIFT ) &PLL_DIVR2_MASK ; + divf1 = (val >>PLL_DIVF1_SHIFT ) &PLL_DIVF_MASK ; + divf2 = (val >>PLL_DIVF2_SHIFT ) &PLL_DIVF_MASK ; + + temp64 = ref *2 ; + temp64 *= (divf1 +1 ) * (divf2 +1 ); + +do_div (temp64, (divr1 +1 ) * (divr2 +1 )); +
Here it looks strange to me.
We break down the SSCG PLL into two parts. But here we manually calculate the PLL rate from HW register value instead of referring to the parent_rate. Seems like a layer violation.
Any strong reason to do this?
Quoted 17 lines
drivers/clk/imx/clk-sccg-pll.c new file +17
-0+return (unsigned long )temp64; +} + +static long clk_pll2_round_rate (struct clk_hw *hw,unsigned long rate, +unsigned long *prate) +{ +u32 div; +unsigned long parent_rate = *prate; + + div = rate / (parent_rate); + +return parent_rate * div; +} + +static int clk_pll2_set_rate (struct clk_hw *hw,unsigned long rate, +unsigned long parent_rate) +{
drivers/clk/imx/clk-sccg-pll.c line 180
Quoted 10 lines
drivers/clk/imx/clk-sccg-pll.c new file +10
-0+u32 val; +u32 divf; +struct clk_sccg_pll *pll =to_clk_sccg_pll (hw); + + divf = rate / (parent_rate); + + val =readl_relaxed (pll->base +PLL_CFG2 ); + val &= ~(PLL_DIVF_MASK <<PLL_DIVF2_SHIFT ); + val |= (divf -1 ) <<PLL_DIVF2_SHIFT ; +writel_relaxed (val, pll->base +PLL_CFG2 );
I wonder pretending the PLL2 as a simple divider (only mult divf2) may break the fractional divider capability.
Probably we shouldn't create another divider behind pll2. e.g. sys1_pll2_div
drivers/clk/imx/clk-sccg-pll.c line 95
Quoted 3 lines
drivers/clk/imx/clk-sccg-pll.c new file +3
-0+ +/* FIXME: PLL lock check */ +
check PLL_LOCK here
drivers/clk/imx/clk-sccg-pll.c line 188
Quoted 5 lines
drivers/clk/imx/clk-sccg-pll.c new file +5
-0+return 0 ; +} + +static const struct clk_ops clk_sccg_pll1_ops = { + .is_prepared = clk_pll1_is_prepared,
Should this belong to pll2?
Quoted 23 lines
drivers/clk/imx/clk-sccg-pll.c new file +23
-0+ .recalc_rate = clk_pll1_recalc_rate, + .round_rate = clk_pll1_round_rate, + .set_rate = clk_pll1_set_rate, +}; + +static const struct clk_ops clk_sccg_pll2_ops = { + .prepare = clk_pll1_prepare, + .unprepare = clk_pll1_unprepare, + .recalc_rate = clk_pll2_recalc_rate, + .round_rate = clk_pll2_round_rate, + .set_rate = clk_pll2_set_rate, +}; + +struct clk *imx_clk_sccg_pll (const char *name,const char *parent_name, +void __iomem *base,enum imx_sccg_pll_type pll_type) +{ +struct clk_sccg_pll *pll; +struct clk *clk; +struct clk_init_data init; + + pll =kzalloc (sizeof (*pll),GFP_KERNEL ); +if (!pll) +return ERR_PTR (-ENOMEM );
drivers/clk/imx/clk-sccg-pll.c line 221
Quoted 10 lines
drivers/clk/imx/clk-sccg-pll.c new file +10
-0+ + pll->base = base; + init.name = name; +switch (pll_type) { +case SCCG_PLL1 : + init.ops = &clk_sccg_pll1_ops; +break ; +case SCCG_PLL2 : + init.ops = &clk_sccg_pll2_ops; +break ;
No default?
drivers/clk/imx/clk-sccg-pll.c line 224
Quoted 3 lines
drivers/clk/imx/clk-sccg-pll.c new file +3
-0+ } + + init.flags =0 ;
Should't assign CLK_SET_RATE_PARENT?
Quoted 28 lines
drivers/clk/imx/clk-sccg-pll.c new file +11
-0+ init.parent_names = &parent_name; + init.num_parents =1 ; + + pll->hw.init = &init; + + clk =clk_register (NULL , &pll->hw); +if (IS_ERR (clk)) +kfree (pll); + +return clk; +}drivers/clk/imx/clk.h +5
-0@@ -21,6 +21,11 @@ enum imx_pllv1_type { IMX_PLLV1_IMX35, }; +enum imx_sccg_pll_type { +SCCG_PLL1 , +SCCG_PLL2 , +}; +struct clk *imx_clk_pllv1 (enum imx_pllv1_type type,const char *name,const char *parent,void __iomem *base);
drivers/clk/imx/clk.h struct clk *imx_clk_pllv2(const char *name, const char *parent, · line 44
Quoted 10 lines
drivers/clk/imx/clk.h +4
-0@@ -30,6 +35,10 @@ struct clk *imx_clk_pllv2(const char *name, const char *parent,struct clk *imx_clk_frac_pll (const char *name,const char *parent_name,void __iomem *base); +struct clk *imx_clk_sccg_pll (const char *name,const char *parent_name, +void __iomem *base, +enum imx_sccg_pll_type pll_type); +enum imx_pllv3_type {IMX_PLLV3_GENERIC ,IMX_PLLV3_SYS ,
Last, overally, i did not see the configuration of SSE bit as it changes the formula.
SSE=0: PLLOUT = REF/DIVR1 * 2 * DIVF1/DIVR2 * DIVF2/DIVQ SSE=1: PLLOUT = REF/DIVR1 * 8 * DIVF1/DIVR2 * DIVF2/DIVQ
Are we replying on the default register value?
Regards
Dong Aisheng
Quoted 7 lines
Signature · 6 lines
2.15.1 -- To unsubscribe from this list: send the line "unsubscribe linux-clk" in the body of a message to majordomo at vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH v2 4/4 clk: imx: add clock driver for i.MX8MQ CCM
In reply to Lucas StachAdd driver for the Clock Control Module found on i.MX8MQ.
This is largely based on the downstream driver from Anson Huang and Bai Ping at NXP, with only some small adaptions to mainline from me.
---
v2: switchvendor prefixes to fsl
--- drivers/clk/imx/Makefile | 1 + drivers/clk/imx/clk-imx8mq.c | 861 +++++++++++++++++++++++++++++++++++++++++++ drivers/clk/imx/clk.h | 43 +++ 3 files changed, 905 insertions(+) create mode 100644 drivers/clk/imx/clk-imx8mq.c
drivers/clk/imx/Makefile +1 -0
@@ -28,3 +28,4 @@ obj-$(CONFIG_SOC_IMX6SX) += clk-imx6sx.o obj-$(CONFIG_SOC_IMX6UL) += clk-imx6ul.o obj-$(CONFIG_SOC_IMX7D) += clk-imx7d.o obj-$(CONFIG_SOC_VF610) += clk-vf610.o +obj-$(CONFIG_SOC_IMX8MQ) += clk-imx8mq.o
drivers/clk/imx/clk-imx8mq.c new file +861 -0
861 lines not on this page · raw message
drivers/clk/imx/clk.h +43 -0
73 lines not on this page · raw message
Signature · 1 line
2.15.1
PATCH v2 4/4 clk: imx: add clock driver for i.MX8MQ CCM
Quoted 20 lines · Lucas Stach
Add driver for the Clock Control Module found on i.MX8MQ.
This is largely based on the downstream driver from Anson Huang and Bai Ping at NXP, with only some small adaptions to mainline from me.
Signed-off-by Lucas Stach <[email protected]>---
v2: switchvendor prefixes to fsl--- drivers/clk/imx/Makefile | 1 + drivers/clk/imx/clk-imx8mq.c | 861 +++++++++++++++++++++++++++++++++++++++++++ drivers/clk/imx/clk.h | 43 +++ 3 files changed, 905 insertions(+) create mode 100644 drivers/clk/imx/clk-imx8mq.cdrivers/clk/imx/Makefile +0
-0
drivers/clk/imx/Makefile obj-$(CONFIG_SOC_IMX6SX) += clk-imx6sx.o · line 31
Quoted 4 lines
drivers/clk/imx/Makefile +1
-0@@ -28,3 +28,4 @@ obj-$(CONFIG_SOC_IMX6SX) += clk-imx6sx.o obj-$(CONFIG_SOC_IMX6UL) += clk-imx6ul.o obj-$(CONFIG_SOC_IMX7D) += clk-imx7d.o obj-$(CONFIG_SOC_VF610) += clk-vf610.o +obj-$(CONFIG_SOC_IMX8MQ) += clk-imx8mq.o
Drop one space before +=, so that the indent can be aligned with existing lines.
Quoted 33 lines
drivers/clk/imx/clk-imx8mq.c new file +27
-0@@ -0,0 +1,861 @@ +/* +* Copyright 2017 NXP. +* +* The code contained herein is licensed under the GNU General Public +* License. You may obtain a copy of the GNU General Public License +* Version 2 or later at the following locations: +* +* http://www.opensource.org/licenses/gpl-license.html +* http://www.gnu.org/copyleft/gpl.html +*/ + +#include <dt-bindings/clock/imx8mq-clock.h> +#include <linux/clk.h> +#include <linux/clkdev.h> +#include <linux/err.h> +#include <linux/init.h> +#include <linux/io.h> +#include <linux/of.h> +#include <linux/of_address.h> +#include <linux/of_irq.h> +#include <linux/types.h> + +#include "clk.h" + +static u32 share_count_sai1; +static u32 share_count_sai2; +static u32 share_count_sai3;
drivers/clk/imx/clk-imx8mq.c line 37
Quoted 10 lines
drivers/clk/imx/clk-imx8mq.c new file +10
-0+static u32 share_count_sai4; +static u32 share_count_sai5; +static u32 share_count_sai6; +static u32 share_count_dcss; +static u32 share_count_nand; + +static struct clk *clks[IMX8MQ_CLK_END ]; + +static const char *pll_ref_sels[] = {"osc_25m" ,"osc_27m" ,"dummy" ,"dummy" , }; +static const char *arm_pll_bypass_sels[] = {"arm_pll" ,"arm_pll_ref_sel" , };
Like we we have a space before the end '}', I would suggest we have a space after '{'.
Quoted 31 lines
drivers/clk/imx/clk-imx8mq.c new file +31
-0+static const char *gpu_pll_bypass_sels[] = {"gpu_pll" ,"gpu_pll_ref_sel" , }; +static const char *vpu_pll_bypass_sels[] = {"vpu_pll" ,"vpu_pll_ref_sel" , }; +static const char *audio_pll1_bypass_sels[] = {"audio_pll1" ,"audio_pll1_ref_sel" , }; +static const char *audio_pll2_bypass_sels[] = {"audio_pll2" ,"audio_pll2_ref_sel" , }; +static const char *video_pll1_bypass_sels[] = {"video_pll1" ,"video_pll1_ref_sel" , }; + +static const char *sys1_pll1_out_sels[] = {"sys1_pll1" ,"sys1_pll1_ref_sel" , }; +static const char *sys2_pll1_out_sels[] = {"sys2_pll1" ,"sys1_pll1_ref_sel" , }; +static const char *sys3_pll1_out_sels[] = {"sys3_pll1" ,"sys3_pll1_ref_sel" , }; +static const char *dram_pll1_out_sels[] = {"dram_pll1" ,"dram_pll1_ref_sel" , }; +static const char *video2_pll1_out_sels[] = {"video2_pll1" ,"video2_pll1_ref_sel" , }; + +static const char *sys1_pll2_out_sels[] = {"sys1_pll2_div" ,"sys1_pll1_ref_sel" , }; +static const char *sys2_pll2_out_sels[] = {"sys2_pll2_div" ,"sys2_pll1_ref_sel" , }; +static const char *sys3_pll2_out_sels[] = {"sys3_pll2_div" ,"sys2_pll1_ref_sel" , }; +static const char *dram_pll2_out_sels[] = {"dram_pll2_div" ,"dram_pll1_ref_sel" , }; +static const char *video2_pll2_out_sels[] = {"video2_pll2_div" ,"video2_pll1_ref_sel" , }; + +/* CCM ROOT */ +static const char *imx8mq_a53_sels[] = {"osc_25m" ,"arm_pll_out" ,"sys2_pll_500m" ,"sys2_pll_1000m" , +"sys1_pll_800m" ,"sys1_pll_400m" ,"audio_pll1_out" ,"sys3_pll2_out" , }; + +static const char *imx8mq_vpu_sels[] = {"osc_25m" ,"arm_pll_out" ,"sys2_pll_500m" ,"sys2_pll_1000m" , +"sys1_pll_800m" ,"sys1_pll_400m" ,"audio_pll1_out" ,"vpu_pll_out" , }; + +static const char *imx8mq_gpu_core_sels[] = {"osc_25m" ,"gpu_pll_out" ,"sys1_pll_800m" ,"sys3_pll2_out" , +"sys2_pll_1000m" ,"audio_pll1_out" ,"video_pll1_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_gpu_shader_sels[] = {"osc_25m" ,"gpu_pll_out" ,"sys1_pll_800m" ,"sys3_pll2_out" , +"sys2_pll_1000m" ,"audio_pll1_out" ,"video_pll1_out" ,"audio_pll2_out" , }; +
drivers/clk/imx/clk-imx8mq.c line 78
Quoted 10 lines
drivers/clk/imx/clk-imx8mq.c new file +10
-0+static const char *imx8mq_main_axi_sels[] = {"osc_25m" ,"sys2_pll_333m" ,"sys1_pll_800m" ,"sys2_pll_250m" , +"sys2_pll_1000m" ,"audio_pll1_out" ,"video_pll1_out" ,"sys1_pll_100m" ,}; + +static const char *imx8mq_enet_axi_sels[] = {"osc_25m" ,"sys1_pll_266m" ,"sys1_pll_800m" ,"sys2_pll_250m" , +"sys2_pll_200m" ,"audio_pll1_out" ,"video_pll1_out" ,"sys3_pll2_out" , }; + +static const char *imx8mq_nand_usdhc_sels[] = {"osc_25m" ,"sys1_pll_266m" ,"sys1_pll_800m" ,"sys2_pll_200m" , +"sys1_pll_133m" ,"sys3_pll2_out" ,"sys2_pll_250m" ,"audio_pll1_out" , }; + +static const char *imx8mq_vpu_bus_sels[] = {"osc_25m" ,"sys1_pll_800m" ,"vpu_pll_out" ,"audio_pll2_out" ,"sys3_pll2_out" ,"sys2_pll_1000m" ,"sys2_pll_200m" ,"sys1_pll_100m" , };
Even we do not care the line-over-80-characters warning for this file, such long lines could be wrapped a bit.
Quoted 198 lines
drivers/clk/imx/clk-imx8mq.c new file +198
-0+ +static const char *imx8mq_disp_axi_sels[] = {"osc_25m" ,"sys2_pll_125m" ,"sys1_pll_800m" ,"sys3_pll2_out" ,"sys1_pll_400m" ,"audio_pll2_out" ,"clk_ext1" ,"clk_ext4" , }; + +static const char *imx8mq_disp_apb_sels[] = {"osc_25m" ,"sys2_pll_125m" ,"sys1_pll_800m" ,"sys3_pll2_out" , +"sys1_pll_40m" ,"audio_pll2_out" ,"clk_ext1" ,"clk_ext3" , }; + +static const char *imx8mq_disp_rtrm_sels[] = {"osc_25m" ,"sys1_pll_800m" ,"sys2_pll_200m" ,"sys1_pll_400m" , +"audio_pll1_out" ,"video_pll1_out" ,"clk_ext2" ,"clk_ext3" , }; + +static const char *imx8mq_usb_bus_sels[] = {"osc_25m" ,"sys2_pll_500m" ,"sys1_pll_800m" ,"sys2_pll_100m" , +"sys2_pll_200m" ,"clk_ext2" ,"clk_ext4" ,"audio_pll2_out" , }; + +static const char *imx8mq_gpu_axi_sels[] = {"osc_25m" ,"sys1_pll_800m" ,"gpu_pll_out" ,"sys3_pll2_out" ,"sys2_pll_1000m" , +"audio_pll1_out" ,"video_pll1_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_gpu_ahb_sels[] = {"osc_25m" ,"sys1_pll_800m" ,"gpu_pll_out" ,"sys3_pll2_out" ,"sys2_pll_1000m" , +"audio_pll1_out" ,"video_pll1_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_noc_sels[] = {"osc_25m" ,"sys1_pll_800m" ,"sys3_pll2_out" ,"sys2_pll_1000m" ,"sys2_pll_500m" , +"audio_pll1_out" ,"video_pll1_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_noc_apb_sels[] = {"osc_25m" ,"sys1_pll_400m" ,"sys3_pll2_out" ,"sys2_pll_333m" ,"sys2_pll_200m" , +"sys1_pll_800m" ,"audio_pll1_out" ,"video_pll1_out" , }; + +static const char *imx8mq_ahb_sels[] = {"osc_25m" ,"sys1_pll_133m" ,"sys1_pll_800m" ,"sys1_pll_400m" , +"sys2_pll_125m" ,"sys3_pll2_out" ,"audio_pll1_out" ,"video_pll1_out" , }; + +static const char *imx8mq_audio_ahb_sels[] = {"osc_25m" ,"sys2_pll_500m" ,"sys1_pll_800m" ,"sys2_pll_1000m" , +"sys2_pll_166m" ,"sys3_pll2_out" ,"audio_pll1_out" ,"video_pll1_out" , }; + +static const char *imx8mq_dsi_ahb_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_80m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"clk_ext3" ,"audio_pll2_out" }; + +static const char *imx8mq_dram_alt_sels[] = {"osc_25m" ,"sys1_pll_800m" ,"sys1_pll_100m" ,"sys2_pll_500m" , +"sys2_pll_250m" ,"sys1_pll_400m" ,"audio_pll1_out" ,"sys1_pll_266m" , }; + +static const char *imx8mq_dram_apb_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys1_pll_40m" ,"sys1_pll_160m" , +"sys1_pll_800m" ,"sys3_pll2_out" ,"sys2_pll_250m" ,"audio_pll2_out" , }; + +static const char *imx8mq_vpu_g1_sels[] = {"osc_25m" ,"vpu_pll_out" ,"sys1_pll_800m" ,"sys2_pll_1000m" ,"sys1_pll_100m" ,"sys2_pll_125m" ,"sys3_pll2_out" ,"audio_pll1_out" , }; + +static const char *imx8mq_vpu_g2_sels[] = {"osc_25m" ,"vpu_pll_out" ,"sys1_pll_800m" ,"sys2_pll_1000m" ,"sys1_pll_100m" ,"sys2_pll_125m" ,"sys3_pll2_out" ,"audio_pll1_out" , }; + +static const char *imx8mq_disp_dtrc_sels[] = {"osc_25m" ,"vpu_pll_out" ,"sys1_pll_800m" ,"sys2_pll_1000m" ,"sys1_pll_160m" ,"sys2_pll_100m" ,"sys3_pll2_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_disp_dc8000_sels[] = {"osc_25m" ,"vpu_pll_out" ,"sys1_pll_800m" ,"sys2_pll_1000m" ,"sys1_pll_160m" ,"sys2_pll_100m" ,"sys3_pll2_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_pcie1_ctrl_sels[] = {"osc_25m" ,"sys2_pll_250m" ,"sys2_pll_200m" ,"sys1_pll_266m" , +"sys1_pll_800m" ,"sys2_pll_500m" ,"sys2_pll_250m" ,"sys3_pll2_out" , }; + +static const char *imx8mq_pcie1_phy_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys2_pll_500m" ,"clk_ext1" ,"clk_ext2" , +"clk_ext3" ,"clk_ext4" , }; + +static const char *imx8mq_pcie1_aux_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys2_pll_500m" ,"sys3_pll2_out" , +"sys2_pll_100m" ,"sys1_pll_80m" ,"sys1_pll_160m" ,"sys1_pll_200m" , }; + +static const char *imx8mq_dc_pixel_sels[] = {"osc_25m" ,"video_pll1_out" ,"audio_pll2_out" ,"audio_pll1_out" ,"sys1_pll_800m" ,"sys2_pll_1000m" ,"sys3_pll2_out" ,"clk_ext4" , }; + +static const char *imx8mq_lcdif_pixel_sels[] = {"osc_25m" ,"video_pll1_out" ,"audio_pll2_out" ,"audio_pll1_out" ,"sys1_pll_800m" ,"sys2_pll_1000m" ,"sys3_pll2_out" ,"clk_ext4" , }; + +static const char *imx8mq_sai1_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext1" ,"clk_ext2" , }; + +static const char *imx8mq_sai2_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext2" ,"clk_ext3" , }; + +static const char *imx8mq_sai3_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext3" ,"clk_ext4" , }; + +static const char *imx8mq_sai4_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext1" ,"clk_ext2" , }; + +static const char *imx8mq_sai5_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext2" ,"clk_ext3" , }; + +static const char *imx8mq_sai6_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext3" ,"clk_ext4" , }; + +static const char *imx8mq_spdif1_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext2" ,"clk_ext3" , }; + +static const char *imx8mq_spdif2_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext3" ,"clk_ext4" , }; + +static const char *imx8mq_enet_ref_sels[] = {"osc_25m" ,"sys2_pll_125m" ,"sys2_pll_500m" ,"sys2_pll_100m" , +"sys1_pll_160m" ,"audio_pll1_out" ,"video_pll1_out" ,"clk_ext4" , }; + +static const char *imx8mq_enet_timer_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"audio_pll1_out" ,"clk_ext1" ,"clk_ext2" , +"clk_ext3" ,"clk_ext4" ,"video_pll1_out" , }; + +static const char *imx8mq_enet_phy_sels[] = {"osc_25m" ,"sys2_pll_50m" ,"sys2_pll_125m" ,"sys2_pll_500m" , +"audio_pll1_out" ,"video_pll1_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_nand_sels[] = {"osc_25m" ,"sys2_pll_500m" ,"audio_pll1_out" ,"sys1_pll_400m" , +"audio_pll2_out" ,"sys3_pll2_out" ,"sys2_pll_250m" ,"video_pll1_out" , }; + +static const char *imx8mq_qspi_sels[] = {"osc_25m" ,"sys1_pll_400m" ,"sys1_pll_800m" ,"sys2_pll_500m" , +"audio_pll2_out" ,"sys1_pll_266m" ,"sys3_pll2_out" ,"sys1_pll_100m" , }; + +static const char *imx8mq_usdhc1_sels[] = {"osc_25m" ,"sys1_pll_400m" ,"sys1_pll_800m" ,"sys2_pll_500m" , +"audio_pll2_out" ,"sys1_pll_266m" ,"sys3_pll2_out" ,"sys1_pll_100m" , }; + +static const char *imx8mq_usdhc2_sels[] = {"osc_25m" ,"sys1_pll_400m" ,"sys1_pll_800m" ,"sys2_pll_500m" , +"audio_pll2_out" ,"sys1_pll_266m" ,"sys3_pll2_out" ,"sys1_pll_100m" , }; + +static const char *imx8mq_i2c1_sels[] = {"osc_25m" ,"sys1_pll_160m" ,"sys2_pll_50m" ,"sys3_pll2_out" ,"audio_pll1_out" , +"video_pll1_out" ,"audio_pll2_out" ,"sys1_pll_133m" , }; + +static const char *imx8mq_i2c2_sels[] = {"osc_25m" ,"sys1_pll_160m" ,"sys2_pll_50m" ,"sys3_pll2_out" ,"audio_pll1_out" , +"video_pll1_out" ,"audio_pll2_out" ,"sys1_pll_133m" , }; + +static const char *imx8mq_i2c3_sels[] = {"osc_25m" ,"sys1_pll_160m" ,"sys2_pll_50m" ,"sys3_pll2_out" ,"audio_pll1_out" , +"video_pll1_out" ,"audio_pll2_out" ,"sys1_pll_133m" , }; + +static const char *imx8mq_i2c4_sels[] = {"osc_25m" ,"sys1_pll_160m" ,"sys2_pll_50m" ,"sys3_pll2_out" ,"audio_pll1_out" , +"video_pll1_out" ,"audio_pll2_out" ,"sys1_pll_133m" , }; + +static const char *imx8mq_uart1_sels[] = {"osc_25m" ,"sys1_pll_80m" ,"sys2_pll_200m" ,"sys2_pll_100m" , +"sys3_pll2_out" ,"clk_ext2" ,"clk_ext4" ,"audio_pll2_out" , }; + +static const char *imx8mq_uart2_sels[] = {"osc_25m" ,"sys1_pll_80m" ,"sys2_pll_200m" ,"sys2_pll_100m" , +"sys3_pll2_out" ,"clk_ext2" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_uart3_sels[] = {"osc_25m" ,"sys1_pll_80m" ,"sys2_pll_200m" ,"sys2_pll_100m" , +"sys3_pll2_out" ,"clk_ext2" ,"clk_ext4" ,"audio_pll2_out" , }; + +static const char *imx8mq_uart4_sels[] = {"osc_25m" ,"sys1_pll_80m" ,"sys2_pll_200m" ,"sys2_pll_100m" , +"sys3_pll2_out" ,"clk_ext2" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_usb_core_sels[] = {"osc_25m" ,"sys1_pll_100m" ,"sys1_pll_40m" ,"sys2_pll_100m" , +"sys2_pll_200m" ,"clk_ext2" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_usb_phy_sels[] = {"osc_25m" ,"sys1_pll_100m" ,"sys1_pll_40m" ,"sys2_pll_100m" , +"sys2_pll_200m" ,"clk_ext2" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_ecspi1_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys1_pll_40m" ,"sys1_pll_160m" , +"sys1_pll_800m" ,"sys3_pll2_out" ,"sys2_pll_250m" ,"audio_pll2_out" , }; + +static const char *imx8mq_ecspi2_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys1_pll_40m" ,"sys1_pll_160m" , +"sys1_pll_800m" ,"sys3_pll2_out" ,"sys2_pll_250m" ,"audio_pll2_out" , }; + +static const char *imx8mq_pwm1_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_160m" ,"sys1_pll_40m" , +"sys3_pll2_out" ,"clk_ext1" ,"sys1_pll_80m" ,"video_pll1_out" , }; + +static const char *imx8mq_pwm2_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_160m" ,"sys1_pll_40m" , +"sys3_pll2_out" ,"clk_ext1" ,"sys1_pll_80m" ,"video_pll1_out" , }; + +static const char *imx8mq_pwm3_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_160m" ,"sys1_pll_40m" , +"sys3_pll2_out" ,"clk_ext2" ,"sys1_pll_80m" ,"video_pll1_out" , }; + +static const char *imx8mq_pwm4_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_160m" ,"sys1_pll_40m" , +"sys3_pll2_out" ,"clk_ext2" ,"sys1_pll_80m" ,"video_pll1_out" , }; + +static const char *imx8mq_gpt1_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_400m" ,"sys1_pll_40m" , +"sys1_pll_80m" ,"audio_pll1_out" ,"clk_ext1" , }; + +static const char *imx8mq_wdog_sels[] = {"osc_25m" ,"sys1_pll_133m" ,"sys1_pll_160m" ,"vpu_pll_out" , +"sys2_pll_125m" ,"sys3_pll2_out" ,"sys1_pll_80m" ,"sys2_pll_166m" , }; + +static const char *imx8mq_wrclk_sels[] = {"osc_25m" ,"sys1_pll_40m" ,"vpu_pll_out" ,"sys3_pll2_out" ,"sys2_pll_200m" , +"sys1_pll_266m" ,"sys2_pll_500m" ,"sys1_pll_100m" , }; + +static const char *imx8mq_dsi_core_sels[] = {"osc_25m" ,"sys1_pll_266m" ,"sys2_pll_250m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_dsi_phy_sels[] = {"osc_25m" ,"sys2_pll_125m" ,"sys2_pll_100m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"clk_ext2" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_dsi_dbi_sels[] = {"osc_25m" ,"sys1_pll_266m" ,"sys2_pll_100m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_dsi_esc_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_80m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_csi1_core_sels[] = {"osc_25m" ,"sys1_pll_266m" ,"sys2_pll_250m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_csi1_phy_sels[] = {"osc_25m" ,"sys2_pll_125m" ,"sys2_pll_100m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"clk_ext2" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_csi1_esc_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_80m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_csi2_core_sels[] = {"osc_25m" ,"sys1_pll_266m" ,"sys2_pll_250m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_csi2_phy_sels[] = {"osc_25m" ,"sys2_pll_125m" ,"sys2_pll_100m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"clk_ext2" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_csi2_esc_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_80m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_pcie2_ctrl_sels[] = {"osc_25m" ,"sys2_pll_250m" ,"sys2_pll_200m" ,"sys1_pll_266m" , +"sys1_pll_800m" ,"sys2_pll_500m" ,"sys2_pll_333m" ,"sys3_pll2_out" , }; + +static const char *imx8mq_pcie2_phy_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys2_pll_500m" ,"clk_ext1" , +"clk_ext2" ,"clk_ext3" ,"clk_ext4" ,"sys1_pll_400m" , }; + +static const char *imx8mq_pcie2_aux_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys2_pll_50m" ,"sys3_pll2_out" , +"sys2_pll_100m" ,"sys1_pll_80m" ,"sys1_pll_160m" ,"sys1_pll_200m" , }; + +static const char *imx8mq_ecspi3_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys1_pll_40m" ,"sys1_pll_160m" , +"sys1_pll_800m" ,"sys3_pll2_out" ,"sys2_pll_250m" ,"audio_pll2_out" , }; +static const char *imx8mq_dram_core_sels[] = {"dram_pll_out" ,"dram_alt_root" , }; + +static const char *imx8mq_clko2_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys1_pll_400m" ,"sys2_pll_166m" ,"audio_pll1_out" ,
drivers/clk/imx/clk-imx8mq.c line 286
Quoted 10 lines
drivers/clk/imx/clk-imx8mq.c new file +10
-0+ "video_pll1_out", "ckil", }; + +static int const clks_init_on[]__initconst = { +IMX8MQ_CLK_DRAM_CORE ,IMX8MQ_CLK_AHB_CG , +IMX8MQ_CLK_NOC_CG ,IMX8MQ_CLK_NOC_APB_CG , +IMX8MQ_CLK_USB_BUS_CG ,IMX8MQ_CLK_NAND_USDHC_BUS_CG , +IMX8MQ_CLK_MAIN_AXI_CG ,IMX8MQ_CLK_A53_CG , +IMX8MQ_CLK_AUDIO_AHB_DIV ,IMX8MQ_CLK_TMU_ROOT , +IMX8MQ_CLK_DRAM_APB_DIV , +};
This doesn't seem to be used.
Quoted 131 lines
drivers/clk/imx/clk-imx8mq.c new file +131
-0+ +static struct clk_onecell_data clk_data; + +static void __init imx8mq_clocks_init (struct device_node *ccm_node) +{ +struct device_node *np; +void __iomem *base; +int i; + + clks[IMX8MQ_CLK_DUMMY ] =imx_clk_fixed ("dummy" ,0 ); + clks[IMX8MQ_CLK_32K ] =of_clk_get_by_name (ccm_node,"ckil" ); + clks[IMX8MQ_CLK_25M ] =of_clk_get_by_name (ccm_node,"osc_25m" ); + clks[IMX8MQ_CLK_27M ] =of_clk_get_by_name (ccm_node,"osc_27m" ); + clks[IMX8MQ_CLK_EXT1 ] =of_clk_get_by_name (ccm_node,"clk_ext1" ); + clks[IMX8MQ_CLK_EXT2 ] =of_clk_get_by_name (ccm_node,"clk_ext2" ); + clks[IMX8MQ_CLK_EXT3 ] =of_clk_get_by_name (ccm_node,"clk_ext3" ); + clks[IMX8MQ_CLK_EXT4 ] =of_clk_get_by_name (ccm_node,"clk_ext4" ); + + np =of_find_compatible_node (NULL ,NULL ,"fsl,imx8mq-anatop" ); + base =of_iomap (np,0 ); +WARN_ON (!base); + + clks[IMX8MQ_ARM_PLL_REF_SEL ] =imx_clk_mux ("arm_pll_ref_sel" , base +0x28 ,16 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_GPU_PLL_REF_SEL ] =imx_clk_mux ("gpu_pll_ref_sel" , base +0x18 ,16 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_VPU_PLL_REF_SEL ] =imx_clk_mux ("vpu_pll_ref_sel" , base +0x20 ,16 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_AUDIO_PLL1_REF_SEL ] =imx_clk_mux ("audio_pll1_ref_sel" , base +0x0 ,16 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_AUDIO_PLL2_REF_SEL ] =imx_clk_mux ("audio_pll2_ref_sel" , base +0x8 ,16 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_VIDEO_PLL1_REF_SEL ] =imx_clk_mux ("video_pll1_ref_sel" , base +0x10 ,16 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_SYS1_PLL1_REF_SEL ] =imx_clk_mux ("sys1_pll1_ref_sel" , base +0x30 ,0 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_SYS2_PLL1_REF_SEL ] =imx_clk_mux ("sys2_pll1_ref_sel" , base +0x3c ,0 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_SYS3_PLL1_REF_SEL ] =imx_clk_mux ("sys3_pll1_ref_sel" , base +0x48 ,0 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_DRAM_PLL1_REF_SEL ] =imx_clk_mux ("dram_pll1_ref_sel" , base +0x60 ,0 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_VIDEO2_PLL1_REF_SEL ] =imx_clk_mux ("video2_pll1_ref_sel" , base +0x54 ,0 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + + clks[IMX8MQ_ARM_PLL_REF_DIV ] =imx_clk_divider ("arm_pll_ref_div" ,"arm_pll_ref_sel" , base +0x28 ,5 ,6 ); + clks[IMX8MQ_GPU_PLL_REF_DIV ] =imx_clk_divider ("gpu_pll_ref_div" ,"gpu_pll_ref_sel" , base +0x18 ,5 ,6 ); + clks[IMX8MQ_VPU_PLL_REF_DIV ] =imx_clk_divider ("vpu_pll_ref_div" ,"vpu_pll_ref_sel" , base +0x20 ,5 ,6 ); + clks[IMX8MQ_AUDIO_PLL1_REF_DIV ] =imx_clk_divider ("audio_pll1_ref_div" ,"audio_pll1_ref_sel" , base +0x0 ,5 ,6 ); + clks[IMX8MQ_AUDIO_PLL2_REF_DIV ] =imx_clk_divider ("audio_pll2_ref_div" ,"audio_pll2_ref_sel" , base +0x8 ,5 ,6 ); + clks[IMX8MQ_VIDEO_PLL1_REF_DIV ] =imx_clk_divider ("video_pll1_ref_div" ,"video_pll1_ref_sel" , base +0x10 ,5 ,6 ); + clks[IMX8MQ_SYS1_PLL1_REF_DIV ] =imx_clk_divider ("sys1_pll1_ref_div" ,"sys1_pll1_ref_sel" , base +0x38 ,25 ,3 ); + clks[IMX8MQ_SYS2_PLL1_REF_DIV ] =imx_clk_divider ("sys2_pll1_ref_div" ,"sys2_pll1_ref_sel" , base +0x44 ,25 ,3 ); + clks[IMX8MQ_SYS3_PLL1_REF_DIV ] =imx_clk_divider ("sys3_pll1_ref_div" ,"sys3_pll1_ref_sel" , base +0x50 ,25 ,3 ); + clks[IMX8MQ_DRAM_PLL1_REF_DIV ] =imx_clk_divider ("dram_pll1_ref_div" ,"dram_pll1_ref_sel" , base +0x68 ,25 ,3 ); + clks[IMX8MQ_VIDEO2_PLL1_REF_DIV ] =imx_clk_divider ("video2_pll1_ref_div" ,"video2_pll1_ref_sel" , base +0x5c ,25 ,3 ); + + clks[IMX8MQ_ARM_PLL ] =imx_clk_frac_pll ("arm_pll" ,"arm_pll_ref_div" , base +0x28 ); + clks[IMX8MQ_GPU_PLL ] =imx_clk_frac_pll ("gpu_pll" ,"gpu_pll_ref_div" , base +0x18 ); + clks[IMX8MQ_VPU_PLL ] =imx_clk_frac_pll ("vpu_pll" ,"vpu_pll_ref_div" , base +0x20 ); + clks[IMX8MQ_AUDIO_PLL1 ] =imx_clk_frac_pll ("audio_pll1" ,"audio_pll1_ref_div" , base +0x0 ); + clks[IMX8MQ_AUDIO_PLL2 ] =imx_clk_frac_pll ("audio_pll2" ,"audio_pll2_ref_div" , base +0x8 ); + clks[IMX8MQ_VIDEO_PLL1 ] =imx_clk_frac_pll ("video_pll1" ,"video_pll1_ref_div" , base +0x10 ); + clks[IMX8MQ_SYS1_PLL1 ] =imx_clk_sccg_pll ("sys1_pll1" ,"sys1_pll1_ref_div" , base +0x30 ,SCCG_PLL1 ); + clks[IMX8MQ_SYS2_PLL1 ] =imx_clk_sccg_pll ("sys2_pll1" ,"sys2_pll1_ref_div" , base +0x3c ,SCCG_PLL1 ); + clks[IMX8MQ_SYS3_PLL1 ] =imx_clk_sccg_pll ("sys3_pll1" ,"sys3_pll1_ref_div" , base +0x48 ,SCCG_PLL1 ); + clks[IMX8MQ_DRAM_PLL1 ] =imx_clk_sccg_pll ("dram_pll1" ,"dram_pll1_ref_div" , base +0x60 ,SCCG_PLL1 ); + clks[IMX8MQ_VIDEO2_PLL1 ] =imx_clk_sccg_pll ("video2_pll1" ,"video2_pll1_ref_div" , base +0x5c ,3 ); + + clks[IMX8MQ_SYS1_PLL2 ] =imx_clk_sccg_pll ("sys1_pll2" ,"sys1_pll1_out_div" , base +0x30 ,SCCG_PLL2 ); + clks[IMX8MQ_SYS2_PLL2 ] =imx_clk_sccg_pll ("sys2_pll2" ,"sys2_pll1_out_div" , base +0x3c ,SCCG_PLL2 ); + clks[IMX8MQ_SYS3_PLL2 ] =imx_clk_sccg_pll ("sys3_pll2" ,"sys3_pll1_out_div" , base +0x48 ,SCCG_PLL2 ); + clks[IMX8MQ_DRAM_PLL2 ] =imx_clk_sccg_pll ("dram_pll2" ,"dram_pll1_out_div" , base +0x60 ,SCCG_PLL2 ); + clks[IMX8MQ_VIDEO2_PLL2 ] =imx_clk_sccg_pll ("video2_pll2" ,"video2_pll1_out_div" , base +0x54 ,SCCG_PLL2 ); + +/* PLL divs */ + clks[IMX8MQ_SYS1_PLL1_OUT_DIV ] =imx_clk_divider ("sys1_pll1_out_div" ,"sys1_pll1_out" , base +0x38 ,19 ,6 ); + clks[IMX8MQ_SYS2_PLL1_OUT_DIV ] =imx_clk_divider ("sys2_pll1_out_div" ,"sys2_pll1_out" , base +0x44 ,19 ,6 ); + clks[IMX8MQ_SYS3_PLL1_OUT_DIV ] =imx_clk_divider ("sys3_pll1_out_div" ,"sys3_pll1_out" , base +0x50 ,19 ,6 ); + clks[IMX8MQ_DRAM_PLL1_OUT_DIV ] =imx_clk_divider ("dram_pll1_out_div" ,"dram_pll1_out" , base +0x68 ,19 ,6 ); + clks[IMX8MQ_VIDEO2_PLL1_OUT_DIV ] =imx_clk_divider ("video2_pll1_out_div" ,"video2_pll1_out" , base +0x5c ,19 ,6 ); + clks[IMX8MQ_SYS1_PLL2_DIV ] =imx_clk_divider ("sys1_pll2_div" ,"sys1_pll2" , base +0x38 ,1 ,6 ); + clks[IMX8MQ_SYS2_PLL2_DIV ] =imx_clk_divider ("sys2_pll2_div" ,"sys2_pll2" , base +0x44 ,1 ,6 ); + clks[IMX8MQ_SYS3_PLL2_DIV ] =imx_clk_divider ("sys3_pll2_div" ,"sys3_pll2" , base +0x50 ,1 ,6 ); + clks[IMX8MQ_DRAM_PLL2_DIV ] =imx_clk_divider ("dram_pll2_div" ,"dram_pll2" , base +0x68 ,1 ,6 ); + clks[IMX8MQ_VIDEO2_PLL2_DIV ] =imx_clk_divider ("video2_pll2_div" ,"video2_pll2" , base +0x5c ,1 ,6 ); + +/* PLL bypass out */ + clks[IMX8MQ_ARM_PLL_BYPASS ] =imx_clk_mux ("arm_pll_bypass" , base +0x28 ,14 ,1 , arm_pll_bypass_sels,ARRAY_SIZE (arm_pll_bypass_sels)); + clks[IMX8MQ_GPU_PLL_BYPASS ] =imx_clk_mux ("gpu_pll_bypass" , base +0x18 ,14 ,1 , gpu_pll_bypass_sels,ARRAY_SIZE (gpu_pll_bypass_sels)); + clks[IMX8MQ_VPU_PLL_BYPASS ] =imx_clk_mux ("vpu_pll_bypass" , base +0x20 ,14 ,1 , vpu_pll_bypass_sels,ARRAY_SIZE (vpu_pll_bypass_sels)); + clks[IMX8MQ_AUDIO_PLL1_BYPASS ] =imx_clk_mux ("audio_pll1_bypass" , base +0x0 ,14 ,1 , audio_pll1_bypass_sels,ARRAY_SIZE (audio_pll1_bypass_sels)); + clks[IMX8MQ_AUDIO_PLL2_BYPASS ] =imx_clk_mux ("audio_pll2_bypass" , base +0x8 ,14 ,1 , audio_pll2_bypass_sels,ARRAY_SIZE (audio_pll2_bypass_sels)); + clks[IMX8MQ_VIDEO_PLL1_BYPASS ] =imx_clk_mux ("video_pll1_bypass" , base +0x10 ,14 ,1 , video_pll1_bypass_sels,ARRAY_SIZE (video_pll1_bypass_sels)); + + clks[IMX8MQ_SYS1_PLL1_OUT ] =imx_clk_mux ("sys1_pll1_out" , base +0x30 ,5 ,1 , sys1_pll1_out_sels,ARRAY_SIZE (sys1_pll1_out_sels)); + clks[IMX8MQ_SYS2_PLL1_OUT ] =imx_clk_mux ("sys2_pll1_out" , base +0x3c ,5 ,1 , sys2_pll1_out_sels,ARRAY_SIZE (sys2_pll1_out_sels)); + clks[IMX8MQ_SYS3_PLL1_OUT ] =imx_clk_mux ("sys3_pll1_out" , base +0x48 ,5 ,1 , sys3_pll1_out_sels,ARRAY_SIZE (sys3_pll1_out_sels)); + clks[IMX8MQ_DRAM_PLL1_OUT ] =imx_clk_mux ("dram_pll1_out" , base +0x60 ,5 ,1 , dram_pll1_out_sels,ARRAY_SIZE (dram_pll1_out_sels)); + clks[IMX8MQ_VIDEO2_PLL1_OUT ] =imx_clk_mux ("video2_pll1_out" , base +0x54 ,5 ,1 , video2_pll1_out_sels,ARRAY_SIZE (video2_pll1_out_sels)); + clks[IMX8MQ_SYS1_PLL2_OUT ] =imx_clk_mux ("sys1_pll2_out" , base +0x30 ,4 ,1 , sys1_pll2_out_sels,ARRAY_SIZE (sys1_pll2_out_sels)); + clks[IMX8MQ_SYS2_PLL2_OUT ] =imx_clk_mux ("sys2_pll2_out" , base +0x3c ,4 ,1 , sys2_pll2_out_sels,ARRAY_SIZE (sys2_pll2_out_sels)); + clks[IMX8MQ_SYS3_PLL2_OUT ] =imx_clk_mux ("sys3_pll2_out" , base +0x48 ,4 ,1 , sys3_pll2_out_sels,ARRAY_SIZE (sys3_pll2_out_sels)); + clks[IMX8MQ_DRAM_PLL2_OUT ] =imx_clk_mux ("dram_pll2_out" , base +0x60 ,4 ,1 , dram_pll2_out_sels,ARRAY_SIZE (dram_pll2_out_sels)); + clks[IMX8MQ_VIDEO2_PLL2_OUT ] =imx_clk_mux ("video2_pll2_out" , base +0x54 ,4 ,1 , video2_pll2_out_sels,ARRAY_SIZE (video2_pll2_out_sels)); + +/* unbypass all the plls */ +clk_set_parent (clks[IMX8MQ_GPU_PLL_BYPASS ], clks[IMX8MQ_GPU_PLL ]); +clk_set_parent (clks[IMX8MQ_VPU_PLL_BYPASS ], clks[IMX8MQ_VPU_PLL ]); +clk_set_parent (clks[IMX8MQ_AUDIO_PLL1_BYPASS ], clks[IMX8MQ_AUDIO_PLL1 ]); +clk_set_parent (clks[IMX8MQ_AUDIO_PLL2_BYPASS ], clks[IMX8MQ_AUDIO_PLL2 ]); +clk_set_parent (clks[IMX8MQ_VIDEO_PLL1_BYPASS ], clks[IMX8MQ_VIDEO_PLL1 ]); +clk_set_parent (clks[IMX8MQ_SYS3_PLL1_OUT ], clks[IMX8MQ_SYS3_PLL1 ]); +clk_set_parent (clks[IMX8MQ_SYS3_PLL2_OUT ], clks[IMX8MQ_SYS3_PLL2_DIV ]); + +/* PLL OUT GATE */ + clks[IMX8MQ_ARM_PLL_OUT ] =imx_clk_gate ("arm_pll_out" ,"arm_pll_bypass" , base +0x28 ,21 ); + clks[IMX8MQ_GPU_PLL_OUT ] =imx_clk_gate ("gpu_pll_out" ,"gpu_pll_bypass" , base +0x18 ,21 ); + clks[IMX8MQ_VPU_PLL_OUT ] =imx_clk_gate ("vpu_pll_out" ,"vpu_pll_bypass" , base +0x20 ,21 ); + clks[IMX8MQ_AUDIO_PLL1_OUT ] =imx_clk_gate ("audio_pll1_out" ,"audio_pll1_bypass" , base +0x0 ,21 ); + clks[IMX8MQ_AUDIO_PLL2_OUT ] =imx_clk_gate ("audio_pll2_out" ,"audio_pll2_bypass" , base +0x8 ,21 ); + clks[IMX8MQ_VIDEO_PLL1_OUT ] =imx_clk_gate ("video_pll1_out" ,"video_pll1_bypass" , base +0x10 ,21 ); + clks[IMX8MQ_SYS1_PLL_OUT ] =imx_clk_gate ("sys1_pll_out" ,"sys1_pll2_out" , base +0x30 ,9 ); + clks[IMX8MQ_SYS2_PLL_OUT ] =imx_clk_gate ("sys2_pll_out" ,"sys2_pll2_out" , base +0x3c ,9 ); + clks[IMX8MQ_SYS3_PLL_OUT ] =imx_clk_gate ("sys3_pll_out" ,"sys3_pll2_out" , base +0x48 ,9 ); + clks[IMX8MQ_DRAM_PLL_OUT ] =imx_clk_gate ("dram_pll_out" ,"dram_pll2_out" , base +0x60 ,9 ); + clks[IMX8MQ_VIDEO2_PLL_OUT ] =imx_clk_gate ("video2_pll_out" ,"video2_pll2_out" , base +0x54 ,9 ); + +/* SYS PLL fixed output */ + clks[IMX8MQ_SYS1_PLL_40M ] =imx_clk_fixed_factor ("sys1_pll_40m" ,"sys1_pll_out" ,1 ,20 ); + clks[IMX8MQ_SYS1_PLL_80M ] =imx_clk_fixed_factor ("sys1_pll_80m" ,"sys1_pll_out" ,1 ,10 ); + clks[IMX8MQ_SYS1_PLL_100M ] =imx_clk_fixed_factor ("sys1_pll_100m" ,"sys1_pll_out" ,1 ,8 ); + clks[IMX8MQ_SYS1_PLL_133M ] =imx_clk_fixed_factor ("sys1_pll_133m" ,"sys1_pll_out" ,1 ,6 ); + clks[IMX8MQ_SYS1_PLL_160M ] =imx_clk_fixed_factor ("sys1_pll_160m" ,"sys1_pll_out" ,1 ,5 ); + clks[IMX8MQ_SYS1_PLL_200M ] =imx_clk_fixed_factor ("sys1_pll_200m" ,"sys1_pll_out" ,1 ,4 ); + clks[IMX8MQ_SYS1_PLL_266M ] =imx_clk_fixed_factor ("sys1_pll_266m" ,"sys1_pll_out" ,1 ,3 ); + clks[IMX8MQ_SYS1_PLL_400M ] =imx_clk_fixed_factor ("sys1_pll_400m" ,"sys1_pll_out" ,1 ,2 ); + clks[IMX8MQ_SYS1_PLL_800M ] =imx_clk_fixed_factor ("sys1_pll_800m" ,"sys1_pll_out" ,1 ,1 ); + + clks[IMX8MQ_SYS2_PLL_50M ] =imx_clk_fixed_factor ("sys2_pll_50m" ,"sys2_pll_out" ,1 ,20 ); + clks[IMX8MQ_SYS2_PLL_100M ] =imx_clk_fixed_factor ("sys2_pll_100m" ,"sys2_pll_out" ,1 ,10 ); + clks[IMX8MQ_SYS2_PLL_125M ] =imx_clk_fixed_factor ("sys2_pll_125m" ,"sys2_pll_out" ,1 ,8 );
drivers/clk/imx/clk-imx8mq.c line 427
Quoted 10 lines
drivers/clk/imx/clk-imx8mq.c new file +10
-0+ clks[IMX8MQ_SYS2_PLL_166M ] =imx_clk_fixed_factor ("sys2_pll_166m" ,"sys2_pll_out" ,1 ,6 ); + clks[IMX8MQ_SYS2_PLL_200M ] =imx_clk_fixed_factor ("sys2_pll_200m" ,"sys2_pll_out" ,1 ,5 ); + clks[IMX8MQ_SYS2_PLL_250M ] =imx_clk_fixed_factor ("sys2_pll_250m" ,"sys2_pll_out" ,1 ,4 ); + clks[IMX8MQ_SYS2_PLL_333M ] =imx_clk_fixed_factor ("sys2_pll_333m" ,"sys2_pll_out" ,1 ,3 ); + clks[IMX8MQ_SYS2_PLL_500M ] =imx_clk_fixed_factor ("sys2_pll_500m" ,"sys2_pll_out" ,1 ,2 ); + clks[IMX8MQ_SYS2_PLL_1000M ] =imx_clk_fixed_factor ("sys2_pll_1000m" ,"sys2_pll_out" ,1 ,1 ); + + np = ccm_node; + base =of_iomap (np,0 ); +WARN_ON (!base);
Have a newline here.
Quoted 324 lines
drivers/clk/imx/clk-imx8mq.c new file +324
-0+/* CORE */ + clks[IMX8MQ_CLK_A53_SRC ] =imx_clk_mux2 ("arm_a53_src" , base +0x8000 ,24 ,3 , imx8mq_a53_sels,ARRAY_SIZE (imx8mq_a53_sels)); + clks[IMX8MQ_CLK_VPU_SRC ] =imx_clk_mux2 ("vpu_src" , base +0x8100 ,24 ,3 , imx8mq_vpu_sels,ARRAY_SIZE (imx8mq_vpu_sels)); + clks[IMX8MQ_CLK_GPU_CORE_SRC ] =imx_clk_mux2 ("gpu_core_src" , base +0x8180 ,24 ,3 , imx8mq_gpu_core_sels,ARRAY_SIZE (imx8mq_gpu_core_sels)); + clks[IMX8MQ_CLK_GPU_SHADER_SRC ] =imx_clk_mux2 ("gpu_shader_src" , base +0x8200 ,24 ,3 , imx8mq_gpu_shader_sels,ARRAY_SIZE (imx8mq_gpu_shader_sels)); + clks[IMX8MQ_CLK_A53_CG ] =imx_clk_gate3_flags ("arm_a53_cg" ,"arm_a53_src" , base +0x8000 ,28 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_VPU_CG ] =imx_clk_gate3 ("vpu_cg" ,"vpu_src" , base +0x8100 ,28 ); + clks[IMX8MQ_CLK_GPU_CORE_CG ] =imx_clk_gate3 ("gpu_core_cg" ,"gpu_core_src" , base +0x8180 ,28 ); + clks[IMX8MQ_CLK_GPU_SHADER_CG ] =imx_clk_gate3 ("gpu_shader_cg" ,"gpu_shader_src" , base +0x8200 ,28 ); + + clks[IMX8MQ_CLK_A53_DIV ] =imx_clk_divider2 ("arm_a53_div" ,"arm_a53_cg" , base +0x8000 ,0 ,3 ); + clks[IMX8MQ_CLK_VPU_DIV ] =imx_clk_divider2 ("vpu_div" ,"vpu_cg" , base +0x8100 ,0 ,3 ); + clks[IMX8MQ_CLK_GPU_CORE_DIV ] =imx_clk_divider2 ("gpu_core_div" ,"gpu_core_cg" , base +0x8180 ,0 ,3 ); + clks[IMX8MQ_CLK_GPU_SHADER_DIV ] =imx_clk_divider2 ("gpu_shader_div" ,"gpu_shader_cg" , base +0x8200 ,0 ,3 ); + +/* BUS */ + clks[IMX8MQ_CLK_MAIN_AXI_SRC ] =imx_clk_mux2 ("main_axi_src" , base +0x8800 ,24 ,3 , imx8mq_main_axi_sels,ARRAY_SIZE (imx8mq_main_axi_sels)); + clks[IMX8MQ_CLK_ENET_AXI_SRC ] =imx_clk_mux2 ("enet_axi_src" , base +0x8880 ,24 ,3 , imx8mq_enet_axi_sels,ARRAY_SIZE (imx8mq_enet_axi_sels)); + clks[IMX8MQ_CLK_NAND_USDHC_BUS_SRC ] =imx_clk_mux2 ("nand_usdhc_bus_src" , base +0x8900 ,24 ,3 , imx8mq_nand_usdhc_sels,ARRAY_SIZE (imx8mq_nand_usdhc_sels)); + clks[IMX8MQ_CLK_VPU_BUS_SRC ] =imx_clk_mux2 ("vpu_bus_src" , base +0x8980 ,24 ,3 , imx8mq_vpu_bus_sels,ARRAY_SIZE (imx8mq_vpu_bus_sels)); + clks[IMX8MQ_CLK_DISP_AXI_SRC ] =imx_clk_mux2 ("disp_axi_src" , base +0x8a00 ,24 ,3 , imx8mq_disp_axi_sels,ARRAY_SIZE (imx8mq_disp_axi_sels)); + clks[IMX8MQ_CLK_DISP_APB_SRC ] =imx_clk_mux2 ("disp_apb_src" , base +0x8a80 ,24 ,3 , imx8mq_disp_apb_sels,ARRAY_SIZE (imx8mq_disp_apb_sels)); + clks[IMX8MQ_CLK_DISP_RTRM_SRC ] =imx_clk_mux2 ("disp_rtrm_src" , base +0x8b00 ,24 ,3 , imx8mq_disp_rtrm_sels,ARRAY_SIZE (imx8mq_disp_rtrm_sels)); + clks[IMX8MQ_CLK_USB_BUS_SRC ] =imx_clk_mux2 ("usb_bus_src" , base +0x8b80 ,24 ,3 , imx8mq_usb_bus_sels,ARRAY_SIZE (imx8mq_usb_bus_sels)); + clks[IMX8MQ_CLK_GPU_AXI_SRC ] =imx_clk_mux2 ("gpu_axi_src" , base +0x8c00 ,24 ,3 , imx8mq_gpu_axi_sels,ARRAY_SIZE (imx8mq_gpu_axi_sels)); + clks[IMX8MQ_CLK_GPU_AHB_SRC ] =imx_clk_mux2 ("gpu_ahb_src" , base +0x8c80 ,24 ,3 , imx8mq_gpu_ahb_sels,ARRAY_SIZE (imx8mq_gpu_ahb_sels)); + clks[IMX8MQ_CLK_NOC_SRC ] =imx_clk_mux2 ("noc_src" , base +0x8d00 ,24 ,3 , imx8mq_noc_sels,ARRAY_SIZE (imx8mq_noc_sels)); + clks[IMX8MQ_CLK_NOC_APB_SRC ] =imx_clk_mux2 ("noc_apb_src" , base +0x8d80 ,24 ,3 , imx8mq_noc_apb_sels,ARRAY_SIZE (imx8mq_noc_apb_sels)); + + clks[IMX8MQ_CLK_MAIN_AXI_CG ] =imx_clk_gate3_flags ("main_axi_cg" ,"main_axi_src" , base +0x8800 ,28 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_ENET_AXI_CG ] =imx_clk_gate3 ("enet_axi_cg" ,"enet_axi_src" , base +0x8880 ,28 ); + clks[IMX8MQ_CLK_NAND_USDHC_BUS_CG ] =imx_clk_gate3_flags ("nand_usdhc_bus_cg" ,"nand_usdhc_bus_src" , base +0x8900 ,28 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_VPU_BUS_CG ] =imx_clk_gate3 ("vpu_bus_cg" ,"vpu_bus_src" , base +0x8980 ,28 ); + clks[IMX8MQ_CLK_DISP_AXI_CG ] =imx_clk_gate3 ("disp_axi_cg" ,"disp_axi_src" , base +0x8a00 ,28 ); + clks[IMX8MQ_CLK_DISP_APB_CG ] =imx_clk_gate3 ("disp_apb_cg" ,"disp_apb_src" , base +0x8a80 ,28 ); + clks[IMX8MQ_CLK_DISP_RTRM_CG ] =imx_clk_gate3 ("disp_rtrm_cg" ,"disp_rtrm_src" , base +0x8b00 ,28 ); + clks[IMX8MQ_CLK_USB_BUS_CG ] =imx_clk_gate3_flags ("usb_bus_cg" ,"usb_bus_src" , base +0x8b80 ,28 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_GPU_AXI_CG ] =imx_clk_gate3 ("gpu_axi_cg" ,"gpu_axi_src" , base +0x8c00 ,28 ); + clks[IMX8MQ_CLK_GPU_AHB_CG ] =imx_clk_gate3 ("gpu_ahb_cg" ,"gpu_ahb_src" , base +0x8c80 ,28 ); + clks[IMX8MQ_CLK_NOC_CG ] =imx_clk_gate3_flags ("noc_cg" ,"noc_src" , base +0x8d00 ,28 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_NOC_APB_CG ] =imx_clk_gate3_flags ("noc_apb_cg" ,"noc_apb_src" , base +0x8d80 ,28 ,CLK_IS_CRITICAL ); + + clks[IMX8MQ_CLK_MAIN_AXI_PRE_DIV ] =imx_clk_divider2 ("main_axi_pre_div" ,"main_axi_cg" , base +0x8800 ,16 ,3 ); + clks[IMX8MQ_CLK_ENET_AXI_PRE_DIV ] =imx_clk_divider2 ("enet_axi_pre_div" ,"enet_axi_cg" , base +0x8880 ,16 ,3 ); + clks[IMX8MQ_CLK_NAND_USDHC_BUS_PRE_DIV ] =imx_clk_divider2 ("nand_usdhc_bus_pre_div" ,"nand_usdhc_bus_cg" , base +0x8900 ,16 ,3 ); + clks[IMX8MQ_CLK_VPU_BUS_PRE_DIV ] =imx_clk_divider2 ("vpu_bus_pre_div" ,"vpu_bus_cg" , base +0x8980 ,16 ,3 ); + clks[IMX8MQ_CLK_DISP_AXI_PRE_DIV ] =imx_clk_divider2 ("disp_axi_pre_div" ,"disp_axi_cg" , base +0x8a00 ,16 ,3 ); + clks[IMX8MQ_CLK_DISP_APB_PRE_DIV ] =imx_clk_divider2 ("disp_apb_pre_div" ,"disp_apb_cg" , base +0x8a80 ,16 ,3 ); + clks[IMX8MQ_CLK_DISP_RTRM_PRE_DIV ] =imx_clk_divider2 ("disp_rtrm_pre_div" ,"disp_rtrm_cg" , base +0x8b00 ,16 ,3 ); + clks[IMX8MQ_CLK_USB_BUS_PRE_DIV ] =imx_clk_divider2 ("usb_bus_pre_div" ,"usb_bus_cg" , base +0x8b80 ,16 ,3 ); + clks[IMX8MQ_CLK_GPU_AXI_PRE_DIV ] =imx_clk_divider2 ("gpu_axi_pre_div" ,"gpu_axi_cg" , base +0x8c00 ,16 ,3 ); + clks[IMX8MQ_CLK_GPU_AHB_PRE_DIV ] =imx_clk_divider2 ("gpu_ahb_pre_div" ,"gpu_ahb_cg" , base +0x8c80 ,16 ,3 ); + clks[IMX8MQ_CLK_NOC_PRE_DIV ] =imx_clk_divider2 ("noc_pre_div" ,"noc_cg" , base +0x8d00 ,16 ,3 ); + clks[IMX8MQ_CLK_NOC_APB_PRE_DIV ] =imx_clk_divider2 ("noc_apb_pre_div" ,"noc_apb_cg" , base +0x8d80 ,16 ,3 ); + + clks[IMX8MQ_CLK_MAIN_AXI_DIV ] =imx_clk_divider2 ("main_axi_div" ,"main_axi_pre_div" , base +0x8800 ,0 ,6 ); + clks[IMX8MQ_CLK_ENET_AXI_DIV ] =imx_clk_divider2 ("enet_axi_div" ,"enet_axi_pre_div" , base +0x8880 ,0 ,6 ); + clks[IMX8MQ_CLK_NAND_USDHC_BUS_DIV ] =imx_clk_divider2 ("nand_usdhc_bus_div" ,"nand_usdhc_bus_pre_div" , base +0x8900 ,0 ,6 ); + clks[IMX8MQ_CLK_VPU_BUS_DIV ] =imx_clk_divider_flags ("vpu_bus_div" ,"vpu_bus_pre_div" , base +0x8980 ,0 ,6 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_DISP_AXI_DIV ] =imx_clk_divider2 ("disp_axi_div" ,"disp_axi_pre_div" , base +0x8a00 ,0 ,6 ); + clks[IMX8MQ_CLK_DISP_APB_DIV ] =imx_clk_divider2 ("disp_apb_div" ,"disp_apb_pre_div" , base +0x8a80 ,0 ,6 ); + clks[IMX8MQ_CLK_DISP_RTRM_DIV ] =imx_clk_divider2 ("disp_rtrm_div" ,"disp_rtrm_pre_div" , base +0x8b00 ,0 ,6 ); + clks[IMX8MQ_CLK_USB_BUS_DIV ] =imx_clk_divider2 ("usb_bus_div" ,"usb_bus_pre_div" , base +0x8b80 ,0 ,6 ); + clks[IMX8MQ_CLK_GPU_AXI_DIV ] =imx_clk_divider2 ("gpu_axi_div" ,"gpu_axi_pre_div" , base +0x8c00 ,0 ,6 ); + clks[IMX8MQ_CLK_GPU_AHB_DIV ] =imx_clk_divider2 ("gpu_ahb_div" ,"gpu_ahb_pre_div" , base +0x8c80 ,0 ,6 ); + clks[IMX8MQ_CLK_NOC_DIV ] =imx_clk_divider2 ("noc_div" ,"noc_pre_div" , base +0x8d00 ,0 ,6 ); + clks[IMX8MQ_CLK_NOC_APB_DIV ] =imx_clk_divider2 ("noc_apb_div" ,"noc_apb_pre_div" , base +0x8d80 ,0 ,6 ); + +/* AHB */ + clks[IMX8MQ_CLK_AHB_SRC ] =imx_clk_mux2 ("ahb_src" , base +0x9000 ,24 ,3 , imx8mq_ahb_sels,ARRAY_SIZE (imx8mq_ahb_sels)); + clks[IMX8MQ_CLK_AUDIO_AHB_SRC ] =imx_clk_mux2 ("audio_ahb_src" , base +0x9100 ,24 ,3 , imx8mq_audio_ahb_sels,ARRAY_SIZE (imx8mq_audio_ahb_sels)); + clks[IMX8MQ_CLK_AHB_CG ] =imx_clk_gate3_flags ("ahb_cg" ,"ahb_src" , base +0x9000 ,28 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_AUDIO_AHB_CG ] =imx_clk_gate3 ("audio_ahb_cg" ,"audio_ahb_src" , base +0x9100 ,28 ); + clks[IMX8MQ_CLK_AHB_PRE_DIV ] =imx_clk_divider2 ("ahb_pre_div" ,"ahb_cg" , base +0x9000 ,16 ,3 ); + clks[IMX8MQ_CLK_AUDIO_AHB_PRE_DIV ] =imx_clk_divider2 ("audio_ahb_pre_div" ,"audio_ahb_cg" , base +0x9100 ,16 ,3 ); + clks[IMX8MQ_CLK_AHB_DIV ] =imx_clk_divider_flags ("ahb_div" ,"ahb_pre_div" , base +0x9000 ,0 ,6 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_AUDIO_AHB_DIV ] =imx_clk_divider2_flags ("audio_ahb_div" ,"audio_ahb_pre_div" , base +0x9100 ,0 ,6 ,CLK_IS_CRITICAL ); + +/* IPG */ + clks[IMX8MQ_CLK_IPG_ROOT ] =imx_clk_divider2 ("ipg_root" ,"ahb_div" , base +0x9080 ,0 ,1 ); + clks[IMX8MQ_CLK_IPG_AUDIO_ROOT ] =imx_clk_divider2 ("ipg_audio_root" ,"audio_ahb_div" , base +0x9180 ,0 ,1 ); + +/* IP */ + clks[IMX8MQ_CLK_DRAM_ALT_SRC ] =imx_clk_mux2 ("dram_alt_src" , base +0xa000 ,24 ,3 , imx8mq_dram_alt_sels,ARRAY_SIZE (imx8mq_dram_alt_sels)); + clks[IMX8MQ_CLK_DRAM_CORE ] =imx_clk_mux2_flags ("dram_core_clk" , base +0x9800 ,24 ,1 , imx8mq_dram_core_sels,ARRAY_SIZE (imx8mq_dram_core_sels),CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_DRAM_APB_SRC ] =imx_clk_mux2 ("dram_apb_src" , base +0xa080 ,24 ,3 , imx8mq_dram_apb_sels,ARRAY_SIZE (imx8mq_dram_apb_sels)); + clks[IMX8MQ_CLK_VPU_G1_SRC ] =imx_clk_mux2 ("vpu_g1_src" , base +0xa100 ,24 ,3 , imx8mq_vpu_g1_sels,ARRAY_SIZE (imx8mq_vpu_g1_sels)); + clks[IMX8MQ_CLK_VPU_G2_SRC ] =imx_clk_mux2 ("vpu_g2_src" , base +0xa180 ,24 ,3 , imx8mq_vpu_g2_sels,ARRAY_SIZE (imx8mq_vpu_g2_sels)); + clks[IMX8MQ_CLK_DISP_DTRC_SRC ] =imx_clk_mux2 ("disp_dtrc_src" , base +0xa200 ,24 ,3 , imx8mq_disp_dtrc_sels,ARRAY_SIZE (imx8mq_disp_dtrc_sels)); + clks[IMX8MQ_CLK_DISP_DC8000_SRC ] =imx_clk_mux2 ("disp_dc8000_src" , base +0xa280 ,24 ,3 , imx8mq_disp_dc8000_sels,ARRAY_SIZE (imx8mq_disp_dc8000_sels)); + clks[IMX8MQ_CLK_PCIE1_CTRL_SRC ] =imx_clk_mux2 ("pcie1_ctrl_src" , base +0xa300 ,24 ,3 , imx8mq_pcie1_ctrl_sels,ARRAY_SIZE (imx8mq_pcie1_ctrl_sels)); + clks[IMX8MQ_CLK_PCIE1_PHY_SRC ] =imx_clk_mux2 ("pcie1_phy_src" , base +0xa380 ,24 ,3 , imx8mq_pcie1_phy_sels,ARRAY_SIZE (imx8mq_pcie1_phy_sels)); + clks[IMX8MQ_CLK_PCIE1_AUX_SRC ] =imx_clk_mux2 ("pcie1_aux_src" , base +0xa400 ,24 ,3 , imx8mq_pcie1_aux_sels,ARRAY_SIZE (imx8mq_pcie1_aux_sels)); + clks[IMX8MQ_CLK_DC_PIXEL_SRC ] =imx_clk_mux2 ("dc_pixel_src" , base +0xa480 ,24 ,3 , imx8mq_dc_pixel_sels,ARRAY_SIZE (imx8mq_dc_pixel_sels)); + clks[IMX8MQ_CLK_LCDIF_PIXEL_SRC ] =imx_clk_mux2 ("lcdif_pixel_src" , base +0xa500 ,24 ,3 , imx8mq_lcdif_pixel_sels,ARRAY_SIZE (imx8mq_lcdif_pixel_sels)); + clks[IMX8MQ_CLK_SAI1_SRC ] =imx_clk_mux2 ("sai1_src" , base +0xa580 ,24 ,3 , imx8mq_sai1_sels,ARRAY_SIZE (imx8mq_sai1_sels)); + clks[IMX8MQ_CLK_SAI2_SRC ] =imx_clk_mux2 ("sai2_src" , base +0xa600 ,24 ,3 , imx8mq_sai2_sels,ARRAY_SIZE (imx8mq_sai2_sels)); + clks[IMX8MQ_CLK_SAI3_SRC ] =imx_clk_mux2 ("sai3_src" , base +0xa680 ,24 ,3 , imx8mq_sai3_sels,ARRAY_SIZE (imx8mq_sai3_sels)); + clks[IMX8MQ_CLK_SAI4_SRC ] =imx_clk_mux2 ("sai4_src" , base +0xa700 ,24 ,3 , imx8mq_sai4_sels,ARRAY_SIZE (imx8mq_sai4_sels)); + clks[IMX8MQ_CLK_SAI5_SRC ] =imx_clk_mux2 ("sai5_src" , base +0xa780 ,24 ,3 , imx8mq_sai5_sels,ARRAY_SIZE (imx8mq_sai5_sels)); + clks[IMX8MQ_CLK_SAI6_SRC ] =imx_clk_mux2 ("sai6_src" , base +0xa800 ,24 ,3 , imx8mq_sai6_sels,ARRAY_SIZE (imx8mq_sai6_sels)); + clks[IMX8MQ_CLK_SPDIF1_SRC ] =imx_clk_mux2 ("spdif1_src" , base +0xa880 ,24 ,3 , imx8mq_spdif1_sels,ARRAY_SIZE (imx8mq_spdif1_sels)); + clks[IMX8MQ_CLK_SPDIF2_SRC ] =imx_clk_mux2 ("spdif2_src" , base +0xa900 ,24 ,3 , imx8mq_spdif2_sels,ARRAY_SIZE (imx8mq_spdif2_sels)); + clks[IMX8MQ_CLK_ENET_REF_SRC ] =imx_clk_mux2 ("enet_ref_src" , base +0xa980 ,24 ,3 , imx8mq_enet_ref_sels,ARRAY_SIZE (imx8mq_enet_ref_sels)); + clks[IMX8MQ_CLK_ENET_TIMER_SRC ] =imx_clk_mux2 ("enet_timer_src" , base +0xaa00 ,24 ,3 , imx8mq_enet_timer_sels,ARRAY_SIZE (imx8mq_enet_timer_sels)); + clks[IMX8MQ_CLK_ENET_PHY_REF_SRC ] =imx_clk_mux2 ("enet_phy_src" , base +0xaa80 ,24 ,3 , imx8mq_enet_phy_sels,ARRAY_SIZE (imx8mq_enet_phy_sels)); + clks[IMX8MQ_CLK_NAND_SRC ] =imx_clk_mux2 ("nand_src" , base +0xab00 ,24 ,3 , imx8mq_nand_sels,ARRAY_SIZE (imx8mq_nand_sels)); + clks[IMX8MQ_CLK_QSPI_SRC ] =imx_clk_mux2 ("qspi_src" , base +0xab80 ,24 ,3 , imx8mq_qspi_sels,ARRAY_SIZE (imx8mq_qspi_sels)); + clks[IMX8MQ_CLK_USDHC1_SRC ] =imx_clk_mux2 ("usdhc1_src" , base +0xac00 ,24 ,3 , imx8mq_usdhc1_sels,ARRAY_SIZE (imx8mq_usdhc1_sels)); + clks[IMX8MQ_CLK_USDHC2_SRC ] =imx_clk_mux2 ("usdhc2_src" , base +0xac80 ,24 ,3 , imx8mq_usdhc2_sels,ARRAY_SIZE (imx8mq_usdhc2_sels)); + clks[IMX8MQ_CLK_I2C1_SRC ] =imx_clk_mux2 ("i2c1_src" , base +0xad00 ,24 ,3 , imx8mq_i2c1_sels,ARRAY_SIZE (imx8mq_i2c1_sels)); + clks[IMX8MQ_CLK_I2C2_SRC ] =imx_clk_mux2 ("i2c2_src" , base +0xad80 ,24 ,3 , imx8mq_i2c2_sels,ARRAY_SIZE (imx8mq_i2c2_sels)); + clks[IMX8MQ_CLK_I2C3_SRC ] =imx_clk_mux2 ("i2c3_src" , base +0xae00 ,24 ,3 , imx8mq_i2c3_sels,ARRAY_SIZE (imx8mq_i2c3_sels)); + clks[IMX8MQ_CLK_I2C4_SRC ] =imx_clk_mux2 ("i2c4_src" , base +0xae80 ,24 ,3 , imx8mq_i2c4_sels,ARRAY_SIZE (imx8mq_i2c4_sels)); + clks[IMX8MQ_CLK_UART1_SRC ] =imx_clk_mux2 ("uart1_src" , base +0xaf00 ,24 ,3 , imx8mq_uart1_sels,ARRAY_SIZE (imx8mq_uart1_sels)); + clks[IMX8MQ_CLK_UART2_SRC ] =imx_clk_mux2 ("uart2_src" , base +0xaf80 ,24 ,3 , imx8mq_uart2_sels,ARRAY_SIZE (imx8mq_uart2_sels)); + clks[IMX8MQ_CLK_UART3_SRC ] =imx_clk_mux2 ("uart3_src" , base +0xb000 ,24 ,3 , imx8mq_uart3_sels,ARRAY_SIZE (imx8mq_uart3_sels)); + clks[IMX8MQ_CLK_UART4_SRC ] =imx_clk_mux2 ("uart4_src" , base +0xb080 ,24 ,3 , imx8mq_uart4_sels,ARRAY_SIZE (imx8mq_uart4_sels)); + clks[IMX8MQ_CLK_USB_CORE_REF_SRC ] =imx_clk_mux2 ("usb_core_ref_src" , base +0xb100 ,24 ,3 , imx8mq_usb_core_sels,ARRAY_SIZE (imx8mq_usb_core_sels)); + clks[IMX8MQ_CLK_USB_PHY_REF_SRC ] =imx_clk_mux2 ("usb_phy_ref_src" , base +0xb180 ,24 ,3 , imx8mq_usb_phy_sels,ARRAY_SIZE (imx8mq_usb_phy_sels)); + clks[IMX8MQ_CLK_ECSPI1_SRC ] =imx_clk_mux2 ("ecspi1_src" , base +0xb280 ,24 ,3 , imx8mq_ecspi1_sels,ARRAY_SIZE (imx8mq_ecspi1_sels)); + clks[IMX8MQ_CLK_ECSPI2_SRC ] =imx_clk_mux2 ("ecspi2_src" , base +0xb300 ,24 ,3 , imx8mq_ecspi2_sels,ARRAY_SIZE (imx8mq_ecspi2_sels)); + clks[IMX8MQ_CLK_PWM1_SRC ] =imx_clk_mux2 ("pwm1_src" , base +0xb380 ,24 ,3 , imx8mq_pwm1_sels,ARRAY_SIZE (imx8mq_pwm1_sels)); + clks[IMX8MQ_CLK_PWM2_SRC ] =imx_clk_mux2 ("pwm2_src" , base +0xb400 ,24 ,3 , imx8mq_pwm2_sels,ARRAY_SIZE (imx8mq_pwm2_sels)); + clks[IMX8MQ_CLK_PWM3_SRC ] =imx_clk_mux2 ("pwm3_src" , base +0xb480 ,24 ,3 , imx8mq_pwm3_sels,ARRAY_SIZE (imx8mq_pwm3_sels)); + clks[IMX8MQ_CLK_PWM4_SRC ] =imx_clk_mux2 ("pwm4_src" , base +0xb500 ,24 ,3 , imx8mq_pwm4_sels,ARRAY_SIZE (imx8mq_pwm4_sels)); + clks[IMX8MQ_CLK_GPT1_SRC ] =imx_clk_mux2 ("gpt1_src" , base +0xb580 ,24 ,3 , imx8mq_gpt1_sels,ARRAY_SIZE (imx8mq_gpt1_sels)); + clks[IMX8MQ_CLK_WDOG_SRC ] =imx_clk_mux2 ("wdog_src" , base +0xb900 ,24 ,3 , imx8mq_wdog_sels,ARRAY_SIZE (imx8mq_wdog_sels)); + clks[IMX8MQ_CLK_WRCLK_SRC ] =imx_clk_mux2 ("wrclk_src" , base +0xb980 ,24 ,3 , imx8mq_wrclk_sels,ARRAY_SIZE (imx8mq_wrclk_sels)); + clks[IMX8MQ_CLK_CLKO2_SRC ] =imx_clk_mux2 ("clko2_src" , base +0xba80 ,24 ,3 , imx8mq_clko2_sels,ARRAY_SIZE (imx8mq_clko2_sels)); + clks[IMX8MQ_CLK_DSI_CORE_SRC ] =imx_clk_mux2 ("dsi_core_src" , base +0xbb00 ,24 ,3 , imx8mq_dsi_core_sels,ARRAY_SIZE (imx8mq_dsi_core_sels)); + clks[IMX8MQ_CLK_DSI_PHY_REF_SRC ] =imx_clk_mux2 ("dsi_phy_ref_src" , base +0xbb80 ,24 ,3 , imx8mq_dsi_phy_sels,ARRAY_SIZE (imx8mq_dsi_phy_sels)); + clks[IMX8MQ_CLK_DSI_DBI_SRC ] =imx_clk_mux2 ("dsi_dbi_src" , base +0xbc00 ,24 ,3 , imx8mq_dsi_dbi_sels,ARRAY_SIZE (imx8mq_dsi_dbi_sels)); + clks[IMX8MQ_CLK_DSI_ESC_SRC ] =imx_clk_mux2 ("dsi_esc_src" , base +0xbc80 ,24 ,3 , imx8mq_dsi_esc_sels,ARRAY_SIZE (imx8mq_dsi_esc_sels)); + clks[IMX8MQ_CLK_DSI_AHB_SRC ] =imx_clk_mux2 ("dsi_ahb_src" , base +0x9200 ,24 ,3 , imx8mq_dsi_ahb_sels,ARRAY_SIZE (imx8mq_dsi_ahb_sels)); + clks[IMX8MQ_CLK_CSI1_CORE_SRC ] =imx_clk_mux2 ("csi1_core_src" , base +0xbd00 ,24 ,3 , imx8mq_csi1_core_sels,ARRAY_SIZE (imx8mq_csi1_core_sels)); + clks[IMX8MQ_CLK_CSI1_PHY_REF_SRC ] =imx_clk_mux2 ("csi1_phy_ref_src" , base +0xbd80 ,24 ,3 , imx8mq_csi1_phy_sels,ARRAY_SIZE (imx8mq_csi1_phy_sels)); + clks[IMX8MQ_CLK_CSI1_ESC_SRC ] =imx_clk_mux2 ("csi1_esc_src" , base +0xbe00 ,24 ,3 , imx8mq_csi1_esc_sels,ARRAY_SIZE (imx8mq_csi1_esc_sels)); + clks[IMX8MQ_CLK_CSI2_CORE_SRC ] =imx_clk_mux2 ("csi2_core_src" , base +0xbe80 ,24 ,3 , imx8mq_csi2_core_sels,ARRAY_SIZE (imx8mq_csi2_core_sels)); + clks[IMX8MQ_CLK_CSI2_PHY_REF_SRC ] =imx_clk_mux2 ("csi2_phy_ref_src" , base +0xbf00 ,24 ,3 , imx8mq_csi2_phy_sels,ARRAY_SIZE (imx8mq_csi2_phy_sels)); + clks[IMX8MQ_CLK_CSI2_ESC_SRC ] =imx_clk_mux2 ("csi2_esc_src" , base +0xbf80 ,24 ,3 , imx8mq_csi2_esc_sels,ARRAY_SIZE (imx8mq_csi2_esc_sels)); + clks[IMX8MQ_CLK_PCIE2_CTRL_SRC ] =imx_clk_mux2 ("pcie2_ctrl_src" , base +0xc000 ,24 ,3 , imx8mq_pcie2_ctrl_sels,ARRAY_SIZE (imx8mq_pcie2_ctrl_sels)); + clks[IMX8MQ_CLK_PCIE2_PHY_SRC ] =imx_clk_mux2 ("pcie2_phy_src" , base +0xc080 ,24 ,3 , imx8mq_pcie2_phy_sels,ARRAY_SIZE (imx8mq_pcie2_phy_sels)); + clks[IMX8MQ_CLK_PCIE2_AUX_SRC ] =imx_clk_mux2 ("pcie2_aux_src" , base +0xc100 ,24 ,3 , imx8mq_pcie2_aux_sels,ARRAY_SIZE (imx8mq_pcie2_aux_sels)); + clks[IMX8MQ_CLK_ECSPI3_SRC ] =imx_clk_mux2 ("ecspi3_src" , base +0xc180 ,24 ,3 , imx8mq_ecspi3_sels,ARRAY_SIZE (imx8mq_ecspi3_sels)); + + clks[IMX8MQ_CLK_DRAM_ALT_CG ] =imx_clk_gate3 ("dram_alt_cg" ,"dram_alt_src" , base +0xa000 ,28 ); + clks[IMX8MQ_CLK_DRAM_APB_CG ] =imx_clk_gate3 ("dram_apb_cg" ,"dram_apb_src" , base +0xa080 ,28 ); + clks[IMX8MQ_CLK_VPU_G1_CG ] =imx_clk_gate3 ("vpu_g1_cg" ,"vpu_g1_src" , base +0xa100 ,28 ); + clks[IMX8MQ_CLK_VPU_G2_CG ] =imx_clk_gate3 ("vpu_g2_cg" ,"vpu_g2_src" , base +0xa180 ,28 ); + clks[IMX8MQ_CLK_DISP_DTRC_CG ] =imx_clk_gate3 ("disp_dtrc_cg" ,"disp_dtrc_src" , base +0xa200 ,28 ); + clks[IMX8MQ_CLK_DISP_DC8000_CG ] =imx_clk_gate3 ("disp_dc8000_cg" ,"disp_dc8000_src" , base +0xa280 ,28 ); + clks[IMX8MQ_CLK_PCIE1_CTRL_CG ] =imx_clk_gate3 ("pcie1_ctrl_cg" ,"pcie1_ctrl_src" , base +0xa300 ,28 ); + clks[IMX8MQ_CLK_PCIE1_PHY_CG ] =imx_clk_gate3 ("pcie1_phy_cg" ,"pcie1_phy_src" , base +0xa380 ,28 ); + clks[IMX8MQ_CLK_PCIE1_AUX_CG ] =imx_clk_gate3 ("pcie1_aux_cg" ,"pcie1_aux_src" , base +0xa400 ,28 ); + clks[IMX8MQ_CLK_DC_PIXEL_CG ] =imx_clk_gate3 ("dc_pixel_cg" ,"dc_pixel_src" , base +0xa480 ,28 ); + clks[IMX8MQ_CLK_LCDIF_PIXEL_CG ] =imx_clk_gate3 ("lcdif_pixel_cg" ,"lcdif_pixel_src" , base +0xa500 ,28 ); + clks[IMX8MQ_CLK_SAI1_CG ] =imx_clk_gate3 ("sai1_cg" ,"sai1_src" , base +0xa580 ,28 ); + clks[IMX8MQ_CLK_SAI2_CG ] =imx_clk_gate3 ("sai2_cg" ,"sai2_src" , base +0xa600 ,28 ); + clks[IMX8MQ_CLK_SAI3_CG ] =imx_clk_gate3 ("sai3_cg" ,"sai3_src" , base +0xa680 ,28 ); + clks[IMX8MQ_CLK_SAI4_CG ] =imx_clk_gate3 ("sai4_cg" ,"sai4_src" , base +0xa700 ,28 ); + clks[IMX8MQ_CLK_SAI5_CG ] =imx_clk_gate3 ("sai5_cg" ,"sai5_src" , base +0xa780 ,28 ); + clks[IMX8MQ_CLK_SAI6_CG ] =imx_clk_gate3 ("sai6_cg" ,"sai6_src" , base +0xa800 ,28 ); + clks[IMX8MQ_CLK_SPDIF1_CG ] =imx_clk_gate3 ("spdif1_cg" ,"spdif1_src" , base +0xa880 ,28 ); + clks[IMX8MQ_CLK_SPDIF2_CG ] =imx_clk_gate3 ("spdif2_cg" ,"spdif2_src" , base +0xa900 ,28 ); + clks[IMX8MQ_CLK_ENET_REF_CG ] =imx_clk_gate3 ("enet_ref_cg" ,"enet_ref_src" , base +0xa980 ,28 ); + clks[IMX8MQ_CLK_ENET_TIMER_CG ] =imx_clk_gate3 ("enet_timer_cg" ,"enet_timer_src" , base +0xaa00 ,28 ); + clks[IMX8MQ_CLK_ENET_PHY_REF_CG ] =imx_clk_gate3 ("enet_phy_cg" ,"enet_phy_src" , base +0xaa80 ,28 ); + clks[IMX8MQ_CLK_NAND_CG ] =imx_clk_gate3 ("nand_cg" ,"nand_src" , base +0xab00 ,28 ); + clks[IMX8MQ_CLK_QSPI_CG ] =imx_clk_gate3 ("qspi_cg" ,"qspi_src" , base +0xab80 ,28 ); + clks[IMX8MQ_CLK_USDHC1_CG ] =imx_clk_gate3 ("usdhc1_cg" ,"usdhc1_src" , base +0xac00 ,28 ); + clks[IMX8MQ_CLK_USDHC2_CG ] =imx_clk_gate3 ("usdhc2_cg" ,"usdhc2_src" , base +0xac80 ,28 ); + clks[IMX8MQ_CLK_I2C1_CG ] =imx_clk_gate3 ("i2c1_cg" ,"i2c1_src" , base +0xad00 ,28 ); + clks[IMX8MQ_CLK_I2C2_CG ] =imx_clk_gate3 ("i2c2_cg" ,"i2c2_src" , base +0xad80 ,28 ); + clks[IMX8MQ_CLK_I2C3_CG ] =imx_clk_gate3 ("i2c3_cg" ,"i2c3_src" , base +0xae00 ,28 ); + clks[IMX8MQ_CLK_I2C4_CG ] =imx_clk_gate3 ("i2c4_cg" ,"i2c4_src" , base +0xae80 ,28 ); + clks[IMX8MQ_CLK_UART1_CG ] =imx_clk_gate3 ("uart1_cg" ,"uart1_src" , base +0xaf00 ,28 ); + clks[IMX8MQ_CLK_UART2_CG ] =imx_clk_gate3 ("uart2_cg" ,"uart2_src" , base +0xaf80 ,28 ); + clks[IMX8MQ_CLK_UART3_CG ] =imx_clk_gate3 ("uart3_cg" ,"uart3_src" , base +0xb000 ,28 ); + clks[IMX8MQ_CLK_UART4_CG ] =imx_clk_gate3 ("uart4_cg" ,"uart4_src" , base +0xb080 ,28 ); + clks[IMX8MQ_CLK_USB_CORE_REF_CG ] =imx_clk_gate3 ("usb_core_ref_cg" ,"usb_core_ref_src" , base +0xb100 ,28 ); + clks[IMX8MQ_CLK_USB_PHY_REF_CG ] =imx_clk_gate3 ("usb_phy_ref_cg" ,"usb_phy_ref_src" , base +0xb180 ,28 ); + clks[IMX8MQ_CLK_ECSPI1_CG ] =imx_clk_gate3 ("ecspi1_cg" ,"ecspi1_src" , base +0xb280 ,28 ); + clks[IMX8MQ_CLK_ECSPI2_CG ] =imx_clk_gate3 ("ecspi2_cg" ,"ecspi2_src" , base +0xb300 ,28 ); + clks[IMX8MQ_CLK_PWM1_CG ] =imx_clk_gate3 ("pwm1_cg" ,"pwm1_src" , base +0xb380 ,28 ); + clks[IMX8MQ_CLK_PWM2_CG ] =imx_clk_gate3 ("pwm2_cg" ,"pwm2_src" , base +0xb400 ,28 ); + clks[IMX8MQ_CLK_PWM3_CG ] =imx_clk_gate3 ("pwm3_cg" ,"pwm3_src" , base +0xb480 ,28 ); + clks[IMX8MQ_CLK_PWM4_CG ] =imx_clk_gate3 ("pwm4_cg" ,"pwm4_src" , base +0xb500 ,28 ); + clks[IMX8MQ_CLK_GPT1_CG ] =imx_clk_gate3 ("gpt1_cg" ,"gpt1_src" , base +0xb580 ,28 ); + clks[IMX8MQ_CLK_WDOG_CG ] =imx_clk_gate3 ("wdog_cg" ,"wdog_src" , base +0xb900 ,28 ); + clks[IMX8MQ_CLK_WRCLK_CG ] =imx_clk_gate3 ("wrclk_cg" ,"wrclk_src" , base +0xb980 ,28 ); + clks[IMX8MQ_CLK_CLKO2_CG ] =imx_clk_gate3 ("clko2_cg" ,"clko2_src" , base +0xba80 ,28 ); + clks[IMX8MQ_CLK_DSI_CORE_CG ] =imx_clk_gate3 ("dsi_core_cg" ,"dsi_core_src" , base +0xbb00 ,28 ); + clks[IMX8MQ_CLK_DSI_PHY_REF_CG ] =imx_clk_gate3 ("dsi_phy_ref_cg" ,"dsi_phy_ref_src" , base +0xbb80 ,28 ); + clks[IMX8MQ_CLK_DSI_DBI_CG ] =imx_clk_gate3 ("dsi_dbi_cg" ,"dsi_dbi_src" , base +0xbc00 ,28 ); + clks[IMX8MQ_CLK_DSI_ESC_CG ] =imx_clk_gate3 ("dsi_esc_cg" ,"dsi_esc_src" , base +0xbc80 ,28 ); + clks[IMX8MQ_CLK_DSI_AHB_CG ] =imx_clk_gate3 ("dsi_ahb_cg" ,"dsi_ahb_src" , base +0x9200 ,28 ); + clks[IMX8MQ_CLK_CSI1_CORE_CG ] =imx_clk_gate3 ("csi1_core_cg" ,"csi1_core_src" , base +0xbd00 ,28 ); + clks[IMX8MQ_CLK_CSI1_PHY_REF_CG ] =imx_clk_gate3 ("csi1_phy_ref_cg" ,"csi1_phy_ref_src" , base +0xbd80 ,28 ); + clks[IMX8MQ_CLK_CSI1_ESC_CG ] =imx_clk_gate3 ("csi1_esc_cg" ,"csi1_esc_src" , base +0xbe00 ,28 ); + clks[IMX8MQ_CLK_CSI2_CORE_CG ] =imx_clk_gate3 ("csi2_core_cg" ,"csi2_core_src" , base +0xbe80 ,28 ); + clks[IMX8MQ_CLK_CSI2_PHY_REF_CG ] =imx_clk_gate3 ("csi2_phy_ref_cg" ,"csi2_phy_ref_src" , base +0xbf00 ,28 ); + clks[IMX8MQ_CLK_CSI2_ESC_CG ] =imx_clk_gate3 ("csi2_esc_cg" ,"csi2_esc_src" , base +0xbf80 ,28 ); + clks[IMX8MQ_CLK_PCIE2_CTRL_CG ] =imx_clk_gate3 ("pcie2_ctrl_cg" ,"pcie2_ctrl_src" , base +0xc000 ,28 ); + clks[IMX8MQ_CLK_PCIE2_PHY_CG ] =imx_clk_gate3 ("pcie2_phy_cg" ,"pcie2_phy_src" , base +0xc080 ,28 ); + clks[IMX8MQ_CLK_PCIE2_AUX_CG ] =imx_clk_gate3 ("pcie2_aux_cg" ,"pcie2_aux_src" , base +0xc100 ,28 ); + clks[IMX8MQ_CLK_ECSPI3_CG ] =imx_clk_gate3 ("ecspi3_cg" ,"ecspi3_src" , base +0xc180 ,28 ); + + clks[IMX8MQ_CLK_DRAM_ALT_PRE_DIV ] =imx_clk_divider2 ("dram_alt_pre_div" ,"dram_alt_cg" , base +0xa000 ,16 ,3 ); + clks[IMX8MQ_CLK_DRAM_APB_PRE_DIV ] =imx_clk_divider_flags ("dram_apb_pre_div" ,"dram_apb_cg" , base +0xa080 ,16 ,3 ,CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_VPU_G1_PRE_DIV ] =imx_clk_divider_flags ("vpu_g1_pre_div" ,"vpu_g1_cg" , base +0xa100 ,16 ,3 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_VPU_G2_PRE_DIV ] =imx_clk_divider_flags ("vpu_g2_pre_div" ,"vpu_g2_cg" , base +0xa180 ,16 ,3 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_DISP_DTRC_PRE_DIV ] =imx_clk_divider2 ("disp_dtrc_pre_div" ,"disp_dtrc_cg" , base +0xa200 ,16 ,3 ); + clks[IMX8MQ_CLK_DISP_DC8000_PRE_DIV ] =imx_clk_divider2 ("disp_dc8000_pre_div" ,"disp_dc8000_cg" , base +0xa280 ,16 ,3 ); + clks[IMX8MQ_CLK_PCIE1_CTRL_PRE_DIV ] =imx_clk_divider2 ("pcie1_ctrl_pre_div" ,"pcie1_ctrl_cg" , base +0xa300 ,16 ,3 ); + clks[IMX8MQ_CLK_PCIE1_PHY_PRE_DIV ] =imx_clk_divider2 ("pcie1_phy_pre_div" ,"pcie1_phy_cg" , base +0xa380 ,16 ,3 ); + clks[IMX8MQ_CLK_PCIE1_AUX_PRE_DIV ] =imx_clk_divider2 ("pcie1_aux_pre_div" ,"pcie1_aux_cg" , base +0xa400 ,16 ,3 ); + clks[IMX8MQ_CLK_DC_PIXEL_PRE_DIV ] =imx_clk_divider2 ("dc_pixel_pre_div" ,"dc_pixel_cg" , base +0xa480 ,16 ,3 ); + clks[IMX8MQ_CLK_LCDIF_PIXEL_PRE_DIV ] =imx_clk_divider2 ("lcdif_pixel_pre_div" ,"lcdif_pixel_cg" , base +0xa500 ,16 ,3 ); + clks[IMX8MQ_CLK_SAI1_PRE_DIV ] =imx_clk_divider2 ("sai1_pre_div" ,"sai1_cg" , base +0xa580 ,16 ,3 ); + clks[IMX8MQ_CLK_SAI2_PRE_DIV ] =imx_clk_divider2 ("sai2_pre_div" ,"sai2_cg" , base +0xa600 ,16 ,3 ); + clks[IMX8MQ_CLK_SAI3_PRE_DIV ] =imx_clk_divider2 ("sai3_pre_div" ,"sai3_cg" , base +0xa680 ,16 ,3 ); + clks[IMX8MQ_CLK_SAI4_PRE_DIV ] =imx_clk_divider2 ("sai4_pre_div" ,"sai4_cg" , base +0xa700 ,16 ,3 ); + clks[IMX8MQ_CLK_SAI5_PRE_DIV ] =imx_clk_divider2 ("sai5_pre_div" ,"sai5_cg" , base +0xa780 ,16 ,3 ); + clks[IMX8MQ_CLK_SAI6_PRE_DIV ] =imx_clk_divider2 ("sai6_pre_div" ,"sai6_cg" , base +0xa800 ,16 ,3 ); + clks[IMX8MQ_CLK_SPDIF1_PRE_DIV ] =imx_clk_divider2 ("spdif1_pre_div" ,"spdif1_cg" , base +0xa880 ,16 ,3 ); + clks[IMX8MQ_CLK_SPDIF2_PRE_DIV ] =imx_clk_divider2 ("spdif2_pre_div" ,"spdif2_cg" , base +0xa900 ,16 ,3 ); + clks[IMX8MQ_CLK_ENET_REF_PRE_DIV ] =imx_clk_divider2 ("enet_ref_pre_div" ,"enet_ref_cg" , base +0xa980 ,16 ,3 ); + clks[IMX8MQ_CLK_ENET_TIMER_PRE_DIV ] =imx_clk_divider2 ("enet_timer_pre_div" ,"enet_timer_cg" , base +0xaa00 ,16 ,3 ); + clks[IMX8MQ_CLK_ENET_PHY_REF_PRE_DIV ] =imx_clk_divider2 ("enet_phy_pre_div" ,"enet_phy_cg" , base +0xaa80 ,16 ,3 ); + clks[IMX8MQ_CLK_NAND_PRE_DIV ] =imx_clk_divider2 ("nand_pre_div" ,"nand_cg" , base +0xab00 ,16 ,3 ); + clks[IMX8MQ_CLK_QSPI_PRE_DIV ] =imx_clk_divider2 ("qspi_pre_div" ,"qspi_cg" , base +0xab80 ,16 ,3 ); + clks[IMX8MQ_CLK_USDHC1_PRE_DIV ] =imx_clk_divider2 ("usdhc1_pre_div" ,"usdhc1_cg" , base +0xac00 ,16 ,3 ); + clks[IMX8MQ_CLK_USDHC2_PRE_DIV ] =imx_clk_divider2 ("usdhc2_pre_div" ,"usdhc2_cg" , base +0xac80 ,16 ,3 ); + clks[IMX8MQ_CLK_I2C1_PRE_DIV ] =imx_clk_divider2 ("i2c1_pre_div" ,"i2c1_cg" , base +0xad00 ,16 ,3 ); + clks[IMX8MQ_CLK_I2C2_PRE_DIV ] =imx_clk_divider2 ("i2c2_pre_div" ,"i2c2_cg" , base +0xad80 ,16 ,3 ); + clks[IMX8MQ_CLK_I2C3_PRE_DIV ] =imx_clk_divider2 ("i2c3_pre_div" ,"i2c3_cg" , base +0xae00 ,16 ,3 ); + clks[IMX8MQ_CLK_I2C4_PRE_DIV ] =imx_clk_divider2 ("i2c4_pre_div" ,"i2c4_cg" , base +0xae80 ,16 ,3 ); + clks[IMX8MQ_CLK_UART1_PRE_DIV ] =imx_clk_divider2 ("uart1_pre_div" ,"uart1_cg" , base +0xaf00 ,16 ,3 ); + clks[IMX8MQ_CLK_UART2_PRE_DIV ] =imx_clk_divider2 ("uart2_pre_div" ,"uart2_cg" , base +0xaf80 ,16 ,3 ); + clks[IMX8MQ_CLK_UART3_PRE_DIV ] =imx_clk_divider2 ("uart3_pre_div" ,"uart3_cg" , base +0xb000 ,16 ,3 ); + clks[IMX8MQ_CLK_UART4_PRE_DIV ] =imx_clk_divider2 ("uart4_pre_div" ,"uart4_cg" , base +0xb080 ,16 ,3 ); + clks[IMX8MQ_CLK_USB_CORE_REF_PRE_DIV ] =imx_clk_divider2 ("usb_core_ref_pre_div" ,"usb_core_ref_cg" , base +0xb100 ,16 ,3 ); + clks[IMX8MQ_CLK_USB_PHY_REF_PRE_DIV ] =imx_clk_divider2 ("usb_phy_ref_pre_div" ,"usb_phy_ref_cg" , base +0xb180 ,16 ,3 ); + clks[IMX8MQ_CLK_ECSPI1_PRE_DIV ] =imx_clk_divider2 ("ecspi1_pre_div" ,"ecspi1_cg" , base +0xb280 ,16 ,3 ); + clks[IMX8MQ_CLK_ECSPI2_PRE_DIV ] =imx_clk_divider2 ("ecspi2_pre_div" ,"ecspi2_cg" , base +0xb300 ,16 ,3 ); + clks[IMX8MQ_CLK_PWM1_PRE_DIV ] =imx_clk_divider2 ("pwm1_pre_div" ,"pwm1_cg" , base +0xb380 ,16 ,3 ); + clks[IMX8MQ_CLK_PWM2_PRE_DIV ] =imx_clk_divider2 ("pwm2_pre_div" ,"pwm2_cg" , base +0xb400 ,16 ,3 ); + clks[IMX8MQ_CLK_PWM3_PRE_DIV ] =imx_clk_divider2 ("pwm3_pre_div" ,"pwm3_cg" , base +0xb480 ,16 ,3 ); + clks[IMX8MQ_CLK_PWM4_PRE_DIV ] =imx_clk_divider2 ("pwm4_pre_div" ,"pwm4_cg" , base +0xb500 ,16 ,3 ); + clks[IMX8MQ_CLK_GPT1_PRE_DIV ] =imx_clk_divider2 ("gpt1_pre_div" ,"gpt1_cg" , base +0xb580 ,16 ,3 ); + clks[IMX8MQ_CLK_WDOG_PRE_DIV ] =imx_clk_divider2 ("wdog_pre_div" ,"wdog_cg" , base +0xb900 ,16 ,3 ); + clks[IMX8MQ_CLK_WRCLK_PRE_DIV ] =imx_clk_divider2 ("wrclk_pre_div" ,"wrclk_cg" , base +0xb980 ,16 ,3 ); + clks[IMX8MQ_CLK_CLKO2_PRE_DIV ] =imx_clk_divider2 ("clko2_pre_div" ,"clko2_cg" , base +0xba80 ,16 ,3 ); + clks[IMX8MQ_CLK_DSI_CORE_PRE_DIV ] =imx_clk_divider2 ("dsi_core_pre_div" ,"dsi_core_cg" , base +0xbb00 ,16 ,3 ); + clks[IMX8MQ_CLK_DSI_PHY_REF_PRE_DIV ] =imx_clk_divider2 ("dsi_phy_ref_pre_div" ,"dsi_phy_ref_cg" , base +0xbb80 ,16 ,3 ); + clks[IMX8MQ_CLK_DSI_DBI_PRE_DIV ] =imx_clk_divider2 ("dsi_dbi_pre_div" ,"dsi_dbi_cg" , base +0xbc00 ,16 ,3 ); + clks[IMX8MQ_CLK_DSI_ESC_PRE_DIV ] =imx_clk_divider2 ("dsi_esc_pre_div" ,"dsi_esc_cg" , base +0xbc80 ,16 ,3 ); + clks[IMX8MQ_CLK_DSI_AHB_PRE_DIV ] =imx_clk_divider2 ("dsi_ahb_pre_div" ,"dsi_ahb_cg" , base +0x9200 ,16 ,3 ); + clks[IMX8MQ_CLK_CSI1_CORE_PRE_DIV ] =imx_clk_divider2 ("csi1_core_pre_div" ,"csi1_core_cg" , base +0xbd00 ,16 ,3 ); + clks[IMX8MQ_CLK_CSI1_PHY_REF_PRE_DIV ] =imx_clk_divider2 ("csi1_phy_ref_pre_div" ,"csi1_phy_ref_cg" , base +0xbd80 ,16 ,3 ); + clks[IMX8MQ_CLK_CSI1_ESC_PRE_DIV ] =imx_clk_divider2 ("csi1_esc_pre_div" ,"csi1_esc_cg" , base +0xbe00 ,16 ,3 ); + clks[IMX8MQ_CLK_CSI2_CORE_PRE_DIV ] =imx_clk_divider2 ("csi2_core_pre_div" ,"csi2_core_cg" , base +0xbe80 ,16 ,3 ); + clks[IMX8MQ_CLK_CSI2_PHY_REF_PRE_DIV ] =imx_clk_divider2 ("csi2_phy_ref_pre_div" ,"csi2_phy_ref_cg" , base +0xbf00 ,16 ,3 ); + clks[IMX8MQ_CLK_CSI2_ESC_PRE_DIV ] =imx_clk_divider2 ("csi2_esc_pre_div" ,"csi2_esc_cg" , base +0xbf80 ,16 ,3 ); + clks[IMX8MQ_CLK_PCIE2_CTRL_PRE_DIV ] =imx_clk_divider2 ("pcie2_ctrl_pre_div" ,"pcie2_ctrl_cg" , base +0xc000 ,16 ,3 ); + clks[IMX8MQ_CLK_PCIE2_PHY_PRE_DIV ] =imx_clk_divider2 ("pcie2_phy_pre_div" ,"pcie2_phy_cg" , base +0xc080 ,16 ,3 ); + clks[IMX8MQ_CLK_PCIE2_AUX_PRE_DIV ] =imx_clk_divider2 ("pcie2_aux_pre_div" ,"pcie2_aux_cg" , base +0xc100 ,16 ,3 ); + clks[IMX8MQ_CLK_ECSPI3_PRE_DIV ] =imx_clk_divider2 ("ecspi3_pre_div" ,"ecspi3_cg" , base +0xc180 ,16 ,3 ); + + clks[IMX8MQ_CLK_DRAM_ALT_DIV ] =imx_clk_divider2 ("dram_alt_div" ,"dram_alt_pre_div" , base +0xa000 ,0 ,6 ); + clks[IMX8MQ_CLK_DRAM_APB_DIV ] =imx_clk_divider2_flags ("dram_apb_div" ,"dram_apb_pre_div" , base +0xa080 ,0 ,6 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_VPU_G1_DIV ] =imx_clk_divider_flags ("vpu_g1_div" ,"vpu_g1_pre_div" , base +0xa100 ,0 ,6 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_VPU_G2_DIV ] =imx_clk_divider_flags ("vpu_g2_div" ,"vpu_g2_pre_div" , base +0xa180 ,0 ,6 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_DISP_DTRC_DIV ] =imx_clk_divider2 ("disp_dtrc_div" ,"disp_dtrc_pre_div" , base +0xa200 ,0 ,6 ); + clks[IMX8MQ_CLK_DISP_DC8000_DIV ] =imx_clk_divider2 ("disp_dc8000_div" ,"disp_dc8000_pre_div" , base +0xa280 ,0 ,6 ); + clks[IMX8MQ_CLK_PCIE1_CTRL_DIV ] =imx_clk_divider2 ("pcie1_ctrl_div" ,"pcie1_ctrl_pre_div" , base +0xa300 ,0 ,6 ); + clks[IMX8MQ_CLK_PCIE1_PHY_DIV ] =imx_clk_divider2 ("pcie1_phy_div" ,"pcie1_phy_pre_div" , base +0xa380 ,0 ,6 ); + clks[IMX8MQ_CLK_PCIE1_AUX_DIV ] =imx_clk_divider2 ("pcie1_aux_div" ,"pcie1_aux_pre_div" , base +0xa400 ,0 ,6 ); + clks[IMX8MQ_CLK_DC_PIXEL_DIV ] =imx_clk_divider2 ("dc_pixel_div" ,"dc_pixel_pre_div" , base +0xa480 ,0 ,6 ); + clks[IMX8MQ_CLK_LCDIF_PIXEL_DIV ] =imx_clk_divider2 ("lcdif_pixel_div" ,"lcdif_pixel_pre_div" , base +0xa500 ,0 ,6 ); + clks[IMX8MQ_CLK_SAI1_DIV ] =imx_clk_divider2 ("sai1_div" ,"sai1_pre_div" , base +0xa580 ,0 ,6 ); + clks[IMX8MQ_CLK_SAI2_DIV ] =imx_clk_divider2 ("sai2_div" ,"sai2_pre_div" , base +0xa600 ,0 ,6 ); + clks[IMX8MQ_CLK_SAI3_DIV ] =imx_clk_divider2 ("sai3_div" ,"sai3_pre_div" , base +0xa680 ,0 ,6 ); + clks[IMX8MQ_CLK_SAI4_DIV ] =imx_clk_divider2 ("sai4_div" ,"sai4_pre_div" , base +0xa700 ,0 ,6 ); + clks[IMX8MQ_CLK_SAI5_DIV ] =imx_clk_divider2 ("sai5_div" ,"sai5_pre_div" , base +0xa780 ,0 ,6 ); + clks[IMX8MQ_CLK_SAI6_DIV ] =imx_clk_divider2 ("sai6_div" ,"sai6_pre_div" , base +0xa800 ,0 ,6 ); + clks[IMX8MQ_CLK_SPDIF1_DIV ] =imx_clk_divider2 ("spdif1_div" ,"spdif1_pre_div" , base +0xa880 ,0 ,6 ); + clks[IMX8MQ_CLK_SPDIF2_DIV ] =imx_clk_divider2 ("spdif2_div" ,"spdif2_pre_div" , base +0xa900 ,0 ,6 ); + clks[IMX8MQ_CLK_ENET_REF_DIV ] =imx_clk_divider2 ("enet_ref_div" ,"enet_ref_pre_div" , base +0xa980 ,0 ,6 ); + clks[IMX8MQ_CLK_ENET_TIMER_DIV ] =imx_clk_divider2 ("enet_timer_div" ,"enet_timer_pre_div" , base +0xaa00 ,0 ,6 ); + clks[IMX8MQ_CLK_ENET_PHY_REF_DIV ] =imx_clk_divider2 ("enet_phy_div" ,"enet_phy_pre_div" , base +0xaa80 ,0 ,6 ); + clks[IMX8MQ_CLK_NAND_DIV ] =imx_clk_divider2 ("nand_div" ,"nand_pre_div" , base +0xab00 ,0 ,6 ); + clks[IMX8MQ_CLK_QSPI_DIV ] =imx_clk_divider2 ("qspi_div" ,"qspi_pre_div" , base +0xab80 ,0 ,6 ); + clks[IMX8MQ_CLK_USDHC1_DIV ] =imx_clk_divider2 ("usdhc1_div" ,"usdhc1_pre_div" , base +0xac00 ,0 ,6 ); + clks[IMX8MQ_CLK_USDHC2_DIV ] =imx_clk_divider2 ("usdhc2_div" ,"usdhc2_pre_div" , base +0xac80 ,0 ,6 ); + clks[IMX8MQ_CLK_I2C1_DIV ] =imx_clk_divider2 ("i2c1_div" ,"i2c1_pre_div" , base +0xad00 ,0 ,6 ); + clks[IMX8MQ_CLK_I2C2_DIV ] =imx_clk_divider2 ("i2c2_div" ,"i2c2_pre_div" , base +0xad80 ,0 ,6 ); + clks[IMX8MQ_CLK_I2C3_DIV ] =imx_clk_divider2 ("i2c3_div" ,"i2c3_pre_div" , base +0xae00 ,0 ,6 ); + clks[IMX8MQ_CLK_I2C4_DIV ] =imx_clk_divider2 ("i2c4_div" ,"i2c4_pre_div" , base +0xae80 ,0 ,6 ); + clks[IMX8MQ_CLK_UART1_DIV ] =imx_clk_divider2 ("uart1_div" ,"uart1_pre_div" , base +0xaf00 ,0 ,6 ); + clks[IMX8MQ_CLK_UART2_DIV ] =imx_clk_divider2 ("uart2_div" ,"uart2_pre_div" , base +0xaf80 ,0 ,6 ); + clks[IMX8MQ_CLK_UART3_DIV ] =imx_clk_divider2 ("uart3_div" ,"uart3_pre_div" , base +0xb000 ,0 ,6 ); + clks[IMX8MQ_CLK_UART4_DIV ] =imx_clk_divider2 ("uart4_div" ,"uart4_pre_div" , base +0xb080 ,0 ,6 ); + clks[IMX8MQ_CLK_USB_CORE_REF_DIV ] =imx_clk_divider2 ("usb_core_ref_div" ,"usb_core_ref_pre_div" , base +0xb100 ,0 ,6 ); + clks[IMX8MQ_CLK_USB_PHY_REF_DIV ] =imx_clk_divider2 ("usb_phy_ref_div" ,"usb_phy_ref_pre_div" , base +0xb180 ,0 ,6 ); + clks[IMX8MQ_CLK_ECSPI1_DIV ] =imx_clk_divider2 ("ecspi1_div" ,"ecspi1_pre_div" , base +0xb280 ,0 ,6 ); + clks[IMX8MQ_CLK_ECSPI2_DIV ] =imx_clk_divider2 ("ecspi2_div" ,"ecspi2_pre_div" , base +0xb300 ,0 ,6 ); + clks[IMX8MQ_CLK_PWM1_DIV ] =imx_clk_divider2 ("pwm1_div" ,"pwm1_pre_div" , base +0xb380 ,0 ,6 ); + clks[IMX8MQ_CLK_PWM2_DIV ] =imx_clk_divider2 ("pwm2_div" ,"pwm2_pre_div" , base +0xb400 ,0 ,6 ); + clks[IMX8MQ_CLK_PWM3_DIV ] =imx_clk_divider2 ("pwm3_div" ,"pwm3_pre_div" , base +0xb480 ,0 ,6 ); + clks[IMX8MQ_CLK_PWM4_DIV ] =imx_clk_divider2 ("pwm4_div" ,"pwm4_pre_div" , base +0xb500 ,0 ,6 ); + clks[IMX8MQ_CLK_GPT1_DIV ] =imx_clk_divider2 ("gpt1_div" ,"gpt1_pre_div" , base +0xb580 ,0 ,6 ); + clks[IMX8MQ_CLK_WDOG_DIV ] =imx_clk_divider2 ("wdog_div" ,"wdog_pre_div" , base +0xb900 ,0 ,6 ); + clks[IMX8MQ_CLK_WRCLK_DIV ] =imx_clk_divider2 ("wrclk_div" ,"wrclk_pre_div" , base +0xb980 ,0 ,6 ); + clks[IMX8MQ_CLK_CLKO2_DIV ] =imx_clk_divider2 ("clko2_div" ,"clko2_pre_div" , base +0xba80 ,0 ,6 ); + clks[IMX8MQ_CLK_DSI_CORE_DIV ] =imx_clk_divider2 ("dsi_core_div" ,"dsi_core_pre_div" , base +0xbb00 ,0 ,6 ); + clks[IMX8MQ_CLK_DSI_PHY_REF_DIV ] =imx_clk_divider2 ("dsi_phy_ref_div" ,"dsi_phy_ref_pre_div" , base +0xbb80 ,0 ,6 ); + clks[IMX8MQ_CLK_DSI_DBI_DIV ] =imx_clk_divider2 ("dsi_dbi_div" ,"dsi_dbi_pre_div" , base +0xbc00 ,0 ,6 ); + clks[IMX8MQ_CLK_DSI_ESC_DIV ] =imx_clk_divider2 ("dsi_esc_div" ,"dsi_esc_pre_div" , base +0xbc80 ,0 ,6 ); + clks[IMX8MQ_CLK_DSI_AHB_DIV ] =imx_clk_divider2 ("dsi_ahb_div" ,"dsi_ahb_pre_div" , base +0x9200 ,0 ,6 ); + clks[IMX8MQ_CLK_DSI_IPG_DIV ] =imx_clk_divider2 ("dsi_ipg_div" ,"dsi_ahb_div" , base +0x9280 ,0 ,6 ); + clks[IMX8MQ_CLK_CSI1_CORE_DIV ] =imx_clk_divider2 ("csi1_core_div" ,"csi1_core_pre_div" , base +0xbd00 ,0 ,6 ); + clks[IMX8MQ_CLK_CSI1_PHY_REF_DIV ] =imx_clk_divider2 ("csi1_phy_ref_div" ,"csi1_phy_ref_pre_div" , base +0xbd80 ,0 ,6 );
drivers/clk/imx/clk-imx8mq.c line 761
Quoted 10 lines
drivers/clk/imx/clk-imx8mq.c new file +10
-0+ clks[IMX8MQ_CLK_CSI1_ESC_DIV ] =imx_clk_divider2 ("csi1_esc_div" ,"csi1_esc_pre_div" , base +0xbe00 ,0 ,6 ); + clks[IMX8MQ_CLK_CSI2_CORE_DIV ] =imx_clk_divider2 ("csi2_core_div" ,"csi2_core_pre_div" , base +0xbe80 ,0 ,6 ); + clks[IMX8MQ_CLK_CSI2_PHY_REF_DIV ] =imx_clk_divider2 ("csi2_phy_ref_div" ,"csi2_phy_ref_pre_div" , base +0xbf00 ,0 ,6 ); + clks[IMX8MQ_CLK_CSI2_ESC_DIV ] =imx_clk_divider2 ("csi2_esc_div" ,"csi2_esc_pre_div" , base +0xbf80 ,0 ,6 ); + clks[IMX8MQ_CLK_PCIE2_CTRL_DIV ] =imx_clk_divider2 ("pcie2_ctrl_div" ,"pcie2_ctrl_pre_div" , base +0xc000 ,0 ,6 ); + clks[IMX8MQ_CLK_PCIE2_PHY_DIV ] =imx_clk_divider2 ("pcie2_phy_div" ,"pcie2_phy_pre_div" , base +0xc080 ,0 ,6 ); + clks[IMX8MQ_CLK_PCIE2_AUX_DIV ] =imx_clk_divider2 ("pcie2_aux_div" ,"pcie2_aux_pre_div" , base +0xc100 ,0 ,6 ); + clks[IMX8MQ_CLK_ECSPI3_DIV ] =imx_clk_divider2 ("ecspi3_div" ,"ecspi3_pre_div" , base +0xc180 ,0 ,6 ); + +/*FIXME, the doc is not ready now */
The comment is very vague. What stuff need to be fixed? What info are missing from the doc?
Shawn
Quoted 185 lines
drivers/clk/imx/clk-imx8mq.c new file +100
-0+ clks[IMX8MQ_CLK_ECSPI1_ROOT ] =imx_clk_gate4 ("ecspi1_root_clk" ,"ecspi1_div" , base +0x4070 ,0 ); + clks[IMX8MQ_CLK_ECSPI2_ROOT ] =imx_clk_gate4 ("ecspi2_root_clk" ,"ecspi2_div" , base +0x4080 ,0 ); + clks[IMX8MQ_CLK_ECSPI3_ROOT ] =imx_clk_gate4 ("ecspi3_root_clk" ,"ecspi3_div" , base +0x4090 ,0 ); + clks[IMX8MQ_CLK_ENET1_ROOT ] =imx_clk_gate4 ("enet1_root_clk" ,"enet_axi_div" , base +0x40a0 ,0 ); + clks[IMX8MQ_CLK_GPT1_ROOT ] =imx_clk_gate4 ("gpt1_root_clk" ,"gpt1_div" , base +0x4100 ,0 ); + clks[IMX8MQ_CLK_I2C1_ROOT ] =imx_clk_gate4 ("i2c1_root_clk" ,"i2c1_div" , base +0x4170 ,0 ); + clks[IMX8MQ_CLK_I2C2_ROOT ] =imx_clk_gate4 ("i2c2_root_clk" ,"i2c2_div" , base +0x4180 ,0 ); + clks[IMX8MQ_CLK_I2C3_ROOT ] =imx_clk_gate4 ("i2c3_root_clk" ,"i2c3_div" , base +0x4190 ,0 ); + clks[IMX8MQ_CLK_I2C4_ROOT ] =imx_clk_gate4 ("i2c4_root_clk" ,"i2c4_div" , base +0x41a0 ,0 ); + clks[IMX8MQ_CLK_MU_ROOT ] =imx_clk_gate4 ("mu_root_clk" ,"ipg_root" , base +0x4210 ,0 ); + clks[IMX8MQ_CLK_OCOTP_ROOT ] =imx_clk_gate4 ("ocotp_root_clk" ,"ipg_root" , base +0x4220 ,0 ); + clks[IMX8MQ_CLK_PCIE1_ROOT ] =imx_clk_gate4 ("pcie1_root_clk" ,"pcie1_ctrl_div" , base +0x4250 ,0 ); + clks[IMX8MQ_CLK_PCIE2_ROOT ] =imx_clk_gate4 ("pcie2_root_clk" ,"pcie2_ctrl_div" , base +0x4640 ,0 ); + clks[IMX8MQ_CLK_PWM1_ROOT ] =imx_clk_gate4 ("pwm1_root_clk" ,"pwm1_div" , base +0x4280 ,0 ); + clks[IMX8MQ_CLK_PWM2_ROOT ] =imx_clk_gate4 ("pwm2_root_clk" ,"pwm2_div" , base +0x4290 ,0 ); + clks[IMX8MQ_CLK_PWM3_ROOT ] =imx_clk_gate4 ("pwm3_root_clk" ,"pwm3_div" , base +0x42a0 ,0 ); + clks[IMX8MQ_CLK_PWM4_ROOT ] =imx_clk_gate4 ("pwm4_root_clk" ,"pwm4_div" , base +0x42b0 ,0 ); + clks[IMX8MQ_CLK_QSPI_ROOT ] =imx_clk_gate4 ("qspi_root_clk" ,"qspi_div" , base +0x42f0 ,0 ); + clks[IMX8MQ_CLK_RAWNAND_ROOT ] =imx_clk_gate2_shared2 ("nand_root_clk" ,"nand_div" , base +0x4300 ,0 , &share_count_nand); + clks[IMX8MQ_CLK_NAND_USDHC_BUS_RAWNAND_CLK ] =imx_clk_gate2_shared2 ("nand_usdhc_rawnand_clk" ,"nand_usdhc_bus_div" , base +0x4300 ,0 , &share_count_nand); + clks[IMX8MQ_CLK_SAI1_ROOT ] =imx_clk_gate2_shared2 ("sai1_root_clk" ,"sai1_div" , base +0x4330 ,0 , &share_count_sai1); + clks[IMX8MQ_CLK_SAI1_IPG ] =imx_clk_gate2_shared2 ("sai1_ipg_clk" ,"ipg_audio_root" , base +0x4330 ,0 , &share_count_sai1); + clks[IMX8MQ_CLK_SAI2_ROOT ] =imx_clk_gate2_shared2 ("sai2_root_clk" ,"sai2_div" , base +0x4340 ,0 , &share_count_sai2); + clks[IMX8MQ_CLK_SAI2_IPG ] =imx_clk_gate2_shared2 ("sai2_ipg_clk" ,"ipg_root" , base +0x4340 ,0 , &share_count_sai2); + clks[IMX8MQ_CLK_SAI3_ROOT ] =imx_clk_gate2_shared2 ("sai3_root_clk" ,"sai3_div" , base +0x4350 ,0 , &share_count_sai3); + clks[IMX8MQ_CLK_SAI3_IPG ] =imx_clk_gate2_shared2 ("sai3_ipg_clk" ,"ipg_root" , base +0x4350 ,0 , &share_count_sai3); + clks[IMX8MQ_CLK_SAI4_ROOT ] =imx_clk_gate2_shared2 ("sai4_root_clk" ,"sai4_div" , base +0x4360 ,0 , &share_count_sai4); + clks[IMX8MQ_CLK_SAI4_IPG ] =imx_clk_gate2_shared2 ("sai4_ipg_clk" ,"ipg_audio_root" , base +0x4360 ,0 , &share_count_sai4); + clks[IMX8MQ_CLK_SAI5_ROOT ] =imx_clk_gate2_shared2 ("sai5_root_clk" ,"sai5_div" , base +0x4370 ,0 , &share_count_sai5); + clks[IMX8MQ_CLK_SAI5_IPG ] =imx_clk_gate2_shared2 ("sai5_ipg_clk" ,"ipg_audio_root" , base +0x4370 ,0 , &share_count_sai5); + clks[IMX8MQ_CLK_SAI6_ROOT ] =imx_clk_gate2_shared2 ("sai6_root_clk" ,"sai6_div" , base +0x4380 ,0 , &share_count_sai6); + clks[IMX8MQ_CLK_SAI6_IPG ] =imx_clk_gate2_shared2 ("sai6_ipg_clk" ,"ipg_audio_root" , base +0x4380 ,0 , &share_count_sai6); + clks[IMX8MQ_CLK_UART1_ROOT ] =imx_clk_gate4 ("uart1_root_clk" ,"uart1_div" , base +0x4490 ,0 ); + clks[IMX8MQ_CLK_UART2_ROOT ] =imx_clk_gate4 ("uart2_root_clk" ,"uart2_div" , base +0x44a0 ,0 ); + clks[IMX8MQ_CLK_UART3_ROOT ] =imx_clk_gate4 ("uart3_root_clk" ,"uart3_div" , base +0x44b0 ,0 ); + clks[IMX8MQ_CLK_UART4_ROOT ] =imx_clk_gate4 ("uart4_root_clk" ,"uart4_div" , base +0x44c0 ,0 ); + clks[IMX8MQ_CLK_USB1_CTRL_ROOT ] =imx_clk_gate4 ("usb1_ctrl_root_clk" ,"usb_core_ref_div" , base +0x44d0 ,0 ); + clks[IMX8MQ_CLK_USB2_CTRL_ROOT ] =imx_clk_gate4 ("usb2_ctrl_root_clk" ,"usb_core_ref_div" , base +0x44e0 ,0 ); + clks[IMX8MQ_CLK_USB1_PHY_ROOT ] =imx_clk_gate4 ("usb1_phy_root_clk" ,"usb_phy_ref_div" , base +0x44f0 ,0 ); + clks[IMX8MQ_CLK_USB2_PHY_ROOT ] =imx_clk_gate4 ("usb2_phy_root_clk" ,"usb_phy_ref_div" , base +0x4500 ,0 ); + clks[IMX8MQ_CLK_USDHC1_ROOT ] =imx_clk_gate4 ("usdhc1_root_clk" ,"usdhc1_div" , base +0x4510 ,0 ); + clks[IMX8MQ_CLK_USDHC2_ROOT ] =imx_clk_gate4 ("usdhc2_root_clk" ,"usdhc2_div" , base +0x4520 ,0 ); + clks[IMX8MQ_CLK_WDOG1_ROOT ] =imx_clk_gate4 ("wdog1_root_clk" ,"wdog_div" , base +0x4530 ,0 ); + clks[IMX8MQ_CLK_WDOG2_ROOT ] =imx_clk_gate4 ("wdog2_root_clk" ,"wdog_div" , base +0x4540 ,0 ); + clks[IMX8MQ_CLK_WDOG3_ROOT ] =imx_clk_gate4 ("wdog3_root_clk" ,"wdog_div" , base +0x4550 ,0 ); + clks[IMX8MQ_CLK_VPU_G1_ROOT ] =imx_clk_gate2_flags ("vpu_g1_root_clk" ,"vpu_g1_div" , base +0x4560 ,0 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_GPU_ROOT ] =imx_clk_gate4 ("gpu_root_clk" ,"gpu_core_div" , base +0x4570 ,0 ); + clks[IMX8MQ_CLK_VPU_G2_ROOT ] =imx_clk_gate2_flags ("vpu_g2_root_clk" ,"vpu_g2_div" , base +0x45a0 ,0 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_DISP_ROOT ] =imx_clk_gate2_shared2 ("disp_root_clk" ,"disp_dc8000_div" , base +0x45d0 ,0 , &share_count_dcss); + clks[IMX8MQ_CLK_DISP_AXI_ROOT ] =imx_clk_gate2_shared2 ("disp_axi_root_clk" ,"disp_axi_div" , base +0x45d0 ,0 , &share_count_dcss); + clks[IMX8MQ_CLK_DISP_APB_ROOT ] =imx_clk_gate2_shared2 ("disp_apb_root_clk" ,"disp_apb_div" , base +0x45d0 ,0 , &share_count_dcss); + clks[IMX8MQ_CLK_DISP_RTRM_ROOT ] =imx_clk_gate2_shared2 ("disp_rtrm_root_clk" ,"disp_rtrm_div" , base +0x45d0 ,0 , &share_count_dcss); + clks[IMX8MQ_CLK_TMU_ROOT ] =imx_clk_gate4_flags ("tmu_root_clk" ,"ipg_root" , base +0x4620 ,0 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_VPU_DEC_ROOT ] =imx_clk_gate2_flags ("vpu_dec_root_clk" ,"vpu_bus_div" , base +0x4630 ,0 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_CSI1_ROOT ] =imx_clk_gate4 ("csi1_root_clk" ,"csi1_core_div" , base +0x4650 ,0 ); + clks[IMX8MQ_CLK_CSI2_ROOT ] =imx_clk_gate4 ("csi2_root_clk" ,"csi2_core_div" , base +0x4660 ,0 ); + clks[IMX8MQ_CLK_SDMA1_ROOT ] =imx_clk_gate4 ("sdma1_clk" ,"ipg_root" , base +0x43a0 ,0 ); + clks[IMX8MQ_CLK_SDMA2_ROOT ] =imx_clk_gate4 ("sdma2_clk" ,"ipg_audio_root" , base +0x43b0 ,0 ); + + clks[IMX8MQ_GPT_3M_CLK ] =imx_clk_fixed_factor ("gpt_3m" ,"osc_25m" ,1 ,8 ); + clks[IMX8MQ_CLK_DRAM_ALT_ROOT ] =imx_clk_fixed_factor ("dram_alt_root" ,"dram_alt_div" ,1 ,4 ); + +for (i =0 ; i <IMX8MQ_CLK_END ; i++) +if (IS_ERR (clks[i])) +pr_err ("i.MX8mq clk %u register failed with %ld\n" , + i,PTR_ERR (clks[i])); + + clk_data.clks = clks; + clk_data.clk_num =ARRAY_SIZE (clks); +of_clk_add_provider (np, of_clk_src_onecell_get, &clk_data); + +clk_set_parent (clks[IMX8MQ_VIDEO2_PLL1_OUT ], clks[IMX8MQ_VIDEO2_PLL1 ]); +clk_set_parent (clks[IMX8MQ_VIDEO2_PLL2_OUT ], clks[IMX8MQ_VIDEO2_PLL2_DIV ]); + +clk_set_parent (clks[IMX8MQ_CLK_AHB_SRC ], clks[IMX8MQ_SYS1_PLL_133M ]); +clk_set_parent (clks[IMX8MQ_CLK_NAND_USDHC_BUS_SRC ], clks[IMX8MQ_SYS1_PLL_266M ]); +clk_set_parent (clks[IMX8MQ_CLK_AUDIO_AHB_SRC ], clks[IMX8MQ_SYS2_PLL_500M ]); + +/* config video_pll1 clock */ +clk_set_parent (clks[IMX8MQ_VIDEO_PLL1_REF_SEL ], clks[IMX8MQ_CLK_27M ]); +clk_set_rate (clks[IMX8MQ_VIDEO_PLL1 ],593999999 ); + +/* increase NOC clock to achieve best DDR access performance */ +clk_set_rate (clks[IMX8MQ_CLK_NOC_DIV ],clk_get_rate (clks[IMX8MQ_SYS1_PLL_800M ])); + +/* set pcie root's parent clk source */ +clk_set_parent (clks[IMX8MQ_CLK_PCIE1_CTRL_SRC ], clks[IMX8MQ_SYS2_PLL_250M ]); +clk_set_parent (clks[IMX8MQ_CLK_PCIE1_PHY_SRC ], clks[IMX8MQ_SYS2_PLL_100M ]); +clk_set_parent (clks[IMX8MQ_CLK_PCIE2_CTRL_SRC ], clks[IMX8MQ_SYS2_PLL_250M ]); +clk_set_parent (clks[IMX8MQ_CLK_PCIE2_PHY_SRC ], clks[IMX8MQ_SYS2_PLL_100M ]); + +clk_set_parent (clks[IMX8MQ_CLK_CSI1_CORE_SRC ], clks[IMX8MQ_SYS1_PLL_266M ]); +clk_set_parent (clks[IMX8MQ_CLK_CSI1_PHY_REF_SRC ], clks[IMX8MQ_SYS2_PLL_1000M ]); +clk_set_parent (clks[IMX8MQ_CLK_CSI1_ESC_SRC ], clks[IMX8MQ_SYS1_PLL_800M ]); +clk_set_parent (clks[IMX8MQ_CLK_CSI2_CORE_SRC ], clks[IMX8MQ_SYS1_PLL_266M ]); +clk_set_parent (clks[IMX8MQ_CLK_CSI2_PHY_REF_SRC ], clks[IMX8MQ_SYS2_PLL_1000M ]); +clk_set_parent (clks[IMX8MQ_CLK_CSI2_ESC_SRC ], clks[IMX8MQ_SYS1_PLL_800M ]); +} + +CLK_OF_DECLARE (imx8mq,"fsl,imx8mq-ccm" , imx8mq_clocks_init);drivers/clk/imx/clk.h +43
-0@@ -128,6 +128,15 @@ static inline struct clk *imx_clk_divider2(const char *name, const char *parent, reg, shift, width, 0, &imx_ccm_lock); } +static inline struct clk *imx_clk_divider2_flags (const char *name, +const char *parent,void __iomem *reg,u8 shift,u8 width, +unsigned long flags) +{ +return clk_register_divider (NULL , name, parent, + flags |CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE , + reg, shift, width,0 , &imx_ccm_lock); +} +static inline struct clk *imx_clk_gate (const char *name,const char *parent,void __iomem *reg,u8 shift) {@@ -149,6 +158,13 @@ static inline struct clk *imx_clk_gate2(const char *name, const char *parent, shift, 0x3, 0, &imx_ccm_lock, NULL); } +static inline struct clk *imx_clk_gate2_flags (const char *name,const char *parent, +void __iomem *reg,u8 shift,unsigned long flags) +{ +return clk_register_gate2 (NULL , name, parent, flags, reg, + shift,0x3 ,0 , &imx_ccm_lock,NULL ); +} +static inline struct clk *imx_clk_gate2_shared (const char *name,const char *parent,void __iomem *reg,u8 shift,unsigned int *share_count)@@ -181,6 +197,15 @@ static inline struct clk *imx_clk_gate3(const char *name, const char *parent, reg, shift, 0, &imx_ccm_lock); } +static inline struct clk *imx_clk_gate3_flags (const char *name, +const char *parent,void __iomem *reg,u8 shift, +unsigned long flags) +{ +return clk_register_gate (NULL , name, parent, + flags |CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE , + reg, shift,0 , &imx_ccm_lock); +} +static inline struct clk *imx_clk_gate4 (const char *name,const char *parent,void __iomem *reg,u8 shift) {@@ -189,6 +214,15 @@ static inline struct clk *imx_clk_gate4(const char *name, const char *parent, reg, shift, 0x3, 0, &imx_ccm_lock, NULL); } +static inline struct clk *imx_clk_gate4_flags (const char *name, +const char *parent,void __iomem *reg,u8 shift, +unsigned long flags) +{ +return clk_register_gate2 (NULL , name, parent, + flags |CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE , + reg, shift,0x3 ,0 , &imx_ccm_lock,NULL ); +} +static inline struct clk *imx_clk_mux (const char *name,void __iomem *reg,u8 shift,u8 width,const char **parents,int num_parents) {@@ -214,6 +248,15 @@ static inline struct clk *imx_clk_mux_flags(const char *name, &imx_ccm_lock); } +static inline struct clk *imx_clk_mux2_flags (const char *name, +void __iomem *reg,u8 shift,u8 width,const char **parents, +int num_parents,unsigned long flags) +{ +return clk_register_mux (NULL , name, parents, num_parents, + flags |CLK_SET_RATE_NO_REPARENT |CLK_OPS_PARENT_ENABLE , + reg, shift, width,0 , &imx_ccm_lock); +} +struct clk *imx_clk_cpu (const char *name,const char *parent_name,struct clk *div,struct clk *mux,struct clk *pll,struct clk *step);Signature · 1 line
2.15.1
PATCH v2 4/4 clk: imx: add clock driver for i.MX8MQ CCM
In reply to Lucas Stachdrivers/clk/imx/clk-imx8mq.c line 827
Quoted 4 lines · Lucas Stach
drivers/clk/imx/clk-imx8mq.c new file +4
-0+for (i =0 ; i <IMX8MQ_CLK_END ; i++) +if (IS_ERR (clks[i])) +pr_err ("i.MX8mq clk %u register failed with %ld\n" , + i,PTR_ERR (clks[i]));
We have a helper imx_check_clocks() for this.
Shawn
PATCH v2 4/4 clk: imx: add clock driver for i.MX8MQ CCM
In reply to Lucas StachQuoted 73 lines · Lucas Stach
Add driver for the Clock Control Module found on i.MX8MQ.
This is largely based on the downstream driver from Anson Huang and Bai Ping at NXP, with only some small adaptions to mainline from me.
Signed-off-by Lucas Stach <[email protected]>---
v2: switchvendor prefixes to fsl--- drivers/clk/imx/Makefile | 1 + drivers/clk/imx/clk-imx8mq.c | 861 +++++++++++++++++++++++++++++++++++++++++++ drivers/clk/imx/clk.h | 43 +++ 3 files changed, 905 insertions(+) create mode 100644 drivers/clk/imx/clk-imx8mq.cdrivers/clk/imx/Makefile +1
-0@@ -28,3 +28,4 @@ obj-$(CONFIG_SOC_IMX6SX) += clk-imx6sx.o obj-$(CONFIG_SOC_IMX6UL) += clk-imx6ul.o obj-$(CONFIG_SOC_IMX7D) += clk-imx7d.o obj-$(CONFIG_SOC_VF610) += clk-vf610.o +obj-$(CONFIG_SOC_IMX8MQ) += clk-imx8mq.odrivers/clk/imx/clk-imx8mq.c new file +43
-0@@ -0,0 +1,861 @@ +/* +* Copyright 2017 NXP. +* +* The code contained herein is licensed under the GNU General Public +* License. You may obtain a copy of the GNU General Public License +* Version 2 or later at the following locations: +* +* http://www.opensource.org/licenses/gpl-license.html +* http://www.gnu.org/copyleft/gpl.html +*/ + +#include <dt-bindings/clock/imx8mq-clock.h> +#include <linux/clk.h> +#include <linux/clkdev.h> +#include <linux/err.h> +#include <linux/init.h> +#include <linux/io.h> +#include <linux/of.h> +#include <linux/of_address.h> +#include <linux/of_irq.h> +#include <linux/types.h> + +#include "clk.h" + +static u32 share_count_sai1; +static u32 share_count_sai2; +static u32 share_count_sai3; +static u32 share_count_sai4; +static u32 share_count_sai5; +static u32 share_count_sai6; +static u32 share_count_dcss; +static u32 share_count_nand; + +static struct clk *clks[IMX8MQ_CLK_END ]; + +static const char *pll_ref_sels[] = {"osc_25m" ,"osc_27m" ,"dummy" ,"dummy" , }; +static const char *arm_pll_bypass_sels[] = {"arm_pll" ,"arm_pll_ref_sel" , }; +static const char *gpu_pll_bypass_sels[] = {"gpu_pll" ,"gpu_pll_ref_sel" , }; +static const char *vpu_pll_bypass_sels[] = {"vpu_pll" ,"vpu_pll_ref_sel" , }; +static const char *audio_pll1_bypass_sels[] = {"audio_pll1" ,"audio_pll1_ref_sel" , }; +static const char *audio_pll2_bypass_sels[] = {"audio_pll2" ,"audio_pll2_ref_sel" , }; +static const char *video_pll1_bypass_sels[] = {"video_pll1" ,"video_pll1_ref_sel" , }; +
drivers/clk/imx/clk-imx8mq.c line 53
Quoted 10 lines
drivers/clk/imx/clk-imx8mq.c new file +10
-0+static const char *sys1_pll1_out_sels[] = {"sys1_pll1" ,"sys1_pll1_ref_sel" , }; +static const char *sys2_pll1_out_sels[] = {"sys2_pll1" ,"sys1_pll1_ref_sel" , }; +static const char *sys3_pll1_out_sels[] = {"sys3_pll1" ,"sys3_pll1_ref_sel" , }; +static const char *dram_pll1_out_sels[] = {"dram_pll1" ,"dram_pll1_ref_sel" , }; +static const char *video2_pll1_out_sels[] = {"video2_pll1" ,"video2_pll1_ref_sel" , }; + +static const char *sys1_pll2_out_sels[] = {"sys1_pll2_div" ,"sys1_pll1_ref_sel" , }; +static const char *sys2_pll2_out_sels[] = {"sys2_pll2_div" ,"sys2_pll1_ref_sel" , }; +static const char *sys3_pll2_out_sels[] = {"sys3_pll2_div" ,"sys2_pll1_ref_sel" , }; +static const char *dram_pll2_out_sels[] = {"dram_pll2_div" ,"dram_pll1_ref_sel" , };
here is a bit strange.
As i mentioned in sscg pll patch review, we probably should not introduce an extra divider at here.
Quoted 224 lines
drivers/clk/imx/clk-imx8mq.c new file +224
-0+static const char *video2_pll2_out_sels[] = {"video2_pll2_div" ,"video2_pll1_ref_sel" , }; + +/* CCM ROOT */ +static const char *imx8mq_a53_sels[] = {"osc_25m" ,"arm_pll_out" ,"sys2_pll_500m" ,"sys2_pll_1000m" , +"sys1_pll_800m" ,"sys1_pll_400m" ,"audio_pll1_out" ,"sys3_pll2_out" , }; + +static const char *imx8mq_vpu_sels[] = {"osc_25m" ,"arm_pll_out" ,"sys2_pll_500m" ,"sys2_pll_1000m" , +"sys1_pll_800m" ,"sys1_pll_400m" ,"audio_pll1_out" ,"vpu_pll_out" , }; + +static const char *imx8mq_gpu_core_sels[] = {"osc_25m" ,"gpu_pll_out" ,"sys1_pll_800m" ,"sys3_pll2_out" , +"sys2_pll_1000m" ,"audio_pll1_out" ,"video_pll1_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_gpu_shader_sels[] = {"osc_25m" ,"gpu_pll_out" ,"sys1_pll_800m" ,"sys3_pll2_out" , +"sys2_pll_1000m" ,"audio_pll1_out" ,"video_pll1_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_main_axi_sels[] = {"osc_25m" ,"sys2_pll_333m" ,"sys1_pll_800m" ,"sys2_pll_250m" , +"sys2_pll_1000m" ,"audio_pll1_out" ,"video_pll1_out" ,"sys1_pll_100m" ,}; + +static const char *imx8mq_enet_axi_sels[] = {"osc_25m" ,"sys1_pll_266m" ,"sys1_pll_800m" ,"sys2_pll_250m" , +"sys2_pll_200m" ,"audio_pll1_out" ,"video_pll1_out" ,"sys3_pll2_out" , }; + +static const char *imx8mq_nand_usdhc_sels[] = {"osc_25m" ,"sys1_pll_266m" ,"sys1_pll_800m" ,"sys2_pll_200m" , +"sys1_pll_133m" ,"sys3_pll2_out" ,"sys2_pll_250m" ,"audio_pll1_out" , }; + +static const char *imx8mq_vpu_bus_sels[] = {"osc_25m" ,"sys1_pll_800m" ,"vpu_pll_out" ,"audio_pll2_out" ,"sys3_pll2_out" ,"sys2_pll_1000m" ,"sys2_pll_200m" ,"sys1_pll_100m" , }; + +static const char *imx8mq_disp_axi_sels[] = {"osc_25m" ,"sys2_pll_125m" ,"sys1_pll_800m" ,"sys3_pll2_out" ,"sys1_pll_400m" ,"audio_pll2_out" ,"clk_ext1" ,"clk_ext4" , }; + +static const char *imx8mq_disp_apb_sels[] = {"osc_25m" ,"sys2_pll_125m" ,"sys1_pll_800m" ,"sys3_pll2_out" , +"sys1_pll_40m" ,"audio_pll2_out" ,"clk_ext1" ,"clk_ext3" , }; + +static const char *imx8mq_disp_rtrm_sels[] = {"osc_25m" ,"sys1_pll_800m" ,"sys2_pll_200m" ,"sys1_pll_400m" , +"audio_pll1_out" ,"video_pll1_out" ,"clk_ext2" ,"clk_ext3" , }; + +static const char *imx8mq_usb_bus_sels[] = {"osc_25m" ,"sys2_pll_500m" ,"sys1_pll_800m" ,"sys2_pll_100m" , +"sys2_pll_200m" ,"clk_ext2" ,"clk_ext4" ,"audio_pll2_out" , }; + +static const char *imx8mq_gpu_axi_sels[] = {"osc_25m" ,"sys1_pll_800m" ,"gpu_pll_out" ,"sys3_pll2_out" ,"sys2_pll_1000m" , +"audio_pll1_out" ,"video_pll1_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_gpu_ahb_sels[] = {"osc_25m" ,"sys1_pll_800m" ,"gpu_pll_out" ,"sys3_pll2_out" ,"sys2_pll_1000m" , +"audio_pll1_out" ,"video_pll1_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_noc_sels[] = {"osc_25m" ,"sys1_pll_800m" ,"sys3_pll2_out" ,"sys2_pll_1000m" ,"sys2_pll_500m" , +"audio_pll1_out" ,"video_pll1_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_noc_apb_sels[] = {"osc_25m" ,"sys1_pll_400m" ,"sys3_pll2_out" ,"sys2_pll_333m" ,"sys2_pll_200m" , +"sys1_pll_800m" ,"audio_pll1_out" ,"video_pll1_out" , }; + +static const char *imx8mq_ahb_sels[] = {"osc_25m" ,"sys1_pll_133m" ,"sys1_pll_800m" ,"sys1_pll_400m" , +"sys2_pll_125m" ,"sys3_pll2_out" ,"audio_pll1_out" ,"video_pll1_out" , }; + +static const char *imx8mq_audio_ahb_sels[] = {"osc_25m" ,"sys2_pll_500m" ,"sys1_pll_800m" ,"sys2_pll_1000m" , +"sys2_pll_166m" ,"sys3_pll2_out" ,"audio_pll1_out" ,"video_pll1_out" , }; + +static const char *imx8mq_dsi_ahb_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_80m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"clk_ext3" ,"audio_pll2_out" }; + +static const char *imx8mq_dram_alt_sels[] = {"osc_25m" ,"sys1_pll_800m" ,"sys1_pll_100m" ,"sys2_pll_500m" , +"sys2_pll_250m" ,"sys1_pll_400m" ,"audio_pll1_out" ,"sys1_pll_266m" , }; + +static const char *imx8mq_dram_apb_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys1_pll_40m" ,"sys1_pll_160m" , +"sys1_pll_800m" ,"sys3_pll2_out" ,"sys2_pll_250m" ,"audio_pll2_out" , }; + +static const char *imx8mq_vpu_g1_sels[] = {"osc_25m" ,"vpu_pll_out" ,"sys1_pll_800m" ,"sys2_pll_1000m" ,"sys1_pll_100m" ,"sys2_pll_125m" ,"sys3_pll2_out" ,"audio_pll1_out" , }; + +static const char *imx8mq_vpu_g2_sels[] = {"osc_25m" ,"vpu_pll_out" ,"sys1_pll_800m" ,"sys2_pll_1000m" ,"sys1_pll_100m" ,"sys2_pll_125m" ,"sys3_pll2_out" ,"audio_pll1_out" , }; + +static const char *imx8mq_disp_dtrc_sels[] = {"osc_25m" ,"vpu_pll_out" ,"sys1_pll_800m" ,"sys2_pll_1000m" ,"sys1_pll_160m" ,"sys2_pll_100m" ,"sys3_pll2_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_disp_dc8000_sels[] = {"osc_25m" ,"vpu_pll_out" ,"sys1_pll_800m" ,"sys2_pll_1000m" ,"sys1_pll_160m" ,"sys2_pll_100m" ,"sys3_pll2_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_pcie1_ctrl_sels[] = {"osc_25m" ,"sys2_pll_250m" ,"sys2_pll_200m" ,"sys1_pll_266m" , +"sys1_pll_800m" ,"sys2_pll_500m" ,"sys2_pll_250m" ,"sys3_pll2_out" , }; + +static const char *imx8mq_pcie1_phy_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys2_pll_500m" ,"clk_ext1" ,"clk_ext2" , +"clk_ext3" ,"clk_ext4" , }; + +static const char *imx8mq_pcie1_aux_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys2_pll_500m" ,"sys3_pll2_out" , +"sys2_pll_100m" ,"sys1_pll_80m" ,"sys1_pll_160m" ,"sys1_pll_200m" , }; + +static const char *imx8mq_dc_pixel_sels[] = {"osc_25m" ,"video_pll1_out" ,"audio_pll2_out" ,"audio_pll1_out" ,"sys1_pll_800m" ,"sys2_pll_1000m" ,"sys3_pll2_out" ,"clk_ext4" , }; + +static const char *imx8mq_lcdif_pixel_sels[] = {"osc_25m" ,"video_pll1_out" ,"audio_pll2_out" ,"audio_pll1_out" ,"sys1_pll_800m" ,"sys2_pll_1000m" ,"sys3_pll2_out" ,"clk_ext4" , }; + +static const char *imx8mq_sai1_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext1" ,"clk_ext2" , }; + +static const char *imx8mq_sai2_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext2" ,"clk_ext3" , }; + +static const char *imx8mq_sai3_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext3" ,"clk_ext4" , }; + +static const char *imx8mq_sai4_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext1" ,"clk_ext2" , }; + +static const char *imx8mq_sai5_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext2" ,"clk_ext3" , }; + +static const char *imx8mq_sai6_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext3" ,"clk_ext4" , }; + +static const char *imx8mq_spdif1_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext2" ,"clk_ext3" , }; + +static const char *imx8mq_spdif2_sels[] = {"osc_25m" ,"audio_pll1_out" ,"audio_pll2_out" ,"video_pll1_out" ,"sys1_pll_133m" ,"osc_27m" ,"clk_ext3" ,"clk_ext4" , }; + +static const char *imx8mq_enet_ref_sels[] = {"osc_25m" ,"sys2_pll_125m" ,"sys2_pll_500m" ,"sys2_pll_100m" , +"sys1_pll_160m" ,"audio_pll1_out" ,"video_pll1_out" ,"clk_ext4" , }; + +static const char *imx8mq_enet_timer_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"audio_pll1_out" ,"clk_ext1" ,"clk_ext2" , +"clk_ext3" ,"clk_ext4" ,"video_pll1_out" , }; + +static const char *imx8mq_enet_phy_sels[] = {"osc_25m" ,"sys2_pll_50m" ,"sys2_pll_125m" ,"sys2_pll_500m" , +"audio_pll1_out" ,"video_pll1_out" ,"audio_pll2_out" , }; + +static const char *imx8mq_nand_sels[] = {"osc_25m" ,"sys2_pll_500m" ,"audio_pll1_out" ,"sys1_pll_400m" , +"audio_pll2_out" ,"sys3_pll2_out" ,"sys2_pll_250m" ,"video_pll1_out" , }; + +static const char *imx8mq_qspi_sels[] = {"osc_25m" ,"sys1_pll_400m" ,"sys1_pll_800m" ,"sys2_pll_500m" , +"audio_pll2_out" ,"sys1_pll_266m" ,"sys3_pll2_out" ,"sys1_pll_100m" , }; + +static const char *imx8mq_usdhc1_sels[] = {"osc_25m" ,"sys1_pll_400m" ,"sys1_pll_800m" ,"sys2_pll_500m" , +"audio_pll2_out" ,"sys1_pll_266m" ,"sys3_pll2_out" ,"sys1_pll_100m" , }; + +static const char *imx8mq_usdhc2_sels[] = {"osc_25m" ,"sys1_pll_400m" ,"sys1_pll_800m" ,"sys2_pll_500m" , +"audio_pll2_out" ,"sys1_pll_266m" ,"sys3_pll2_out" ,"sys1_pll_100m" , }; + +static const char *imx8mq_i2c1_sels[] = {"osc_25m" ,"sys1_pll_160m" ,"sys2_pll_50m" ,"sys3_pll2_out" ,"audio_pll1_out" , +"video_pll1_out" ,"audio_pll2_out" ,"sys1_pll_133m" , }; + +static const char *imx8mq_i2c2_sels[] = {"osc_25m" ,"sys1_pll_160m" ,"sys2_pll_50m" ,"sys3_pll2_out" ,"audio_pll1_out" , +"video_pll1_out" ,"audio_pll2_out" ,"sys1_pll_133m" , }; + +static const char *imx8mq_i2c3_sels[] = {"osc_25m" ,"sys1_pll_160m" ,"sys2_pll_50m" ,"sys3_pll2_out" ,"audio_pll1_out" , +"video_pll1_out" ,"audio_pll2_out" ,"sys1_pll_133m" , }; + +static const char *imx8mq_i2c4_sels[] = {"osc_25m" ,"sys1_pll_160m" ,"sys2_pll_50m" ,"sys3_pll2_out" ,"audio_pll1_out" , +"video_pll1_out" ,"audio_pll2_out" ,"sys1_pll_133m" , }; + +static const char *imx8mq_uart1_sels[] = {"osc_25m" ,"sys1_pll_80m" ,"sys2_pll_200m" ,"sys2_pll_100m" , +"sys3_pll2_out" ,"clk_ext2" ,"clk_ext4" ,"audio_pll2_out" , }; + +static const char *imx8mq_uart2_sels[] = {"osc_25m" ,"sys1_pll_80m" ,"sys2_pll_200m" ,"sys2_pll_100m" , +"sys3_pll2_out" ,"clk_ext2" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_uart3_sels[] = {"osc_25m" ,"sys1_pll_80m" ,"sys2_pll_200m" ,"sys2_pll_100m" , +"sys3_pll2_out" ,"clk_ext2" ,"clk_ext4" ,"audio_pll2_out" , }; + +static const char *imx8mq_uart4_sels[] = {"osc_25m" ,"sys1_pll_80m" ,"sys2_pll_200m" ,"sys2_pll_100m" , +"sys3_pll2_out" ,"clk_ext2" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_usb_core_sels[] = {"osc_25m" ,"sys1_pll_100m" ,"sys1_pll_40m" ,"sys2_pll_100m" , +"sys2_pll_200m" ,"clk_ext2" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_usb_phy_sels[] = {"osc_25m" ,"sys1_pll_100m" ,"sys1_pll_40m" ,"sys2_pll_100m" , +"sys2_pll_200m" ,"clk_ext2" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_ecspi1_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys1_pll_40m" ,"sys1_pll_160m" , +"sys1_pll_800m" ,"sys3_pll2_out" ,"sys2_pll_250m" ,"audio_pll2_out" , }; + +static const char *imx8mq_ecspi2_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys1_pll_40m" ,"sys1_pll_160m" , +"sys1_pll_800m" ,"sys3_pll2_out" ,"sys2_pll_250m" ,"audio_pll2_out" , }; + +static const char *imx8mq_pwm1_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_160m" ,"sys1_pll_40m" , +"sys3_pll2_out" ,"clk_ext1" ,"sys1_pll_80m" ,"video_pll1_out" , }; + +static const char *imx8mq_pwm2_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_160m" ,"sys1_pll_40m" , +"sys3_pll2_out" ,"clk_ext1" ,"sys1_pll_80m" ,"video_pll1_out" , }; + +static const char *imx8mq_pwm3_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_160m" ,"sys1_pll_40m" , +"sys3_pll2_out" ,"clk_ext2" ,"sys1_pll_80m" ,"video_pll1_out" , }; + +static const char *imx8mq_pwm4_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_160m" ,"sys1_pll_40m" , +"sys3_pll2_out" ,"clk_ext2" ,"sys1_pll_80m" ,"video_pll1_out" , }; + +static const char *imx8mq_gpt1_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_400m" ,"sys1_pll_40m" , +"sys1_pll_80m" ,"audio_pll1_out" ,"clk_ext1" , }; + +static const char *imx8mq_wdog_sels[] = {"osc_25m" ,"sys1_pll_133m" ,"sys1_pll_160m" ,"vpu_pll_out" , +"sys2_pll_125m" ,"sys3_pll2_out" ,"sys1_pll_80m" ,"sys2_pll_166m" , }; + +static const char *imx8mq_wrclk_sels[] = {"osc_25m" ,"sys1_pll_40m" ,"vpu_pll_out" ,"sys3_pll2_out" ,"sys2_pll_200m" , +"sys1_pll_266m" ,"sys2_pll_500m" ,"sys1_pll_100m" , }; + +static const char *imx8mq_dsi_core_sels[] = {"osc_25m" ,"sys1_pll_266m" ,"sys2_pll_250m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_dsi_phy_sels[] = {"osc_25m" ,"sys2_pll_125m" ,"sys2_pll_100m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"clk_ext2" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_dsi_dbi_sels[] = {"osc_25m" ,"sys1_pll_266m" ,"sys2_pll_100m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_dsi_esc_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_80m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_csi1_core_sels[] = {"osc_25m" ,"sys1_pll_266m" ,"sys2_pll_250m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_csi1_phy_sels[] = {"osc_25m" ,"sys2_pll_125m" ,"sys2_pll_100m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"clk_ext2" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_csi1_esc_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_80m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_csi2_core_sels[] = {"osc_25m" ,"sys1_pll_266m" ,"sys2_pll_250m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_csi2_phy_sels[] = {"osc_25m" ,"sys2_pll_125m" ,"sys2_pll_100m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"clk_ext2" ,"audio_pll2_out" ,"video_pll1_out" , }; + +static const char *imx8mq_csi2_esc_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys1_pll_80m" ,"sys1_pll_800m" , +"sys2_pll_1000m" ,"sys3_pll2_out" ,"clk_ext3" ,"audio_pll2_out" , }; + +static const char *imx8mq_pcie2_ctrl_sels[] = {"osc_25m" ,"sys2_pll_250m" ,"sys2_pll_200m" ,"sys1_pll_266m" , +"sys1_pll_800m" ,"sys2_pll_500m" ,"sys2_pll_333m" ,"sys3_pll2_out" , }; + +static const char *imx8mq_pcie2_phy_sels[] = {"osc_25m" ,"sys2_pll_100m" ,"sys2_pll_500m" ,"clk_ext1" , +"clk_ext2" ,"clk_ext3" ,"clk_ext4" ,"sys1_pll_400m" , }; + +static const char *imx8mq_pcie2_aux_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys2_pll_50m" ,"sys3_pll2_out" , +"sys2_pll_100m" ,"sys1_pll_80m" ,"sys1_pll_160m" ,"sys1_pll_200m" , }; + +static const char *imx8mq_ecspi3_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys1_pll_40m" ,"sys1_pll_160m" , +"sys1_pll_800m" ,"sys3_pll2_out" ,"sys2_pll_250m" ,"audio_pll2_out" , }; +static const char *imx8mq_dram_core_sels[] = {"dram_pll_out" ,"dram_alt_root" , }; + +static const char *imx8mq_clko2_sels[] = {"osc_25m" ,"sys2_pll_200m" ,"sys1_pll_400m" ,"sys2_pll_166m" ,"audio_pll1_out" , +"video_pll1_out" ,"ckil" , };
drivers/clk/imx/clk-imx8mq.c line 287
Quoted 10 lines
drivers/clk/imx/clk-imx8mq.c new file +10
-0+ +static int const clks_init_on[]__initconst = { +IMX8MQ_CLK_DRAM_CORE ,IMX8MQ_CLK_AHB_CG , +IMX8MQ_CLK_NOC_CG ,IMX8MQ_CLK_NOC_APB_CG , +IMX8MQ_CLK_USB_BUS_CG ,IMX8MQ_CLK_NAND_USDHC_BUS_CG , +IMX8MQ_CLK_MAIN_AXI_CG ,IMX8MQ_CLK_A53_CG , +IMX8MQ_CLK_AUDIO_AHB_DIV ,IMX8MQ_CLK_TMU_ROOT , +IMX8MQ_CLK_DRAM_APB_DIV , +}; +
We can drop clks_init_on by using CLK_IS_CRITICAL.
Quoted 22 lines
drivers/clk/imx/clk-imx8mq.c new file +22
-0+static struct clk_onecell_data clk_data; + +static void __init imx8mq_clocks_init (struct device_node *ccm_node) +{ +struct device_node *np; +void __iomem *base; +int i; + + clks[IMX8MQ_CLK_DUMMY ] =imx_clk_fixed ("dummy" ,0 ); + clks[IMX8MQ_CLK_32K ] =of_clk_get_by_name (ccm_node,"ckil" ); + clks[IMX8MQ_CLK_25M ] =of_clk_get_by_name (ccm_node,"osc_25m" ); + clks[IMX8MQ_CLK_27M ] =of_clk_get_by_name (ccm_node,"osc_27m" ); + clks[IMX8MQ_CLK_EXT1 ] =of_clk_get_by_name (ccm_node,"clk_ext1" ); + clks[IMX8MQ_CLK_EXT2 ] =of_clk_get_by_name (ccm_node,"clk_ext2" ); + clks[IMX8MQ_CLK_EXT3 ] =of_clk_get_by_name (ccm_node,"clk_ext3" ); + clks[IMX8MQ_CLK_EXT4 ] =of_clk_get_by_name (ccm_node,"clk_ext4" ); + + np =of_find_compatible_node (NULL ,NULL ,"fsl,imx8mq-anatop" ); + base =of_iomap (np,0 ); +WARN_ON (!base); + + clks[IMX8MQ_ARM_PLL_REF_SEL ] =imx_clk_mux ("arm_pll_ref_sel" , base +0x28 ,16 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels));
drivers/clk/imx/clk-imx8mq.c line 319
Quoted 10 lines
drivers/clk/imx/clk-imx8mq.c new file +10
-0+ clks[IMX8MQ_GPU_PLL_REF_SEL ] =imx_clk_mux ("gpu_pll_ref_sel" , base +0x18 ,16 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_VPU_PLL_REF_SEL ] =imx_clk_mux ("vpu_pll_ref_sel" , base +0x20 ,16 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_AUDIO_PLL1_REF_SEL ] =imx_clk_mux ("audio_pll1_ref_sel" , base +0x0 ,16 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_AUDIO_PLL2_REF_SEL ] =imx_clk_mux ("audio_pll2_ref_sel" , base +0x8 ,16 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_VIDEO_PLL1_REF_SEL ] =imx_clk_mux ("video_pll1_ref_sel" , base +0x10 ,16 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_SYS1_PLL1_REF_SEL ] =imx_clk_mux ("sys1_pll1_ref_sel" , base +0x30 ,0 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_SYS2_PLL1_REF_SEL ] =imx_clk_mux ("sys2_pll1_ref_sel" , base +0x3c ,0 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_SYS3_PLL1_REF_SEL ] =imx_clk_mux ("sys3_pll1_ref_sel" , base +0x48 ,0 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_DRAM_PLL1_REF_SEL ] =imx_clk_mux ("dram_pll1_ref_sel" , base +0x60 ,0 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels)); + clks[IMX8MQ_VIDEO2_PLL1_REF_SEL ] =imx_clk_mux ("video2_pll1_ref_sel" , base +0x54 ,0 ,2 , pll_ref_sels,ARRAY_SIZE (pll_ref_sels));
How about define them from low address to high address according to reference manual? Same issue on other places.
Quoted 27 lines
drivers/clk/imx/clk-imx8mq.c new file +27
-0+ + clks[IMX8MQ_ARM_PLL_REF_DIV ] =imx_clk_divider ("arm_pll_ref_div" ,"arm_pll_ref_sel" , base +0x28 ,5 ,6 ); + clks[IMX8MQ_GPU_PLL_REF_DIV ] =imx_clk_divider ("gpu_pll_ref_div" ,"gpu_pll_ref_sel" , base +0x18 ,5 ,6 ); + clks[IMX8MQ_VPU_PLL_REF_DIV ] =imx_clk_divider ("vpu_pll_ref_div" ,"vpu_pll_ref_sel" , base +0x20 ,5 ,6 ); + clks[IMX8MQ_AUDIO_PLL1_REF_DIV ] =imx_clk_divider ("audio_pll1_ref_div" ,"audio_pll1_ref_sel" , base +0x0 ,5 ,6 ); + clks[IMX8MQ_AUDIO_PLL2_REF_DIV ] =imx_clk_divider ("audio_pll2_ref_div" ,"audio_pll2_ref_sel" , base +0x8 ,5 ,6 ); + clks[IMX8MQ_VIDEO_PLL1_REF_DIV ] =imx_clk_divider ("video_pll1_ref_div" ,"video_pll1_ref_sel" , base +0x10 ,5 ,6 ); + clks[IMX8MQ_SYS1_PLL1_REF_DIV ] =imx_clk_divider ("sys1_pll1_ref_div" ,"sys1_pll1_ref_sel" , base +0x38 ,25 ,3 ); + clks[IMX8MQ_SYS2_PLL1_REF_DIV ] =imx_clk_divider ("sys2_pll1_ref_div" ,"sys2_pll1_ref_sel" , base +0x44 ,25 ,3 ); + clks[IMX8MQ_SYS3_PLL1_REF_DIV ] =imx_clk_divider ("sys3_pll1_ref_div" ,"sys3_pll1_ref_sel" , base +0x50 ,25 ,3 ); + clks[IMX8MQ_DRAM_PLL1_REF_DIV ] =imx_clk_divider ("dram_pll1_ref_div" ,"dram_pll1_ref_sel" , base +0x68 ,25 ,3 ); + clks[IMX8MQ_VIDEO2_PLL1_REF_DIV ] =imx_clk_divider ("video2_pll1_ref_div" ,"video2_pll1_ref_sel" , base +0x5c ,25 ,3 ); + + clks[IMX8MQ_ARM_PLL ] =imx_clk_frac_pll ("arm_pll" ,"arm_pll_ref_div" , base +0x28 ); + clks[IMX8MQ_GPU_PLL ] =imx_clk_frac_pll ("gpu_pll" ,"gpu_pll_ref_div" , base +0x18 ); + clks[IMX8MQ_VPU_PLL ] =imx_clk_frac_pll ("vpu_pll" ,"vpu_pll_ref_div" , base +0x20 ); + clks[IMX8MQ_AUDIO_PLL1 ] =imx_clk_frac_pll ("audio_pll1" ,"audio_pll1_ref_div" , base +0x0 ); + clks[IMX8MQ_AUDIO_PLL2 ] =imx_clk_frac_pll ("audio_pll2" ,"audio_pll2_ref_div" , base +0x8 ); + clks[IMX8MQ_VIDEO_PLL1 ] =imx_clk_frac_pll ("video_pll1" ,"video_pll1_ref_div" , base +0x10 ); + clks[IMX8MQ_SYS1_PLL1 ] =imx_clk_sccg_pll ("sys1_pll1" ,"sys1_pll1_ref_div" , base +0x30 ,SCCG_PLL1 ); + clks[IMX8MQ_SYS2_PLL1 ] =imx_clk_sccg_pll ("sys2_pll1" ,"sys2_pll1_ref_div" , base +0x3c ,SCCG_PLL1 ); + clks[IMX8MQ_SYS3_PLL1 ] =imx_clk_sccg_pll ("sys3_pll1" ,"sys3_pll1_ref_div" , base +0x48 ,SCCG_PLL1 ); + clks[IMX8MQ_DRAM_PLL1 ] =imx_clk_sccg_pll ("dram_pll1" ,"dram_pll1_ref_div" , base +0x60 ,SCCG_PLL1 ); + clks[IMX8MQ_VIDEO2_PLL1 ] =imx_clk_sccg_pll ("video2_pll1" ,"video2_pll1_ref_div" , base +0x5c ,3 ); + + clks[IMX8MQ_SYS1_PLL2 ] =imx_clk_sccg_pll ("sys1_pll2" ,"sys1_pll1_out_div" , base +0x30 ,SCCG_PLL2 ); + clks[IMX8MQ_SYS2_PLL2 ] =imx_clk_sccg_pll ("sys2_pll2" ,"sys2_pll1_out_div" , base +0x3c ,SCCG_PLL2 );
drivers/clk/imx/clk-imx8mq.c line 356
Quoted 10 lines
drivers/clk/imx/clk-imx8mq.c new file +10
-0+ clks[IMX8MQ_SYS3_PLL2 ] =imx_clk_sccg_pll ("sys3_pll2" ,"sys3_pll1_out_div" , base +0x48 ,SCCG_PLL2 ); + clks[IMX8MQ_DRAM_PLL2 ] =imx_clk_sccg_pll ("dram_pll2" ,"dram_pll1_out_div" , base +0x60 ,SCCG_PLL2 ); + clks[IMX8MQ_VIDEO2_PLL2 ] =imx_clk_sccg_pll ("video2_pll2" ,"video2_pll1_out_div" , base +0x54 ,SCCG_PLL2 ); + +/* PLL divs */ + clks[IMX8MQ_SYS1_PLL1_OUT_DIV ] =imx_clk_divider ("sys1_pll1_out_div" ,"sys1_pll1_out" , base +0x38 ,19 ,6 ); + clks[IMX8MQ_SYS2_PLL1_OUT_DIV ] =imx_clk_divider ("sys2_pll1_out_div" ,"sys2_pll1_out" , base +0x44 ,19 ,6 ); + clks[IMX8MQ_SYS3_PLL1_OUT_DIV ] =imx_clk_divider ("sys3_pll1_out_div" ,"sys3_pll1_out" , base +0x50 ,19 ,6 ); + clks[IMX8MQ_DRAM_PLL1_OUT_DIV ] =imx_clk_divider ("dram_pll1_out_div" ,"dram_pll1_out" , base +0x68 ,19 ,6 ); + clks[IMX8MQ_VIDEO2_PLL1_OUT_DIV ] =imx_clk_divider ("video2_pll1_out_div" ,"video2_pll1_out" , base +0x5c ,19 ,6 );
here out of orders
better define parent clocks before the using to avoid unnecessary churn.
Quoted 34 lines
drivers/clk/imx/clk-imx8mq.c new file +34
-0+ clks[IMX8MQ_SYS1_PLL2_DIV ] =imx_clk_divider ("sys1_pll2_div" ,"sys1_pll2" , base +0x38 ,1 ,6 ); + clks[IMX8MQ_SYS2_PLL2_DIV ] =imx_clk_divider ("sys2_pll2_div" ,"sys2_pll2" , base +0x44 ,1 ,6 ); + clks[IMX8MQ_SYS3_PLL2_DIV ] =imx_clk_divider ("sys3_pll2_div" ,"sys3_pll2" , base +0x50 ,1 ,6 ); + clks[IMX8MQ_DRAM_PLL2_DIV ] =imx_clk_divider ("dram_pll2_div" ,"dram_pll2" , base +0x68 ,1 ,6 ); + clks[IMX8MQ_VIDEO2_PLL2_DIV ] =imx_clk_divider ("video2_pll2_div" ,"video2_pll2" , base +0x5c ,1 ,6 ); + +/* PLL bypass out */ + clks[IMX8MQ_ARM_PLL_BYPASS ] =imx_clk_mux ("arm_pll_bypass" , base +0x28 ,14 ,1 , arm_pll_bypass_sels,ARRAY_SIZE (arm_pll_bypass_sels)); + clks[IMX8MQ_GPU_PLL_BYPASS ] =imx_clk_mux ("gpu_pll_bypass" , base +0x18 ,14 ,1 , gpu_pll_bypass_sels,ARRAY_SIZE (gpu_pll_bypass_sels)); + clks[IMX8MQ_VPU_PLL_BYPASS ] =imx_clk_mux ("vpu_pll_bypass" , base +0x20 ,14 ,1 , vpu_pll_bypass_sels,ARRAY_SIZE (vpu_pll_bypass_sels)); + clks[IMX8MQ_AUDIO_PLL1_BYPASS ] =imx_clk_mux ("audio_pll1_bypass" , base +0x0 ,14 ,1 , audio_pll1_bypass_sels,ARRAY_SIZE (audio_pll1_bypass_sels)); + clks[IMX8MQ_AUDIO_PLL2_BYPASS ] =imx_clk_mux ("audio_pll2_bypass" , base +0x8 ,14 ,1 , audio_pll2_bypass_sels,ARRAY_SIZE (audio_pll2_bypass_sels)); + clks[IMX8MQ_VIDEO_PLL1_BYPASS ] =imx_clk_mux ("video_pll1_bypass" , base +0x10 ,14 ,1 , video_pll1_bypass_sels,ARRAY_SIZE (video_pll1_bypass_sels)); + + clks[IMX8MQ_SYS1_PLL1_OUT ] =imx_clk_mux ("sys1_pll1_out" , base +0x30 ,5 ,1 , sys1_pll1_out_sels,ARRAY_SIZE (sys1_pll1_out_sels)); + clks[IMX8MQ_SYS2_PLL1_OUT ] =imx_clk_mux ("sys2_pll1_out" , base +0x3c ,5 ,1 , sys2_pll1_out_sels,ARRAY_SIZE (sys2_pll1_out_sels)); + clks[IMX8MQ_SYS3_PLL1_OUT ] =imx_clk_mux ("sys3_pll1_out" , base +0x48 ,5 ,1 , sys3_pll1_out_sels,ARRAY_SIZE (sys3_pll1_out_sels)); + clks[IMX8MQ_DRAM_PLL1_OUT ] =imx_clk_mux ("dram_pll1_out" , base +0x60 ,5 ,1 , dram_pll1_out_sels,ARRAY_SIZE (dram_pll1_out_sels)); + clks[IMX8MQ_VIDEO2_PLL1_OUT ] =imx_clk_mux ("video2_pll1_out" , base +0x54 ,5 ,1 , video2_pll1_out_sels,ARRAY_SIZE (video2_pll1_out_sels)); + clks[IMX8MQ_SYS1_PLL2_OUT ] =imx_clk_mux ("sys1_pll2_out" , base +0x30 ,4 ,1 , sys1_pll2_out_sels,ARRAY_SIZE (sys1_pll2_out_sels)); + clks[IMX8MQ_SYS2_PLL2_OUT ] =imx_clk_mux ("sys2_pll2_out" , base +0x3c ,4 ,1 , sys2_pll2_out_sels,ARRAY_SIZE (sys2_pll2_out_sels)); + clks[IMX8MQ_SYS3_PLL2_OUT ] =imx_clk_mux ("sys3_pll2_out" , base +0x48 ,4 ,1 , sys3_pll2_out_sels,ARRAY_SIZE (sys3_pll2_out_sels)); + clks[IMX8MQ_DRAM_PLL2_OUT ] =imx_clk_mux ("dram_pll2_out" , base +0x60 ,4 ,1 , dram_pll2_out_sels,ARRAY_SIZE (dram_pll2_out_sels)); + clks[IMX8MQ_VIDEO2_PLL2_OUT ] =imx_clk_mux ("video2_pll2_out" , base +0x54 ,4 ,1 , video2_pll2_out_sels,ARRAY_SIZE (video2_pll2_out_sels)); + +/* unbypass all the plls */ +clk_set_parent (clks[IMX8MQ_GPU_PLL_BYPASS ], clks[IMX8MQ_GPU_PLL ]); +clk_set_parent (clks[IMX8MQ_VPU_PLL_BYPASS ], clks[IMX8MQ_VPU_PLL ]); +clk_set_parent (clks[IMX8MQ_AUDIO_PLL1_BYPASS ], clks[IMX8MQ_AUDIO_PLL1 ]); +clk_set_parent (clks[IMX8MQ_AUDIO_PLL2_BYPASS ], clks[IMX8MQ_AUDIO_PLL2 ]); +clk_set_parent (clks[IMX8MQ_VIDEO_PLL1_BYPASS ], clks[IMX8MQ_VIDEO_PLL1 ]); +clk_set_parent (clks[IMX8MQ_SYS3_PLL1_OUT ], clks[IMX8MQ_SYS3_PLL1 ]); +clk_set_parent (clks[IMX8MQ_SYS3_PLL2_OUT ], clks[IMX8MQ_SYS3_PLL2_DIV ]); +
drivers/clk/imx/clk-imx8mq.c line 400
Quoted 10 lines
drivers/clk/imx/clk-imx8mq.c new file +10
-0+/* PLL OUT GATE */ + clks[IMX8MQ_ARM_PLL_OUT ] =imx_clk_gate ("arm_pll_out" ,"arm_pll_bypass" , base +0x28 ,21 ); + clks[IMX8MQ_GPU_PLL_OUT ] =imx_clk_gate ("gpu_pll_out" ,"gpu_pll_bypass" , base +0x18 ,21 ); + clks[IMX8MQ_VPU_PLL_OUT ] =imx_clk_gate ("vpu_pll_out" ,"vpu_pll_bypass" , base +0x20 ,21 ); + clks[IMX8MQ_AUDIO_PLL1_OUT ] =imx_clk_gate ("audio_pll1_out" ,"audio_pll1_bypass" , base +0x0 ,21 ); + clks[IMX8MQ_AUDIO_PLL2_OUT ] =imx_clk_gate ("audio_pll2_out" ,"audio_pll2_bypass" , base +0x8 ,21 ); + clks[IMX8MQ_VIDEO_PLL1_OUT ] =imx_clk_gate ("video_pll1_out" ,"video_pll1_bypass" , base +0x10 ,21 ); + clks[IMX8MQ_SYS1_PLL_OUT ] =imx_clk_gate ("sys1_pll_out" ,"sys1_pll2_out" , base +0x30 ,9 ); + clks[IMX8MQ_SYS2_PLL_OUT ] =imx_clk_gate ("sys2_pll_out" ,"sys2_pll2_out" , base +0x3c ,9 ); + clks[IMX8MQ_SYS3_PLL_OUT ] =imx_clk_gate ("sys3_pll_out" ,"sys3_pll2_out" , base +0x48 ,9 );
Are those correct?
What i see from RM, Bit 9 is:PLL_DIV20_CLKE
Quoted 450 lines
drivers/clk/imx/clk-imx8mq.c new file +450
-0+ clks[IMX8MQ_DRAM_PLL_OUT ] =imx_clk_gate ("dram_pll_out" ,"dram_pll2_out" , base +0x60 ,9 ); + clks[IMX8MQ_VIDEO2_PLL_OUT ] =imx_clk_gate ("video2_pll_out" ,"video2_pll2_out" , base +0x54 ,9 ); + +/* SYS PLL fixed output */ + clks[IMX8MQ_SYS1_PLL_40M ] =imx_clk_fixed_factor ("sys1_pll_40m" ,"sys1_pll_out" ,1 ,20 ); + clks[IMX8MQ_SYS1_PLL_80M ] =imx_clk_fixed_factor ("sys1_pll_80m" ,"sys1_pll_out" ,1 ,10 ); + clks[IMX8MQ_SYS1_PLL_100M ] =imx_clk_fixed_factor ("sys1_pll_100m" ,"sys1_pll_out" ,1 ,8 ); + clks[IMX8MQ_SYS1_PLL_133M ] =imx_clk_fixed_factor ("sys1_pll_133m" ,"sys1_pll_out" ,1 ,6 ); + clks[IMX8MQ_SYS1_PLL_160M ] =imx_clk_fixed_factor ("sys1_pll_160m" ,"sys1_pll_out" ,1 ,5 ); + clks[IMX8MQ_SYS1_PLL_200M ] =imx_clk_fixed_factor ("sys1_pll_200m" ,"sys1_pll_out" ,1 ,4 ); + clks[IMX8MQ_SYS1_PLL_266M ] =imx_clk_fixed_factor ("sys1_pll_266m" ,"sys1_pll_out" ,1 ,3 ); + clks[IMX8MQ_SYS1_PLL_400M ] =imx_clk_fixed_factor ("sys1_pll_400m" ,"sys1_pll_out" ,1 ,2 ); + clks[IMX8MQ_SYS1_PLL_800M ] =imx_clk_fixed_factor ("sys1_pll_800m" ,"sys1_pll_out" ,1 ,1 ); + + clks[IMX8MQ_SYS2_PLL_50M ] =imx_clk_fixed_factor ("sys2_pll_50m" ,"sys2_pll_out" ,1 ,20 ); + clks[IMX8MQ_SYS2_PLL_100M ] =imx_clk_fixed_factor ("sys2_pll_100m" ,"sys2_pll_out" ,1 ,10 ); + clks[IMX8MQ_SYS2_PLL_125M ] =imx_clk_fixed_factor ("sys2_pll_125m" ,"sys2_pll_out" ,1 ,8 ); + clks[IMX8MQ_SYS2_PLL_166M ] =imx_clk_fixed_factor ("sys2_pll_166m" ,"sys2_pll_out" ,1 ,6 ); + clks[IMX8MQ_SYS2_PLL_200M ] =imx_clk_fixed_factor ("sys2_pll_200m" ,"sys2_pll_out" ,1 ,5 ); + clks[IMX8MQ_SYS2_PLL_250M ] =imx_clk_fixed_factor ("sys2_pll_250m" ,"sys2_pll_out" ,1 ,4 ); + clks[IMX8MQ_SYS2_PLL_333M ] =imx_clk_fixed_factor ("sys2_pll_333m" ,"sys2_pll_out" ,1 ,3 ); + clks[IMX8MQ_SYS2_PLL_500M ] =imx_clk_fixed_factor ("sys2_pll_500m" ,"sys2_pll_out" ,1 ,2 ); + clks[IMX8MQ_SYS2_PLL_1000M ] =imx_clk_fixed_factor ("sys2_pll_1000m" ,"sys2_pll_out" ,1 ,1 ); + + np = ccm_node; + base =of_iomap (np,0 ); +WARN_ON (!base); +/* CORE */ + clks[IMX8MQ_CLK_A53_SRC ] =imx_clk_mux2 ("arm_a53_src" , base +0x8000 ,24 ,3 , imx8mq_a53_sels,ARRAY_SIZE (imx8mq_a53_sels)); + clks[IMX8MQ_CLK_VPU_SRC ] =imx_clk_mux2 ("vpu_src" , base +0x8100 ,24 ,3 , imx8mq_vpu_sels,ARRAY_SIZE (imx8mq_vpu_sels)); + clks[IMX8MQ_CLK_GPU_CORE_SRC ] =imx_clk_mux2 ("gpu_core_src" , base +0x8180 ,24 ,3 , imx8mq_gpu_core_sels,ARRAY_SIZE (imx8mq_gpu_core_sels)); + clks[IMX8MQ_CLK_GPU_SHADER_SRC ] =imx_clk_mux2 ("gpu_shader_src" , base +0x8200 ,24 ,3 , imx8mq_gpu_shader_sels,ARRAY_SIZE (imx8mq_gpu_shader_sels)); + clks[IMX8MQ_CLK_A53_CG ] =imx_clk_gate3_flags ("arm_a53_cg" ,"arm_a53_src" , base +0x8000 ,28 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_VPU_CG ] =imx_clk_gate3 ("vpu_cg" ,"vpu_src" , base +0x8100 ,28 ); + clks[IMX8MQ_CLK_GPU_CORE_CG ] =imx_clk_gate3 ("gpu_core_cg" ,"gpu_core_src" , base +0x8180 ,28 ); + clks[IMX8MQ_CLK_GPU_SHADER_CG ] =imx_clk_gate3 ("gpu_shader_cg" ,"gpu_shader_src" , base +0x8200 ,28 ); + + clks[IMX8MQ_CLK_A53_DIV ] =imx_clk_divider2 ("arm_a53_div" ,"arm_a53_cg" , base +0x8000 ,0 ,3 ); + clks[IMX8MQ_CLK_VPU_DIV ] =imx_clk_divider2 ("vpu_div" ,"vpu_cg" , base +0x8100 ,0 ,3 ); + clks[IMX8MQ_CLK_GPU_CORE_DIV ] =imx_clk_divider2 ("gpu_core_div" ,"gpu_core_cg" , base +0x8180 ,0 ,3 ); + clks[IMX8MQ_CLK_GPU_SHADER_DIV ] =imx_clk_divider2 ("gpu_shader_div" ,"gpu_shader_cg" , base +0x8200 ,0 ,3 ); + +/* BUS */ + clks[IMX8MQ_CLK_MAIN_AXI_SRC ] =imx_clk_mux2 ("main_axi_src" , base +0x8800 ,24 ,3 , imx8mq_main_axi_sels,ARRAY_SIZE (imx8mq_main_axi_sels)); + clks[IMX8MQ_CLK_ENET_AXI_SRC ] =imx_clk_mux2 ("enet_axi_src" , base +0x8880 ,24 ,3 , imx8mq_enet_axi_sels,ARRAY_SIZE (imx8mq_enet_axi_sels)); + clks[IMX8MQ_CLK_NAND_USDHC_BUS_SRC ] =imx_clk_mux2 ("nand_usdhc_bus_src" , base +0x8900 ,24 ,3 , imx8mq_nand_usdhc_sels,ARRAY_SIZE (imx8mq_nand_usdhc_sels)); + clks[IMX8MQ_CLK_VPU_BUS_SRC ] =imx_clk_mux2 ("vpu_bus_src" , base +0x8980 ,24 ,3 , imx8mq_vpu_bus_sels,ARRAY_SIZE (imx8mq_vpu_bus_sels)); + clks[IMX8MQ_CLK_DISP_AXI_SRC ] =imx_clk_mux2 ("disp_axi_src" , base +0x8a00 ,24 ,3 , imx8mq_disp_axi_sels,ARRAY_SIZE (imx8mq_disp_axi_sels)); + clks[IMX8MQ_CLK_DISP_APB_SRC ] =imx_clk_mux2 ("disp_apb_src" , base +0x8a80 ,24 ,3 , imx8mq_disp_apb_sels,ARRAY_SIZE (imx8mq_disp_apb_sels)); + clks[IMX8MQ_CLK_DISP_RTRM_SRC ] =imx_clk_mux2 ("disp_rtrm_src" , base +0x8b00 ,24 ,3 , imx8mq_disp_rtrm_sels,ARRAY_SIZE (imx8mq_disp_rtrm_sels)); + clks[IMX8MQ_CLK_USB_BUS_SRC ] =imx_clk_mux2 ("usb_bus_src" , base +0x8b80 ,24 ,3 , imx8mq_usb_bus_sels,ARRAY_SIZE (imx8mq_usb_bus_sels)); + clks[IMX8MQ_CLK_GPU_AXI_SRC ] =imx_clk_mux2 ("gpu_axi_src" , base +0x8c00 ,24 ,3 , imx8mq_gpu_axi_sels,ARRAY_SIZE (imx8mq_gpu_axi_sels)); + clks[IMX8MQ_CLK_GPU_AHB_SRC ] =imx_clk_mux2 ("gpu_ahb_src" , base +0x8c80 ,24 ,3 , imx8mq_gpu_ahb_sels,ARRAY_SIZE (imx8mq_gpu_ahb_sels)); + clks[IMX8MQ_CLK_NOC_SRC ] =imx_clk_mux2 ("noc_src" , base +0x8d00 ,24 ,3 , imx8mq_noc_sels,ARRAY_SIZE (imx8mq_noc_sels)); + clks[IMX8MQ_CLK_NOC_APB_SRC ] =imx_clk_mux2 ("noc_apb_src" , base +0x8d80 ,24 ,3 , imx8mq_noc_apb_sels,ARRAY_SIZE (imx8mq_noc_apb_sels)); + + clks[IMX8MQ_CLK_MAIN_AXI_CG ] =imx_clk_gate3_flags ("main_axi_cg" ,"main_axi_src" , base +0x8800 ,28 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_ENET_AXI_CG ] =imx_clk_gate3 ("enet_axi_cg" ,"enet_axi_src" , base +0x8880 ,28 ); + clks[IMX8MQ_CLK_NAND_USDHC_BUS_CG ] =imx_clk_gate3_flags ("nand_usdhc_bus_cg" ,"nand_usdhc_bus_src" , base +0x8900 ,28 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_VPU_BUS_CG ] =imx_clk_gate3 ("vpu_bus_cg" ,"vpu_bus_src" , base +0x8980 ,28 ); + clks[IMX8MQ_CLK_DISP_AXI_CG ] =imx_clk_gate3 ("disp_axi_cg" ,"disp_axi_src" , base +0x8a00 ,28 ); + clks[IMX8MQ_CLK_DISP_APB_CG ] =imx_clk_gate3 ("disp_apb_cg" ,"disp_apb_src" , base +0x8a80 ,28 ); + clks[IMX8MQ_CLK_DISP_RTRM_CG ] =imx_clk_gate3 ("disp_rtrm_cg" ,"disp_rtrm_src" , base +0x8b00 ,28 ); + clks[IMX8MQ_CLK_USB_BUS_CG ] =imx_clk_gate3_flags ("usb_bus_cg" ,"usb_bus_src" , base +0x8b80 ,28 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_GPU_AXI_CG ] =imx_clk_gate3 ("gpu_axi_cg" ,"gpu_axi_src" , base +0x8c00 ,28 ); + clks[IMX8MQ_CLK_GPU_AHB_CG ] =imx_clk_gate3 ("gpu_ahb_cg" ,"gpu_ahb_src" , base +0x8c80 ,28 ); + clks[IMX8MQ_CLK_NOC_CG ] =imx_clk_gate3_flags ("noc_cg" ,"noc_src" , base +0x8d00 ,28 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_NOC_APB_CG ] =imx_clk_gate3_flags ("noc_apb_cg" ,"noc_apb_src" , base +0x8d80 ,28 ,CLK_IS_CRITICAL ); + + clks[IMX8MQ_CLK_MAIN_AXI_PRE_DIV ] =imx_clk_divider2 ("main_axi_pre_div" ,"main_axi_cg" , base +0x8800 ,16 ,3 ); + clks[IMX8MQ_CLK_ENET_AXI_PRE_DIV ] =imx_clk_divider2 ("enet_axi_pre_div" ,"enet_axi_cg" , base +0x8880 ,16 ,3 ); + clks[IMX8MQ_CLK_NAND_USDHC_BUS_PRE_DIV ] =imx_clk_divider2 ("nand_usdhc_bus_pre_div" ,"nand_usdhc_bus_cg" , base +0x8900 ,16 ,3 ); + clks[IMX8MQ_CLK_VPU_BUS_PRE_DIV ] =imx_clk_divider2 ("vpu_bus_pre_div" ,"vpu_bus_cg" , base +0x8980 ,16 ,3 ); + clks[IMX8MQ_CLK_DISP_AXI_PRE_DIV ] =imx_clk_divider2 ("disp_axi_pre_div" ,"disp_axi_cg" , base +0x8a00 ,16 ,3 ); + clks[IMX8MQ_CLK_DISP_APB_PRE_DIV ] =imx_clk_divider2 ("disp_apb_pre_div" ,"disp_apb_cg" , base +0x8a80 ,16 ,3 ); + clks[IMX8MQ_CLK_DISP_RTRM_PRE_DIV ] =imx_clk_divider2 ("disp_rtrm_pre_div" ,"disp_rtrm_cg" , base +0x8b00 ,16 ,3 ); + clks[IMX8MQ_CLK_USB_BUS_PRE_DIV ] =imx_clk_divider2 ("usb_bus_pre_div" ,"usb_bus_cg" , base +0x8b80 ,16 ,3 ); + clks[IMX8MQ_CLK_GPU_AXI_PRE_DIV ] =imx_clk_divider2 ("gpu_axi_pre_div" ,"gpu_axi_cg" , base +0x8c00 ,16 ,3 ); + clks[IMX8MQ_CLK_GPU_AHB_PRE_DIV ] =imx_clk_divider2 ("gpu_ahb_pre_div" ,"gpu_ahb_cg" , base +0x8c80 ,16 ,3 ); + clks[IMX8MQ_CLK_NOC_PRE_DIV ] =imx_clk_divider2 ("noc_pre_div" ,"noc_cg" , base +0x8d00 ,16 ,3 ); + clks[IMX8MQ_CLK_NOC_APB_PRE_DIV ] =imx_clk_divider2 ("noc_apb_pre_div" ,"noc_apb_cg" , base +0x8d80 ,16 ,3 ); + + clks[IMX8MQ_CLK_MAIN_AXI_DIV ] =imx_clk_divider2 ("main_axi_div" ,"main_axi_pre_div" , base +0x8800 ,0 ,6 ); + clks[IMX8MQ_CLK_ENET_AXI_DIV ] =imx_clk_divider2 ("enet_axi_div" ,"enet_axi_pre_div" , base +0x8880 ,0 ,6 ); + clks[IMX8MQ_CLK_NAND_USDHC_BUS_DIV ] =imx_clk_divider2 ("nand_usdhc_bus_div" ,"nand_usdhc_bus_pre_div" , base +0x8900 ,0 ,6 ); + clks[IMX8MQ_CLK_VPU_BUS_DIV ] =imx_clk_divider_flags ("vpu_bus_div" ,"vpu_bus_pre_div" , base +0x8980 ,0 ,6 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_DISP_AXI_DIV ] =imx_clk_divider2 ("disp_axi_div" ,"disp_axi_pre_div" , base +0x8a00 ,0 ,6 ); + clks[IMX8MQ_CLK_DISP_APB_DIV ] =imx_clk_divider2 ("disp_apb_div" ,"disp_apb_pre_div" , base +0x8a80 ,0 ,6 ); + clks[IMX8MQ_CLK_DISP_RTRM_DIV ] =imx_clk_divider2 ("disp_rtrm_div" ,"disp_rtrm_pre_div" , base +0x8b00 ,0 ,6 ); + clks[IMX8MQ_CLK_USB_BUS_DIV ] =imx_clk_divider2 ("usb_bus_div" ,"usb_bus_pre_div" , base +0x8b80 ,0 ,6 ); + clks[IMX8MQ_CLK_GPU_AXI_DIV ] =imx_clk_divider2 ("gpu_axi_div" ,"gpu_axi_pre_div" , base +0x8c00 ,0 ,6 ); + clks[IMX8MQ_CLK_GPU_AHB_DIV ] =imx_clk_divider2 ("gpu_ahb_div" ,"gpu_ahb_pre_div" , base +0x8c80 ,0 ,6 ); + clks[IMX8MQ_CLK_NOC_DIV ] =imx_clk_divider2 ("noc_div" ,"noc_pre_div" , base +0x8d00 ,0 ,6 ); + clks[IMX8MQ_CLK_NOC_APB_DIV ] =imx_clk_divider2 ("noc_apb_div" ,"noc_apb_pre_div" , base +0x8d80 ,0 ,6 ); + +/* AHB */ + clks[IMX8MQ_CLK_AHB_SRC ] =imx_clk_mux2 ("ahb_src" , base +0x9000 ,24 ,3 , imx8mq_ahb_sels,ARRAY_SIZE (imx8mq_ahb_sels)); + clks[IMX8MQ_CLK_AUDIO_AHB_SRC ] =imx_clk_mux2 ("audio_ahb_src" , base +0x9100 ,24 ,3 , imx8mq_audio_ahb_sels,ARRAY_SIZE (imx8mq_audio_ahb_sels)); + clks[IMX8MQ_CLK_AHB_CG ] =imx_clk_gate3_flags ("ahb_cg" ,"ahb_src" , base +0x9000 ,28 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_AUDIO_AHB_CG ] =imx_clk_gate3 ("audio_ahb_cg" ,"audio_ahb_src" , base +0x9100 ,28 ); + clks[IMX8MQ_CLK_AHB_PRE_DIV ] =imx_clk_divider2 ("ahb_pre_div" ,"ahb_cg" , base +0x9000 ,16 ,3 ); + clks[IMX8MQ_CLK_AUDIO_AHB_PRE_DIV ] =imx_clk_divider2 ("audio_ahb_pre_div" ,"audio_ahb_cg" , base +0x9100 ,16 ,3 ); + clks[IMX8MQ_CLK_AHB_DIV ] =imx_clk_divider_flags ("ahb_div" ,"ahb_pre_div" , base +0x9000 ,0 ,6 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_AUDIO_AHB_DIV ] =imx_clk_divider2_flags ("audio_ahb_div" ,"audio_ahb_pre_div" , base +0x9100 ,0 ,6 ,CLK_IS_CRITICAL ); + +/* IPG */ + clks[IMX8MQ_CLK_IPG_ROOT ] =imx_clk_divider2 ("ipg_root" ,"ahb_div" , base +0x9080 ,0 ,1 ); + clks[IMX8MQ_CLK_IPG_AUDIO_ROOT ] =imx_clk_divider2 ("ipg_audio_root" ,"audio_ahb_div" , base +0x9180 ,0 ,1 ); + +/* IP */ + clks[IMX8MQ_CLK_DRAM_ALT_SRC ] =imx_clk_mux2 ("dram_alt_src" , base +0xa000 ,24 ,3 , imx8mq_dram_alt_sels,ARRAY_SIZE (imx8mq_dram_alt_sels)); + clks[IMX8MQ_CLK_DRAM_CORE ] =imx_clk_mux2_flags ("dram_core_clk" , base +0x9800 ,24 ,1 , imx8mq_dram_core_sels,ARRAY_SIZE (imx8mq_dram_core_sels),CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_DRAM_APB_SRC ] =imx_clk_mux2 ("dram_apb_src" , base +0xa080 ,24 ,3 , imx8mq_dram_apb_sels,ARRAY_SIZE (imx8mq_dram_apb_sels)); + clks[IMX8MQ_CLK_VPU_G1_SRC ] =imx_clk_mux2 ("vpu_g1_src" , base +0xa100 ,24 ,3 , imx8mq_vpu_g1_sels,ARRAY_SIZE (imx8mq_vpu_g1_sels)); + clks[IMX8MQ_CLK_VPU_G2_SRC ] =imx_clk_mux2 ("vpu_g2_src" , base +0xa180 ,24 ,3 , imx8mq_vpu_g2_sels,ARRAY_SIZE (imx8mq_vpu_g2_sels)); + clks[IMX8MQ_CLK_DISP_DTRC_SRC ] =imx_clk_mux2 ("disp_dtrc_src" , base +0xa200 ,24 ,3 , imx8mq_disp_dtrc_sels,ARRAY_SIZE (imx8mq_disp_dtrc_sels)); + clks[IMX8MQ_CLK_DISP_DC8000_SRC ] =imx_clk_mux2 ("disp_dc8000_src" , base +0xa280 ,24 ,3 , imx8mq_disp_dc8000_sels,ARRAY_SIZE (imx8mq_disp_dc8000_sels)); + clks[IMX8MQ_CLK_PCIE1_CTRL_SRC ] =imx_clk_mux2 ("pcie1_ctrl_src" , base +0xa300 ,24 ,3 , imx8mq_pcie1_ctrl_sels,ARRAY_SIZE (imx8mq_pcie1_ctrl_sels)); + clks[IMX8MQ_CLK_PCIE1_PHY_SRC ] =imx_clk_mux2 ("pcie1_phy_src" , base +0xa380 ,24 ,3 , imx8mq_pcie1_phy_sels,ARRAY_SIZE (imx8mq_pcie1_phy_sels)); + clks[IMX8MQ_CLK_PCIE1_AUX_SRC ] =imx_clk_mux2 ("pcie1_aux_src" , base +0xa400 ,24 ,3 , imx8mq_pcie1_aux_sels,ARRAY_SIZE (imx8mq_pcie1_aux_sels)); + clks[IMX8MQ_CLK_DC_PIXEL_SRC ] =imx_clk_mux2 ("dc_pixel_src" , base +0xa480 ,24 ,3 , imx8mq_dc_pixel_sels,ARRAY_SIZE (imx8mq_dc_pixel_sels)); + clks[IMX8MQ_CLK_LCDIF_PIXEL_SRC ] =imx_clk_mux2 ("lcdif_pixel_src" , base +0xa500 ,24 ,3 , imx8mq_lcdif_pixel_sels,ARRAY_SIZE (imx8mq_lcdif_pixel_sels)); + clks[IMX8MQ_CLK_SAI1_SRC ] =imx_clk_mux2 ("sai1_src" , base +0xa580 ,24 ,3 , imx8mq_sai1_sels,ARRAY_SIZE (imx8mq_sai1_sels)); + clks[IMX8MQ_CLK_SAI2_SRC ] =imx_clk_mux2 ("sai2_src" , base +0xa600 ,24 ,3 , imx8mq_sai2_sels,ARRAY_SIZE (imx8mq_sai2_sels)); + clks[IMX8MQ_CLK_SAI3_SRC ] =imx_clk_mux2 ("sai3_src" , base +0xa680 ,24 ,3 , imx8mq_sai3_sels,ARRAY_SIZE (imx8mq_sai3_sels)); + clks[IMX8MQ_CLK_SAI4_SRC ] =imx_clk_mux2 ("sai4_src" , base +0xa700 ,24 ,3 , imx8mq_sai4_sels,ARRAY_SIZE (imx8mq_sai4_sels)); + clks[IMX8MQ_CLK_SAI5_SRC ] =imx_clk_mux2 ("sai5_src" , base +0xa780 ,24 ,3 , imx8mq_sai5_sels,ARRAY_SIZE (imx8mq_sai5_sels)); + clks[IMX8MQ_CLK_SAI6_SRC ] =imx_clk_mux2 ("sai6_src" , base +0xa800 ,24 ,3 , imx8mq_sai6_sels,ARRAY_SIZE (imx8mq_sai6_sels)); + clks[IMX8MQ_CLK_SPDIF1_SRC ] =imx_clk_mux2 ("spdif1_src" , base +0xa880 ,24 ,3 , imx8mq_spdif1_sels,ARRAY_SIZE (imx8mq_spdif1_sels)); + clks[IMX8MQ_CLK_SPDIF2_SRC ] =imx_clk_mux2 ("spdif2_src" , base +0xa900 ,24 ,3 , imx8mq_spdif2_sels,ARRAY_SIZE (imx8mq_spdif2_sels)); + clks[IMX8MQ_CLK_ENET_REF_SRC ] =imx_clk_mux2 ("enet_ref_src" , base +0xa980 ,24 ,3 , imx8mq_enet_ref_sels,ARRAY_SIZE (imx8mq_enet_ref_sels)); + clks[IMX8MQ_CLK_ENET_TIMER_SRC ] =imx_clk_mux2 ("enet_timer_src" , base +0xaa00 ,24 ,3 , imx8mq_enet_timer_sels,ARRAY_SIZE (imx8mq_enet_timer_sels)); + clks[IMX8MQ_CLK_ENET_PHY_REF_SRC ] =imx_clk_mux2 ("enet_phy_src" , base +0xaa80 ,24 ,3 , imx8mq_enet_phy_sels,ARRAY_SIZE (imx8mq_enet_phy_sels)); + clks[IMX8MQ_CLK_NAND_SRC ] =imx_clk_mux2 ("nand_src" , base +0xab00 ,24 ,3 , imx8mq_nand_sels,ARRAY_SIZE (imx8mq_nand_sels)); + clks[IMX8MQ_CLK_QSPI_SRC ] =imx_clk_mux2 ("qspi_src" , base +0xab80 ,24 ,3 , imx8mq_qspi_sels,ARRAY_SIZE (imx8mq_qspi_sels)); + clks[IMX8MQ_CLK_USDHC1_SRC ] =imx_clk_mux2 ("usdhc1_src" , base +0xac00 ,24 ,3 , imx8mq_usdhc1_sels,ARRAY_SIZE (imx8mq_usdhc1_sels)); + clks[IMX8MQ_CLK_USDHC2_SRC ] =imx_clk_mux2 ("usdhc2_src" , base +0xac80 ,24 ,3 , imx8mq_usdhc2_sels,ARRAY_SIZE (imx8mq_usdhc2_sels)); + clks[IMX8MQ_CLK_I2C1_SRC ] =imx_clk_mux2 ("i2c1_src" , base +0xad00 ,24 ,3 , imx8mq_i2c1_sels,ARRAY_SIZE (imx8mq_i2c1_sels)); + clks[IMX8MQ_CLK_I2C2_SRC ] =imx_clk_mux2 ("i2c2_src" , base +0xad80 ,24 ,3 , imx8mq_i2c2_sels,ARRAY_SIZE (imx8mq_i2c2_sels)); + clks[IMX8MQ_CLK_I2C3_SRC ] =imx_clk_mux2 ("i2c3_src" , base +0xae00 ,24 ,3 , imx8mq_i2c3_sels,ARRAY_SIZE (imx8mq_i2c3_sels)); + clks[IMX8MQ_CLK_I2C4_SRC ] =imx_clk_mux2 ("i2c4_src" , base +0xae80 ,24 ,3 , imx8mq_i2c4_sels,ARRAY_SIZE (imx8mq_i2c4_sels)); + clks[IMX8MQ_CLK_UART1_SRC ] =imx_clk_mux2 ("uart1_src" , base +0xaf00 ,24 ,3 , imx8mq_uart1_sels,ARRAY_SIZE (imx8mq_uart1_sels)); + clks[IMX8MQ_CLK_UART2_SRC ] =imx_clk_mux2 ("uart2_src" , base +0xaf80 ,24 ,3 , imx8mq_uart2_sels,ARRAY_SIZE (imx8mq_uart2_sels)); + clks[IMX8MQ_CLK_UART3_SRC ] =imx_clk_mux2 ("uart3_src" , base +0xb000 ,24 ,3 , imx8mq_uart3_sels,ARRAY_SIZE (imx8mq_uart3_sels)); + clks[IMX8MQ_CLK_UART4_SRC ] =imx_clk_mux2 ("uart4_src" , base +0xb080 ,24 ,3 , imx8mq_uart4_sels,ARRAY_SIZE (imx8mq_uart4_sels)); + clks[IMX8MQ_CLK_USB_CORE_REF_SRC ] =imx_clk_mux2 ("usb_core_ref_src" , base +0xb100 ,24 ,3 , imx8mq_usb_core_sels,ARRAY_SIZE (imx8mq_usb_core_sels)); + clks[IMX8MQ_CLK_USB_PHY_REF_SRC ] =imx_clk_mux2 ("usb_phy_ref_src" , base +0xb180 ,24 ,3 , imx8mq_usb_phy_sels,ARRAY_SIZE (imx8mq_usb_phy_sels)); + clks[IMX8MQ_CLK_ECSPI1_SRC ] =imx_clk_mux2 ("ecspi1_src" , base +0xb280 ,24 ,3 , imx8mq_ecspi1_sels,ARRAY_SIZE (imx8mq_ecspi1_sels)); + clks[IMX8MQ_CLK_ECSPI2_SRC ] =imx_clk_mux2 ("ecspi2_src" , base +0xb300 ,24 ,3 , imx8mq_ecspi2_sels,ARRAY_SIZE (imx8mq_ecspi2_sels)); + clks[IMX8MQ_CLK_PWM1_SRC ] =imx_clk_mux2 ("pwm1_src" , base +0xb380 ,24 ,3 , imx8mq_pwm1_sels,ARRAY_SIZE (imx8mq_pwm1_sels)); + clks[IMX8MQ_CLK_PWM2_SRC ] =imx_clk_mux2 ("pwm2_src" , base +0xb400 ,24 ,3 , imx8mq_pwm2_sels,ARRAY_SIZE (imx8mq_pwm2_sels)); + clks[IMX8MQ_CLK_PWM3_SRC ] =imx_clk_mux2 ("pwm3_src" , base +0xb480 ,24 ,3 , imx8mq_pwm3_sels,ARRAY_SIZE (imx8mq_pwm3_sels)); + clks[IMX8MQ_CLK_PWM4_SRC ] =imx_clk_mux2 ("pwm4_src" , base +0xb500 ,24 ,3 , imx8mq_pwm4_sels,ARRAY_SIZE (imx8mq_pwm4_sels)); + clks[IMX8MQ_CLK_GPT1_SRC ] =imx_clk_mux2 ("gpt1_src" , base +0xb580 ,24 ,3 , imx8mq_gpt1_sels,ARRAY_SIZE (imx8mq_gpt1_sels)); + clks[IMX8MQ_CLK_WDOG_SRC ] =imx_clk_mux2 ("wdog_src" , base +0xb900 ,24 ,3 , imx8mq_wdog_sels,ARRAY_SIZE (imx8mq_wdog_sels)); + clks[IMX8MQ_CLK_WRCLK_SRC ] =imx_clk_mux2 ("wrclk_src" , base +0xb980 ,24 ,3 , imx8mq_wrclk_sels,ARRAY_SIZE (imx8mq_wrclk_sels)); + clks[IMX8MQ_CLK_CLKO2_SRC ] =imx_clk_mux2 ("clko2_src" , base +0xba80 ,24 ,3 , imx8mq_clko2_sels,ARRAY_SIZE (imx8mq_clko2_sels)); + clks[IMX8MQ_CLK_DSI_CORE_SRC ] =imx_clk_mux2 ("dsi_core_src" , base +0xbb00 ,24 ,3 , imx8mq_dsi_core_sels,ARRAY_SIZE (imx8mq_dsi_core_sels)); + clks[IMX8MQ_CLK_DSI_PHY_REF_SRC ] =imx_clk_mux2 ("dsi_phy_ref_src" , base +0xbb80 ,24 ,3 , imx8mq_dsi_phy_sels,ARRAY_SIZE (imx8mq_dsi_phy_sels)); + clks[IMX8MQ_CLK_DSI_DBI_SRC ] =imx_clk_mux2 ("dsi_dbi_src" , base +0xbc00 ,24 ,3 , imx8mq_dsi_dbi_sels,ARRAY_SIZE (imx8mq_dsi_dbi_sels)); + clks[IMX8MQ_CLK_DSI_ESC_SRC ] =imx_clk_mux2 ("dsi_esc_src" , base +0xbc80 ,24 ,3 , imx8mq_dsi_esc_sels,ARRAY_SIZE (imx8mq_dsi_esc_sels)); + clks[IMX8MQ_CLK_DSI_AHB_SRC ] =imx_clk_mux2 ("dsi_ahb_src" , base +0x9200 ,24 ,3 , imx8mq_dsi_ahb_sels,ARRAY_SIZE (imx8mq_dsi_ahb_sels)); + clks[IMX8MQ_CLK_CSI1_CORE_SRC ] =imx_clk_mux2 ("csi1_core_src" , base +0xbd00 ,24 ,3 , imx8mq_csi1_core_sels,ARRAY_SIZE (imx8mq_csi1_core_sels)); + clks[IMX8MQ_CLK_CSI1_PHY_REF_SRC ] =imx_clk_mux2 ("csi1_phy_ref_src" , base +0xbd80 ,24 ,3 , imx8mq_csi1_phy_sels,ARRAY_SIZE (imx8mq_csi1_phy_sels)); + clks[IMX8MQ_CLK_CSI1_ESC_SRC ] =imx_clk_mux2 ("csi1_esc_src" , base +0xbe00 ,24 ,3 , imx8mq_csi1_esc_sels,ARRAY_SIZE (imx8mq_csi1_esc_sels)); + clks[IMX8MQ_CLK_CSI2_CORE_SRC ] =imx_clk_mux2 ("csi2_core_src" , base +0xbe80 ,24 ,3 , imx8mq_csi2_core_sels,ARRAY_SIZE (imx8mq_csi2_core_sels)); + clks[IMX8MQ_CLK_CSI2_PHY_REF_SRC ] =imx_clk_mux2 ("csi2_phy_ref_src" , base +0xbf00 ,24 ,3 , imx8mq_csi2_phy_sels,ARRAY_SIZE (imx8mq_csi2_phy_sels)); + clks[IMX8MQ_CLK_CSI2_ESC_SRC ] =imx_clk_mux2 ("csi2_esc_src" , base +0xbf80 ,24 ,3 , imx8mq_csi2_esc_sels,ARRAY_SIZE (imx8mq_csi2_esc_sels)); + clks[IMX8MQ_CLK_PCIE2_CTRL_SRC ] =imx_clk_mux2 ("pcie2_ctrl_src" , base +0xc000 ,24 ,3 , imx8mq_pcie2_ctrl_sels,ARRAY_SIZE (imx8mq_pcie2_ctrl_sels)); + clks[IMX8MQ_CLK_PCIE2_PHY_SRC ] =imx_clk_mux2 ("pcie2_phy_src" , base +0xc080 ,24 ,3 , imx8mq_pcie2_phy_sels,ARRAY_SIZE (imx8mq_pcie2_phy_sels)); + clks[IMX8MQ_CLK_PCIE2_AUX_SRC ] =imx_clk_mux2 ("pcie2_aux_src" , base +0xc100 ,24 ,3 , imx8mq_pcie2_aux_sels,ARRAY_SIZE (imx8mq_pcie2_aux_sels)); + clks[IMX8MQ_CLK_ECSPI3_SRC ] =imx_clk_mux2 ("ecspi3_src" , base +0xc180 ,24 ,3 , imx8mq_ecspi3_sels,ARRAY_SIZE (imx8mq_ecspi3_sels)); + + clks[IMX8MQ_CLK_DRAM_ALT_CG ] =imx_clk_gate3 ("dram_alt_cg" ,"dram_alt_src" , base +0xa000 ,28 ); + clks[IMX8MQ_CLK_DRAM_APB_CG ] =imx_clk_gate3 ("dram_apb_cg" ,"dram_apb_src" , base +0xa080 ,28 ); + clks[IMX8MQ_CLK_VPU_G1_CG ] =imx_clk_gate3 ("vpu_g1_cg" ,"vpu_g1_src" , base +0xa100 ,28 ); + clks[IMX8MQ_CLK_VPU_G2_CG ] =imx_clk_gate3 ("vpu_g2_cg" ,"vpu_g2_src" , base +0xa180 ,28 ); + clks[IMX8MQ_CLK_DISP_DTRC_CG ] =imx_clk_gate3 ("disp_dtrc_cg" ,"disp_dtrc_src" , base +0xa200 ,28 ); + clks[IMX8MQ_CLK_DISP_DC8000_CG ] =imx_clk_gate3 ("disp_dc8000_cg" ,"disp_dc8000_src" , base +0xa280 ,28 ); + clks[IMX8MQ_CLK_PCIE1_CTRL_CG ] =imx_clk_gate3 ("pcie1_ctrl_cg" ,"pcie1_ctrl_src" , base +0xa300 ,28 ); + clks[IMX8MQ_CLK_PCIE1_PHY_CG ] =imx_clk_gate3 ("pcie1_phy_cg" ,"pcie1_phy_src" , base +0xa380 ,28 ); + clks[IMX8MQ_CLK_PCIE1_AUX_CG ] =imx_clk_gate3 ("pcie1_aux_cg" ,"pcie1_aux_src" , base +0xa400 ,28 ); + clks[IMX8MQ_CLK_DC_PIXEL_CG ] =imx_clk_gate3 ("dc_pixel_cg" ,"dc_pixel_src" , base +0xa480 ,28 ); + clks[IMX8MQ_CLK_LCDIF_PIXEL_CG ] =imx_clk_gate3 ("lcdif_pixel_cg" ,"lcdif_pixel_src" , base +0xa500 ,28 ); + clks[IMX8MQ_CLK_SAI1_CG ] =imx_clk_gate3 ("sai1_cg" ,"sai1_src" , base +0xa580 ,28 ); + clks[IMX8MQ_CLK_SAI2_CG ] =imx_clk_gate3 ("sai2_cg" ,"sai2_src" , base +0xa600 ,28 ); + clks[IMX8MQ_CLK_SAI3_CG ] =imx_clk_gate3 ("sai3_cg" ,"sai3_src" , base +0xa680 ,28 ); + clks[IMX8MQ_CLK_SAI4_CG ] =imx_clk_gate3 ("sai4_cg" ,"sai4_src" , base +0xa700 ,28 ); + clks[IMX8MQ_CLK_SAI5_CG ] =imx_clk_gate3 ("sai5_cg" ,"sai5_src" , base +0xa780 ,28 ); + clks[IMX8MQ_CLK_SAI6_CG ] =imx_clk_gate3 ("sai6_cg" ,"sai6_src" , base +0xa800 ,28 ); + clks[IMX8MQ_CLK_SPDIF1_CG ] =imx_clk_gate3 ("spdif1_cg" ,"spdif1_src" , base +0xa880 ,28 ); + clks[IMX8MQ_CLK_SPDIF2_CG ] =imx_clk_gate3 ("spdif2_cg" ,"spdif2_src" , base +0xa900 ,28 ); + clks[IMX8MQ_CLK_ENET_REF_CG ] =imx_clk_gate3 ("enet_ref_cg" ,"enet_ref_src" , base +0xa980 ,28 ); + clks[IMX8MQ_CLK_ENET_TIMER_CG ] =imx_clk_gate3 ("enet_timer_cg" ,"enet_timer_src" , base +0xaa00 ,28 ); + clks[IMX8MQ_CLK_ENET_PHY_REF_CG ] =imx_clk_gate3 ("enet_phy_cg" ,"enet_phy_src" , base +0xaa80 ,28 ); + clks[IMX8MQ_CLK_NAND_CG ] =imx_clk_gate3 ("nand_cg" ,"nand_src" , base +0xab00 ,28 ); + clks[IMX8MQ_CLK_QSPI_CG ] =imx_clk_gate3 ("qspi_cg" ,"qspi_src" , base +0xab80 ,28 ); + clks[IMX8MQ_CLK_USDHC1_CG ] =imx_clk_gate3 ("usdhc1_cg" ,"usdhc1_src" , base +0xac00 ,28 ); + clks[IMX8MQ_CLK_USDHC2_CG ] =imx_clk_gate3 ("usdhc2_cg" ,"usdhc2_src" , base +0xac80 ,28 ); + clks[IMX8MQ_CLK_I2C1_CG ] =imx_clk_gate3 ("i2c1_cg" ,"i2c1_src" , base +0xad00 ,28 ); + clks[IMX8MQ_CLK_I2C2_CG ] =imx_clk_gate3 ("i2c2_cg" ,"i2c2_src" , base +0xad80 ,28 ); + clks[IMX8MQ_CLK_I2C3_CG ] =imx_clk_gate3 ("i2c3_cg" ,"i2c3_src" , base +0xae00 ,28 ); + clks[IMX8MQ_CLK_I2C4_CG ] =imx_clk_gate3 ("i2c4_cg" ,"i2c4_src" , base +0xae80 ,28 ); + clks[IMX8MQ_CLK_UART1_CG ] =imx_clk_gate3 ("uart1_cg" ,"uart1_src" , base +0xaf00 ,28 ); + clks[IMX8MQ_CLK_UART2_CG ] =imx_clk_gate3 ("uart2_cg" ,"uart2_src" , base +0xaf80 ,28 ); + clks[IMX8MQ_CLK_UART3_CG ] =imx_clk_gate3 ("uart3_cg" ,"uart3_src" , base +0xb000 ,28 ); + clks[IMX8MQ_CLK_UART4_CG ] =imx_clk_gate3 ("uart4_cg" ,"uart4_src" , base +0xb080 ,28 ); + clks[IMX8MQ_CLK_USB_CORE_REF_CG ] =imx_clk_gate3 ("usb_core_ref_cg" ,"usb_core_ref_src" , base +0xb100 ,28 ); + clks[IMX8MQ_CLK_USB_PHY_REF_CG ] =imx_clk_gate3 ("usb_phy_ref_cg" ,"usb_phy_ref_src" , base +0xb180 ,28 ); + clks[IMX8MQ_CLK_ECSPI1_CG ] =imx_clk_gate3 ("ecspi1_cg" ,"ecspi1_src" , base +0xb280 ,28 ); + clks[IMX8MQ_CLK_ECSPI2_CG ] =imx_clk_gate3 ("ecspi2_cg" ,"ecspi2_src" , base +0xb300 ,28 ); + clks[IMX8MQ_CLK_PWM1_CG ] =imx_clk_gate3 ("pwm1_cg" ,"pwm1_src" , base +0xb380 ,28 ); + clks[IMX8MQ_CLK_PWM2_CG ] =imx_clk_gate3 ("pwm2_cg" ,"pwm2_src" , base +0xb400 ,28 ); + clks[IMX8MQ_CLK_PWM3_CG ] =imx_clk_gate3 ("pwm3_cg" ,"pwm3_src" , base +0xb480 ,28 ); + clks[IMX8MQ_CLK_PWM4_CG ] =imx_clk_gate3 ("pwm4_cg" ,"pwm4_src" , base +0xb500 ,28 ); + clks[IMX8MQ_CLK_GPT1_CG ] =imx_clk_gate3 ("gpt1_cg" ,"gpt1_src" , base +0xb580 ,28 ); + clks[IMX8MQ_CLK_WDOG_CG ] =imx_clk_gate3 ("wdog_cg" ,"wdog_src" , base +0xb900 ,28 ); + clks[IMX8MQ_CLK_WRCLK_CG ] =imx_clk_gate3 ("wrclk_cg" ,"wrclk_src" , base +0xb980 ,28 ); + clks[IMX8MQ_CLK_CLKO2_CG ] =imx_clk_gate3 ("clko2_cg" ,"clko2_src" , base +0xba80 ,28 ); + clks[IMX8MQ_CLK_DSI_CORE_CG ] =imx_clk_gate3 ("dsi_core_cg" ,"dsi_core_src" , base +0xbb00 ,28 ); + clks[IMX8MQ_CLK_DSI_PHY_REF_CG ] =imx_clk_gate3 ("dsi_phy_ref_cg" ,"dsi_phy_ref_src" , base +0xbb80 ,28 ); + clks[IMX8MQ_CLK_DSI_DBI_CG ] =imx_clk_gate3 ("dsi_dbi_cg" ,"dsi_dbi_src" , base +0xbc00 ,28 ); + clks[IMX8MQ_CLK_DSI_ESC_CG ] =imx_clk_gate3 ("dsi_esc_cg" ,"dsi_esc_src" , base +0xbc80 ,28 ); + clks[IMX8MQ_CLK_DSI_AHB_CG ] =imx_clk_gate3 ("dsi_ahb_cg" ,"dsi_ahb_src" , base +0x9200 ,28 ); + clks[IMX8MQ_CLK_CSI1_CORE_CG ] =imx_clk_gate3 ("csi1_core_cg" ,"csi1_core_src" , base +0xbd00 ,28 ); + clks[IMX8MQ_CLK_CSI1_PHY_REF_CG ] =imx_clk_gate3 ("csi1_phy_ref_cg" ,"csi1_phy_ref_src" , base +0xbd80 ,28 ); + clks[IMX8MQ_CLK_CSI1_ESC_CG ] =imx_clk_gate3 ("csi1_esc_cg" ,"csi1_esc_src" , base +0xbe00 ,28 ); + clks[IMX8MQ_CLK_CSI2_CORE_CG ] =imx_clk_gate3 ("csi2_core_cg" ,"csi2_core_src" , base +0xbe80 ,28 ); + clks[IMX8MQ_CLK_CSI2_PHY_REF_CG ] =imx_clk_gate3 ("csi2_phy_ref_cg" ,"csi2_phy_ref_src" , base +0xbf00 ,28 ); + clks[IMX8MQ_CLK_CSI2_ESC_CG ] =imx_clk_gate3 ("csi2_esc_cg" ,"csi2_esc_src" , base +0xbf80 ,28 ); + clks[IMX8MQ_CLK_PCIE2_CTRL_CG ] =imx_clk_gate3 ("pcie2_ctrl_cg" ,"pcie2_ctrl_src" , base +0xc000 ,28 ); + clks[IMX8MQ_CLK_PCIE2_PHY_CG ] =imx_clk_gate3 ("pcie2_phy_cg" ,"pcie2_phy_src" , base +0xc080 ,28 ); + clks[IMX8MQ_CLK_PCIE2_AUX_CG ] =imx_clk_gate3 ("pcie2_aux_cg" ,"pcie2_aux_src" , base +0xc100 ,28 ); + clks[IMX8MQ_CLK_ECSPI3_CG ] =imx_clk_gate3 ("ecspi3_cg" ,"ecspi3_src" , base +0xc180 ,28 ); + + clks[IMX8MQ_CLK_DRAM_ALT_PRE_DIV ] =imx_clk_divider2 ("dram_alt_pre_div" ,"dram_alt_cg" , base +0xa000 ,16 ,3 ); + clks[IMX8MQ_CLK_DRAM_APB_PRE_DIV ] =imx_clk_divider_flags ("dram_apb_pre_div" ,"dram_apb_cg" , base +0xa080 ,16 ,3 ,CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_VPU_G1_PRE_DIV ] =imx_clk_divider_flags ("vpu_g1_pre_div" ,"vpu_g1_cg" , base +0xa100 ,16 ,3 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_VPU_G2_PRE_DIV ] =imx_clk_divider_flags ("vpu_g2_pre_div" ,"vpu_g2_cg" , base +0xa180 ,16 ,3 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_DISP_DTRC_PRE_DIV ] =imx_clk_divider2 ("disp_dtrc_pre_div" ,"disp_dtrc_cg" , base +0xa200 ,16 ,3 ); + clks[IMX8MQ_CLK_DISP_DC8000_PRE_DIV ] =imx_clk_divider2 ("disp_dc8000_pre_div" ,"disp_dc8000_cg" , base +0xa280 ,16 ,3 ); + clks[IMX8MQ_CLK_PCIE1_CTRL_PRE_DIV ] =imx_clk_divider2 ("pcie1_ctrl_pre_div" ,"pcie1_ctrl_cg" , base +0xa300 ,16 ,3 ); + clks[IMX8MQ_CLK_PCIE1_PHY_PRE_DIV ] =imx_clk_divider2 ("pcie1_phy_pre_div" ,"pcie1_phy_cg" , base +0xa380 ,16 ,3 ); + clks[IMX8MQ_CLK_PCIE1_AUX_PRE_DIV ] =imx_clk_divider2 ("pcie1_aux_pre_div" ,"pcie1_aux_cg" , base +0xa400 ,16 ,3 ); + clks[IMX8MQ_CLK_DC_PIXEL_PRE_DIV ] =imx_clk_divider2 ("dc_pixel_pre_div" ,"dc_pixel_cg" , base +0xa480 ,16 ,3 ); + clks[IMX8MQ_CLK_LCDIF_PIXEL_PRE_DIV ] =imx_clk_divider2 ("lcdif_pixel_pre_div" ,"lcdif_pixel_cg" , base +0xa500 ,16 ,3 ); + clks[IMX8MQ_CLK_SAI1_PRE_DIV ] =imx_clk_divider2 ("sai1_pre_div" ,"sai1_cg" , base +0xa580 ,16 ,3 ); + clks[IMX8MQ_CLK_SAI2_PRE_DIV ] =imx_clk_divider2 ("sai2_pre_div" ,"sai2_cg" , base +0xa600 ,16 ,3 ); + clks[IMX8MQ_CLK_SAI3_PRE_DIV ] =imx_clk_divider2 ("sai3_pre_div" ,"sai3_cg" , base +0xa680 ,16 ,3 ); + clks[IMX8MQ_CLK_SAI4_PRE_DIV ] =imx_clk_divider2 ("sai4_pre_div" ,"sai4_cg" , base +0xa700 ,16 ,3 ); + clks[IMX8MQ_CLK_SAI5_PRE_DIV ] =imx_clk_divider2 ("sai5_pre_div" ,"sai5_cg" , base +0xa780 ,16 ,3 ); + clks[IMX8MQ_CLK_SAI6_PRE_DIV ] =imx_clk_divider2 ("sai6_pre_div" ,"sai6_cg" , base +0xa800 ,16 ,3 ); + clks[IMX8MQ_CLK_SPDIF1_PRE_DIV ] =imx_clk_divider2 ("spdif1_pre_div" ,"spdif1_cg" , base +0xa880 ,16 ,3 ); + clks[IMX8MQ_CLK_SPDIF2_PRE_DIV ] =imx_clk_divider2 ("spdif2_pre_div" ,"spdif2_cg" , base +0xa900 ,16 ,3 ); + clks[IMX8MQ_CLK_ENET_REF_PRE_DIV ] =imx_clk_divider2 ("enet_ref_pre_div" ,"enet_ref_cg" , base +0xa980 ,16 ,3 ); + clks[IMX8MQ_CLK_ENET_TIMER_PRE_DIV ] =imx_clk_divider2 ("enet_timer_pre_div" ,"enet_timer_cg" , base +0xaa00 ,16 ,3 ); + clks[IMX8MQ_CLK_ENET_PHY_REF_PRE_DIV ] =imx_clk_divider2 ("enet_phy_pre_div" ,"enet_phy_cg" , base +0xaa80 ,16 ,3 ); + clks[IMX8MQ_CLK_NAND_PRE_DIV ] =imx_clk_divider2 ("nand_pre_div" ,"nand_cg" , base +0xab00 ,16 ,3 ); + clks[IMX8MQ_CLK_QSPI_PRE_DIV ] =imx_clk_divider2 ("qspi_pre_div" ,"qspi_cg" , base +0xab80 ,16 ,3 ); + clks[IMX8MQ_CLK_USDHC1_PRE_DIV ] =imx_clk_divider2 ("usdhc1_pre_div" ,"usdhc1_cg" , base +0xac00 ,16 ,3 ); + clks[IMX8MQ_CLK_USDHC2_PRE_DIV ] =imx_clk_divider2 ("usdhc2_pre_div" ,"usdhc2_cg" , base +0xac80 ,16 ,3 ); + clks[IMX8MQ_CLK_I2C1_PRE_DIV ] =imx_clk_divider2 ("i2c1_pre_div" ,"i2c1_cg" , base +0xad00 ,16 ,3 ); + clks[IMX8MQ_CLK_I2C2_PRE_DIV ] =imx_clk_divider2 ("i2c2_pre_div" ,"i2c2_cg" , base +0xad80 ,16 ,3 ); + clks[IMX8MQ_CLK_I2C3_PRE_DIV ] =imx_clk_divider2 ("i2c3_pre_div" ,"i2c3_cg" , base +0xae00 ,16 ,3 ); + clks[IMX8MQ_CLK_I2C4_PRE_DIV ] =imx_clk_divider2 ("i2c4_pre_div" ,"i2c4_cg" , base +0xae80 ,16 ,3 ); + clks[IMX8MQ_CLK_UART1_PRE_DIV ] =imx_clk_divider2 ("uart1_pre_div" ,"uart1_cg" , base +0xaf00 ,16 ,3 ); + clks[IMX8MQ_CLK_UART2_PRE_DIV ] =imx_clk_divider2 ("uart2_pre_div" ,"uart2_cg" , base +0xaf80 ,16 ,3 ); + clks[IMX8MQ_CLK_UART3_PRE_DIV ] =imx_clk_divider2 ("uart3_pre_div" ,"uart3_cg" , base +0xb000 ,16 ,3 ); + clks[IMX8MQ_CLK_UART4_PRE_DIV ] =imx_clk_divider2 ("uart4_pre_div" ,"uart4_cg" , base +0xb080 ,16 ,3 ); + clks[IMX8MQ_CLK_USB_CORE_REF_PRE_DIV ] =imx_clk_divider2 ("usb_core_ref_pre_div" ,"usb_core_ref_cg" , base +0xb100 ,16 ,3 ); + clks[IMX8MQ_CLK_USB_PHY_REF_PRE_DIV ] =imx_clk_divider2 ("usb_phy_ref_pre_div" ,"usb_phy_ref_cg" , base +0xb180 ,16 ,3 ); + clks[IMX8MQ_CLK_ECSPI1_PRE_DIV ] =imx_clk_divider2 ("ecspi1_pre_div" ,"ecspi1_cg" , base +0xb280 ,16 ,3 ); + clks[IMX8MQ_CLK_ECSPI2_PRE_DIV ] =imx_clk_divider2 ("ecspi2_pre_div" ,"ecspi2_cg" , base +0xb300 ,16 ,3 ); + clks[IMX8MQ_CLK_PWM1_PRE_DIV ] =imx_clk_divider2 ("pwm1_pre_div" ,"pwm1_cg" , base +0xb380 ,16 ,3 ); + clks[IMX8MQ_CLK_PWM2_PRE_DIV ] =imx_clk_divider2 ("pwm2_pre_div" ,"pwm2_cg" , base +0xb400 ,16 ,3 ); + clks[IMX8MQ_CLK_PWM3_PRE_DIV ] =imx_clk_divider2 ("pwm3_pre_div" ,"pwm3_cg" , base +0xb480 ,16 ,3 ); + clks[IMX8MQ_CLK_PWM4_PRE_DIV ] =imx_clk_divider2 ("pwm4_pre_div" ,"pwm4_cg" , base +0xb500 ,16 ,3 ); + clks[IMX8MQ_CLK_GPT1_PRE_DIV ] =imx_clk_divider2 ("gpt1_pre_div" ,"gpt1_cg" , base +0xb580 ,16 ,3 ); + clks[IMX8MQ_CLK_WDOG_PRE_DIV ] =imx_clk_divider2 ("wdog_pre_div" ,"wdog_cg" , base +0xb900 ,16 ,3 ); + clks[IMX8MQ_CLK_WRCLK_PRE_DIV ] =imx_clk_divider2 ("wrclk_pre_div" ,"wrclk_cg" , base +0xb980 ,16 ,3 ); + clks[IMX8MQ_CLK_CLKO2_PRE_DIV ] =imx_clk_divider2 ("clko2_pre_div" ,"clko2_cg" , base +0xba80 ,16 ,3 ); + clks[IMX8MQ_CLK_DSI_CORE_PRE_DIV ] =imx_clk_divider2 ("dsi_core_pre_div" ,"dsi_core_cg" , base +0xbb00 ,16 ,3 ); + clks[IMX8MQ_CLK_DSI_PHY_REF_PRE_DIV ] =imx_clk_divider2 ("dsi_phy_ref_pre_div" ,"dsi_phy_ref_cg" , base +0xbb80 ,16 ,3 ); + clks[IMX8MQ_CLK_DSI_DBI_PRE_DIV ] =imx_clk_divider2 ("dsi_dbi_pre_div" ,"dsi_dbi_cg" , base +0xbc00 ,16 ,3 ); + clks[IMX8MQ_CLK_DSI_ESC_PRE_DIV ] =imx_clk_divider2 ("dsi_esc_pre_div" ,"dsi_esc_cg" , base +0xbc80 ,16 ,3 ); + clks[IMX8MQ_CLK_DSI_AHB_PRE_DIV ] =imx_clk_divider2 ("dsi_ahb_pre_div" ,"dsi_ahb_cg" , base +0x9200 ,16 ,3 ); + clks[IMX8MQ_CLK_CSI1_CORE_PRE_DIV ] =imx_clk_divider2 ("csi1_core_pre_div" ,"csi1_core_cg" , base +0xbd00 ,16 ,3 ); + clks[IMX8MQ_CLK_CSI1_PHY_REF_PRE_DIV ] =imx_clk_divider2 ("csi1_phy_ref_pre_div" ,"csi1_phy_ref_cg" , base +0xbd80 ,16 ,3 ); + clks[IMX8MQ_CLK_CSI1_ESC_PRE_DIV ] =imx_clk_divider2 ("csi1_esc_pre_div" ,"csi1_esc_cg" , base +0xbe00 ,16 ,3 ); + clks[IMX8MQ_CLK_CSI2_CORE_PRE_DIV ] =imx_clk_divider2 ("csi2_core_pre_div" ,"csi2_core_cg" , base +0xbe80 ,16 ,3 ); + clks[IMX8MQ_CLK_CSI2_PHY_REF_PRE_DIV ] =imx_clk_divider2 ("csi2_phy_ref_pre_div" ,"csi2_phy_ref_cg" , base +0xbf00 ,16 ,3 ); + clks[IMX8MQ_CLK_CSI2_ESC_PRE_DIV ] =imx_clk_divider2 ("csi2_esc_pre_div" ,"csi2_esc_cg" , base +0xbf80 ,16 ,3 ); + clks[IMX8MQ_CLK_PCIE2_CTRL_PRE_DIV ] =imx_clk_divider2 ("pcie2_ctrl_pre_div" ,"pcie2_ctrl_cg" , base +0xc000 ,16 ,3 ); + clks[IMX8MQ_CLK_PCIE2_PHY_PRE_DIV ] =imx_clk_divider2 ("pcie2_phy_pre_div" ,"pcie2_phy_cg" , base +0xc080 ,16 ,3 ); + clks[IMX8MQ_CLK_PCIE2_AUX_PRE_DIV ] =imx_clk_divider2 ("pcie2_aux_pre_div" ,"pcie2_aux_cg" , base +0xc100 ,16 ,3 ); + clks[IMX8MQ_CLK_ECSPI3_PRE_DIV ] =imx_clk_divider2 ("ecspi3_pre_div" ,"ecspi3_cg" , base +0xc180 ,16 ,3 ); + + clks[IMX8MQ_CLK_DRAM_ALT_DIV ] =imx_clk_divider2 ("dram_alt_div" ,"dram_alt_pre_div" , base +0xa000 ,0 ,6 ); + clks[IMX8MQ_CLK_DRAM_APB_DIV ] =imx_clk_divider2_flags ("dram_apb_div" ,"dram_apb_pre_div" , base +0xa080 ,0 ,6 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_VPU_G1_DIV ] =imx_clk_divider_flags ("vpu_g1_div" ,"vpu_g1_pre_div" , base +0xa100 ,0 ,6 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_VPU_G2_DIV ] =imx_clk_divider_flags ("vpu_g2_div" ,"vpu_g2_pre_div" , base +0xa180 ,0 ,6 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_DISP_DTRC_DIV ] =imx_clk_divider2 ("disp_dtrc_div" ,"disp_dtrc_pre_div" , base +0xa200 ,0 ,6 ); + clks[IMX8MQ_CLK_DISP_DC8000_DIV ] =imx_clk_divider2 ("disp_dc8000_div" ,"disp_dc8000_pre_div" , base +0xa280 ,0 ,6 ); + clks[IMX8MQ_CLK_PCIE1_CTRL_DIV ] =imx_clk_divider2 ("pcie1_ctrl_div" ,"pcie1_ctrl_pre_div" , base +0xa300 ,0 ,6 ); + clks[IMX8MQ_CLK_PCIE1_PHY_DIV ] =imx_clk_divider2 ("pcie1_phy_div" ,"pcie1_phy_pre_div" , base +0xa380 ,0 ,6 ); + clks[IMX8MQ_CLK_PCIE1_AUX_DIV ] =imx_clk_divider2 ("pcie1_aux_div" ,"pcie1_aux_pre_div" , base +0xa400 ,0 ,6 ); + clks[IMX8MQ_CLK_DC_PIXEL_DIV ] =imx_clk_divider2 ("dc_pixel_div" ,"dc_pixel_pre_div" , base +0xa480 ,0 ,6 ); + clks[IMX8MQ_CLK_LCDIF_PIXEL_DIV ] =imx_clk_divider2 ("lcdif_pixel_div" ,"lcdif_pixel_pre_div" , base +0xa500 ,0 ,6 ); + clks[IMX8MQ_CLK_SAI1_DIV ] =imx_clk_divider2 ("sai1_div" ,"sai1_pre_div" , base +0xa580 ,0 ,6 ); + clks[IMX8MQ_CLK_SAI2_DIV ] =imx_clk_divider2 ("sai2_div" ,"sai2_pre_div" , base +0xa600 ,0 ,6 ); + clks[IMX8MQ_CLK_SAI3_DIV ] =imx_clk_divider2 ("sai3_div" ,"sai3_pre_div" , base +0xa680 ,0 ,6 ); + clks[IMX8MQ_CLK_SAI4_DIV ] =imx_clk_divider2 ("sai4_div" ,"sai4_pre_div" , base +0xa700 ,0 ,6 ); + clks[IMX8MQ_CLK_SAI5_DIV ] =imx_clk_divider2 ("sai5_div" ,"sai5_pre_div" , base +0xa780 ,0 ,6 ); + clks[IMX8MQ_CLK_SAI6_DIV ] =imx_clk_divider2 ("sai6_div" ,"sai6_pre_div" , base +0xa800 ,0 ,6 ); + clks[IMX8MQ_CLK_SPDIF1_DIV ] =imx_clk_divider2 ("spdif1_div" ,"spdif1_pre_div" , base +0xa880 ,0 ,6 ); + clks[IMX8MQ_CLK_SPDIF2_DIV ] =imx_clk_divider2 ("spdif2_div" ,"spdif2_pre_div" , base +0xa900 ,0 ,6 ); + clks[IMX8MQ_CLK_ENET_REF_DIV ] =imx_clk_divider2 ("enet_ref_div" ,"enet_ref_pre_div" , base +0xa980 ,0 ,6 ); + clks[IMX8MQ_CLK_ENET_TIMER_DIV ] =imx_clk_divider2 ("enet_timer_div" ,"enet_timer_pre_div" , base +0xaa00 ,0 ,6 ); + clks[IMX8MQ_CLK_ENET_PHY_REF_DIV ] =imx_clk_divider2 ("enet_phy_div" ,"enet_phy_pre_div" , base +0xaa80 ,0 ,6 ); + clks[IMX8MQ_CLK_NAND_DIV ] =imx_clk_divider2 ("nand_div" ,"nand_pre_div" , base +0xab00 ,0 ,6 ); + clks[IMX8MQ_CLK_QSPI_DIV ] =imx_clk_divider2 ("qspi_div" ,"qspi_pre_div" , base +0xab80 ,0 ,6 ); + clks[IMX8MQ_CLK_USDHC1_DIV ] =imx_clk_divider2 ("usdhc1_div" ,"usdhc1_pre_div" , base +0xac00 ,0 ,6 ); + clks[IMX8MQ_CLK_USDHC2_DIV ] =imx_clk_divider2 ("usdhc2_div" ,"usdhc2_pre_div" , base +0xac80 ,0 ,6 ); + clks[IMX8MQ_CLK_I2C1_DIV ] =imx_clk_divider2 ("i2c1_div" ,"i2c1_pre_div" , base +0xad00 ,0 ,6 ); + clks[IMX8MQ_CLK_I2C2_DIV ] =imx_clk_divider2 ("i2c2_div" ,"i2c2_pre_div" , base +0xad80 ,0 ,6 ); + clks[IMX8MQ_CLK_I2C3_DIV ] =imx_clk_divider2 ("i2c3_div" ,"i2c3_pre_div" , base +0xae00 ,0 ,6 ); + clks[IMX8MQ_CLK_I2C4_DIV ] =imx_clk_divider2 ("i2c4_div" ,"i2c4_pre_div" , base +0xae80 ,0 ,6 ); + clks[IMX8MQ_CLK_UART1_DIV ] =imx_clk_divider2 ("uart1_div" ,"uart1_pre_div" , base +0xaf00 ,0 ,6 ); + clks[IMX8MQ_CLK_UART2_DIV ] =imx_clk_divider2 ("uart2_div" ,"uart2_pre_div" , base +0xaf80 ,0 ,6 ); + clks[IMX8MQ_CLK_UART3_DIV ] =imx_clk_divider2 ("uart3_div" ,"uart3_pre_div" , base +0xb000 ,0 ,6 ); + clks[IMX8MQ_CLK_UART4_DIV ] =imx_clk_divider2 ("uart4_div" ,"uart4_pre_div" , base +0xb080 ,0 ,6 ); + clks[IMX8MQ_CLK_USB_CORE_REF_DIV ] =imx_clk_divider2 ("usb_core_ref_div" ,"usb_core_ref_pre_div" , base +0xb100 ,0 ,6 ); + clks[IMX8MQ_CLK_USB_PHY_REF_DIV ] =imx_clk_divider2 ("usb_phy_ref_div" ,"usb_phy_ref_pre_div" , base +0xb180 ,0 ,6 ); + clks[IMX8MQ_CLK_ECSPI1_DIV ] =imx_clk_divider2 ("ecspi1_div" ,"ecspi1_pre_div" , base +0xb280 ,0 ,6 ); + clks[IMX8MQ_CLK_ECSPI2_DIV ] =imx_clk_divider2 ("ecspi2_div" ,"ecspi2_pre_div" , base +0xb300 ,0 ,6 ); + clks[IMX8MQ_CLK_PWM1_DIV ] =imx_clk_divider2 ("pwm1_div" ,"pwm1_pre_div" , base +0xb380 ,0 ,6 ); + clks[IMX8MQ_CLK_PWM2_DIV ] =imx_clk_divider2 ("pwm2_div" ,"pwm2_pre_div" , base +0xb400 ,0 ,6 ); + clks[IMX8MQ_CLK_PWM3_DIV ] =imx_clk_divider2 ("pwm3_div" ,"pwm3_pre_div" , base +0xb480 ,0 ,6 ); + clks[IMX8MQ_CLK_PWM4_DIV ] =imx_clk_divider2 ("pwm4_div" ,"pwm4_pre_div" , base +0xb500 ,0 ,6 ); + clks[IMX8MQ_CLK_GPT1_DIV ] =imx_clk_divider2 ("gpt1_div" ,"gpt1_pre_div" , base +0xb580 ,0 ,6 ); + clks[IMX8MQ_CLK_WDOG_DIV ] =imx_clk_divider2 ("wdog_div" ,"wdog_pre_div" , base +0xb900 ,0 ,6 ); + clks[IMX8MQ_CLK_WRCLK_DIV ] =imx_clk_divider2 ("wrclk_div" ,"wrclk_pre_div" , base +0xb980 ,0 ,6 ); + clks[IMX8MQ_CLK_CLKO2_DIV ] =imx_clk_divider2 ("clko2_div" ,"clko2_pre_div" , base +0xba80 ,0 ,6 ); + clks[IMX8MQ_CLK_DSI_CORE_DIV ] =imx_clk_divider2 ("dsi_core_div" ,"dsi_core_pre_div" , base +0xbb00 ,0 ,6 ); + clks[IMX8MQ_CLK_DSI_PHY_REF_DIV ] =imx_clk_divider2 ("dsi_phy_ref_div" ,"dsi_phy_ref_pre_div" , base +0xbb80 ,0 ,6 ); + clks[IMX8MQ_CLK_DSI_DBI_DIV ] =imx_clk_divider2 ("dsi_dbi_div" ,"dsi_dbi_pre_div" , base +0xbc00 ,0 ,6 ); + clks[IMX8MQ_CLK_DSI_ESC_DIV ] =imx_clk_divider2 ("dsi_esc_div" ,"dsi_esc_pre_div" , base +0xbc80 ,0 ,6 ); + clks[IMX8MQ_CLK_DSI_AHB_DIV ] =imx_clk_divider2 ("dsi_ahb_div" ,"dsi_ahb_pre_div" , base +0x9200 ,0 ,6 ); + clks[IMX8MQ_CLK_DSI_IPG_DIV ] =imx_clk_divider2 ("dsi_ipg_div" ,"dsi_ahb_div" , base +0x9280 ,0 ,6 ); + clks[IMX8MQ_CLK_CSI1_CORE_DIV ] =imx_clk_divider2 ("csi1_core_div" ,"csi1_core_pre_div" , base +0xbd00 ,0 ,6 ); + clks[IMX8MQ_CLK_CSI1_PHY_REF_DIV ] =imx_clk_divider2 ("csi1_phy_ref_div" ,"csi1_phy_ref_pre_div" , base +0xbd80 ,0 ,6 ); + clks[IMX8MQ_CLK_CSI1_ESC_DIV ] =imx_clk_divider2 ("csi1_esc_div" ,"csi1_esc_pre_div" , base +0xbe00 ,0 ,6 ); + clks[IMX8MQ_CLK_CSI2_CORE_DIV ] =imx_clk_divider2 ("csi2_core_div" ,"csi2_core_pre_div" , base +0xbe80 ,0 ,6 ); + clks[IMX8MQ_CLK_CSI2_PHY_REF_DIV ] =imx_clk_divider2 ("csi2_phy_ref_div" ,"csi2_phy_ref_pre_div" , base +0xbf00 ,0 ,6 ); + clks[IMX8MQ_CLK_CSI2_ESC_DIV ] =imx_clk_divider2 ("csi2_esc_div" ,"csi2_esc_pre_div" , base +0xbf80 ,0 ,6 ); + clks[IMX8MQ_CLK_PCIE2_CTRL_DIV ] =imx_clk_divider2 ("pcie2_ctrl_div" ,"pcie2_ctrl_pre_div" , base +0xc000 ,0 ,6 ); + clks[IMX8MQ_CLK_PCIE2_PHY_DIV ] =imx_clk_divider2 ("pcie2_phy_div" ,"pcie2_phy_pre_div" , base +0xc080 ,0 ,6 ); + clks[IMX8MQ_CLK_PCIE2_AUX_DIV ] =imx_clk_divider2 ("pcie2_aux_div" ,"pcie2_aux_pre_div" , base +0xc100 ,0 ,6 ); + clks[IMX8MQ_CLK_ECSPI3_DIV ] =imx_clk_divider2 ("ecspi3_div" ,"ecspi3_pre_div" , base +0xc180 ,0 ,6 ); + +/*FIXME, the doc is not ready now */ + clks[IMX8MQ_CLK_ECSPI1_ROOT ] =imx_clk_gate4 ("ecspi1_root_clk" ,"ecspi1_div" , base +0x4070 ,0 ); + clks[IMX8MQ_CLK_ECSPI2_ROOT ] =imx_clk_gate4 ("ecspi2_root_clk" ,"ecspi2_div" , base +0x4080 ,0 ); + clks[IMX8MQ_CLK_ECSPI3_ROOT ] =imx_clk_gate4 ("ecspi3_root_clk" ,"ecspi3_div" , base +0x4090 ,0 ); + clks[IMX8MQ_CLK_ENET1_ROOT ] =imx_clk_gate4 ("enet1_root_clk" ,"enet_axi_div" , base +0x40a0 ,0 ); + clks[IMX8MQ_CLK_GPT1_ROOT ] =imx_clk_gate4 ("gpt1_root_clk" ,"gpt1_div" , base +0x4100 ,0 ); + clks[IMX8MQ_CLK_I2C1_ROOT ] =imx_clk_gate4 ("i2c1_root_clk" ,"i2c1_div" , base +0x4170 ,0 ); + clks[IMX8MQ_CLK_I2C2_ROOT ] =imx_clk_gate4 ("i2c2_root_clk" ,"i2c2_div" , base +0x4180 ,0 ); + clks[IMX8MQ_CLK_I2C3_ROOT ] =imx_clk_gate4 ("i2c3_root_clk" ,"i2c3_div" , base +0x4190 ,0 ); + clks[IMX8MQ_CLK_I2C4_ROOT ] =imx_clk_gate4 ("i2c4_root_clk" ,"i2c4_div" , base +0x41a0 ,0 ); + clks[IMX8MQ_CLK_MU_ROOT ] =imx_clk_gate4 ("mu_root_clk" ,"ipg_root" , base +0x4210 ,0 ); + clks[IMX8MQ_CLK_OCOTP_ROOT ] =imx_clk_gate4 ("ocotp_root_clk" ,"ipg_root" , base +0x4220 ,0 ); + clks[IMX8MQ_CLK_PCIE1_ROOT ] =imx_clk_gate4 ("pcie1_root_clk" ,"pcie1_ctrl_div" , base +0x4250 ,0 ); + clks[IMX8MQ_CLK_PCIE2_ROOT ] =imx_clk_gate4 ("pcie2_root_clk" ,"pcie2_ctrl_div" , base +0x4640 ,0 ); + clks[IMX8MQ_CLK_PWM1_ROOT ] =imx_clk_gate4 ("pwm1_root_clk" ,"pwm1_div" , base +0x4280 ,0 ); + clks[IMX8MQ_CLK_PWM2_ROOT ] =imx_clk_gate4 ("pwm2_root_clk" ,"pwm2_div" , base +0x4290 ,0 ); + clks[IMX8MQ_CLK_PWM3_ROOT ] =imx_clk_gate4 ("pwm3_root_clk" ,"pwm3_div" , base +0x42a0 ,0 ); + clks[IMX8MQ_CLK_PWM4_ROOT ] =imx_clk_gate4 ("pwm4_root_clk" ,"pwm4_div" , base +0x42b0 ,0 ); + clks[IMX8MQ_CLK_QSPI_ROOT ] =imx_clk_gate4 ("qspi_root_clk" ,"qspi_div" , base +0x42f0 ,0 ); + clks[IMX8MQ_CLK_RAWNAND_ROOT ] =imx_clk_gate2_shared2 ("nand_root_clk" ,"nand_div" , base +0x4300 ,0 , &share_count_nand); + clks[IMX8MQ_CLK_NAND_USDHC_BUS_RAWNAND_CLK ] =imx_clk_gate2_shared2 ("nand_usdhc_rawnand_clk" ,"nand_usdhc_bus_div" , base +0x4300 ,0 , &share_count_nand); + clks[IMX8MQ_CLK_SAI1_ROOT ] =imx_clk_gate2_shared2 ("sai1_root_clk" ,"sai1_div" , base +0x4330 ,0 , &share_count_sai1); + clks[IMX8MQ_CLK_SAI1_IPG ] =imx_clk_gate2_shared2 ("sai1_ipg_clk" ,"ipg_audio_root" , base +0x4330 ,0 , &share_count_sai1); + clks[IMX8MQ_CLK_SAI2_ROOT ] =imx_clk_gate2_shared2 ("sai2_root_clk" ,"sai2_div" , base +0x4340 ,0 , &share_count_sai2); + clks[IMX8MQ_CLK_SAI2_IPG ] =imx_clk_gate2_shared2 ("sai2_ipg_clk" ,"ipg_root" , base +0x4340 ,0 , &share_count_sai2); + clks[IMX8MQ_CLK_SAI3_ROOT ] =imx_clk_gate2_shared2 ("sai3_root_clk" ,"sai3_div" , base +0x4350 ,0 , &share_count_sai3); + clks[IMX8MQ_CLK_SAI3_IPG ] =imx_clk_gate2_shared2 ("sai3_ipg_clk" ,"ipg_root" , base +0x4350 ,0 , &share_count_sai3); + clks[IMX8MQ_CLK_SAI4_ROOT ] =imx_clk_gate2_shared2 ("sai4_root_clk" ,"sai4_div" , base +0x4360 ,0 , &share_count_sai4); + clks[IMX8MQ_CLK_SAI4_IPG ] =imx_clk_gate2_shared2 ("sai4_ipg_clk" ,"ipg_audio_root" , base +0x4360 ,0 , &share_count_sai4); + clks[IMX8MQ_CLK_SAI5_ROOT ] =imx_clk_gate2_shared2 ("sai5_root_clk" ,"sai5_div" , base +0x4370 ,0 , &share_count_sai5); + clks[IMX8MQ_CLK_SAI5_IPG ] =imx_clk_gate2_shared2 ("sai5_ipg_clk" ,"ipg_audio_root" , base +0x4370 ,0 , &share_count_sai5); + clks[IMX8MQ_CLK_SAI6_ROOT ] =imx_clk_gate2_shared2 ("sai6_root_clk" ,"sai6_div" , base +0x4380 ,0 , &share_count_sai6); + clks[IMX8MQ_CLK_SAI6_IPG ] =imx_clk_gate2_shared2 ("sai6_ipg_clk" ,"ipg_audio_root" , base +0x4380 ,0 , &share_count_sai6); + clks[IMX8MQ_CLK_UART1_ROOT ] =imx_clk_gate4 ("uart1_root_clk" ,"uart1_div" , base +0x4490 ,0 ); + clks[IMX8MQ_CLK_UART2_ROOT ] =imx_clk_gate4 ("uart2_root_clk" ,"uart2_div" , base +0x44a0 ,0 ); + clks[IMX8MQ_CLK_UART3_ROOT ] =imx_clk_gate4 ("uart3_root_clk" ,"uart3_div" , base +0x44b0 ,0 ); + clks[IMX8MQ_CLK_UART4_ROOT ] =imx_clk_gate4 ("uart4_root_clk" ,"uart4_div" , base +0x44c0 ,0 ); + clks[IMX8MQ_CLK_USB1_CTRL_ROOT ] =imx_clk_gate4 ("usb1_ctrl_root_clk" ,"usb_core_ref_div" , base +0x44d0 ,0 ); + clks[IMX8MQ_CLK_USB2_CTRL_ROOT ] =imx_clk_gate4 ("usb2_ctrl_root_clk" ,"usb_core_ref_div" , base +0x44e0 ,0 ); + clks[IMX8MQ_CLK_USB1_PHY_ROOT ] =imx_clk_gate4 ("usb1_phy_root_clk" ,"usb_phy_ref_div" , base +0x44f0 ,0 ); + clks[IMX8MQ_CLK_USB2_PHY_ROOT ] =imx_clk_gate4 ("usb2_phy_root_clk" ,"usb_phy_ref_div" , base +0x4500 ,0 ); + clks[IMX8MQ_CLK_USDHC1_ROOT ] =imx_clk_gate4 ("usdhc1_root_clk" ,"usdhc1_div" , base +0x4510 ,0 ); + clks[IMX8MQ_CLK_USDHC2_ROOT ] =imx_clk_gate4 ("usdhc2_root_clk" ,"usdhc2_div" , base +0x4520 ,0 ); + clks[IMX8MQ_CLK_WDOG1_ROOT ] =imx_clk_gate4 ("wdog1_root_clk" ,"wdog_div" , base +0x4530 ,0 ); + clks[IMX8MQ_CLK_WDOG2_ROOT ] =imx_clk_gate4 ("wdog2_root_clk" ,"wdog_div" , base +0x4540 ,0 ); + clks[IMX8MQ_CLK_WDOG3_ROOT ] =imx_clk_gate4 ("wdog3_root_clk" ,"wdog_div" , base +0x4550 ,0 ); + clks[IMX8MQ_CLK_VPU_G1_ROOT ] =imx_clk_gate2_flags ("vpu_g1_root_clk" ,"vpu_g1_div" , base +0x4560 ,0 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_GPU_ROOT ] =imx_clk_gate4 ("gpu_root_clk" ,"gpu_core_div" , base +0x4570 ,0 ); + clks[IMX8MQ_CLK_VPU_G2_ROOT ] =imx_clk_gate2_flags ("vpu_g2_root_clk" ,"vpu_g2_div" , base +0x45a0 ,0 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_DISP_ROOT ] =imx_clk_gate2_shared2 ("disp_root_clk" ,"disp_dc8000_div" , base +0x45d0 ,0 , &share_count_dcss); + clks[IMX8MQ_CLK_DISP_AXI_ROOT ] =imx_clk_gate2_shared2 ("disp_axi_root_clk" ,"disp_axi_div" , base +0x45d0 ,0 , &share_count_dcss); + clks[IMX8MQ_CLK_DISP_APB_ROOT ] =imx_clk_gate2_shared2 ("disp_apb_root_clk" ,"disp_apb_div" , base +0x45d0 ,0 , &share_count_dcss); + clks[IMX8MQ_CLK_DISP_RTRM_ROOT ] =imx_clk_gate2_shared2 ("disp_rtrm_root_clk" ,"disp_rtrm_div" , base +0x45d0 ,0 , &share_count_dcss); + clks[IMX8MQ_CLK_TMU_ROOT ] =imx_clk_gate4_flags ("tmu_root_clk" ,"ipg_root" , base +0x4620 ,0 ,CLK_IS_CRITICAL ); + clks[IMX8MQ_CLK_VPU_DEC_ROOT ] =imx_clk_gate2_flags ("vpu_dec_root_clk" ,"vpu_bus_div" , base +0x4630 ,0 ,CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE ); + clks[IMX8MQ_CLK_CSI1_ROOT ] =imx_clk_gate4 ("csi1_root_clk" ,"csi1_core_div" , base +0x4650 ,0 ); + clks[IMX8MQ_CLK_CSI2_ROOT ] =imx_clk_gate4 ("csi2_root_clk" ,"csi2_core_div" , base +0x4660 ,0 ); + clks[IMX8MQ_CLK_SDMA1_ROOT ] =imx_clk_gate4 ("sdma1_clk" ,"ipg_root" , base +0x43a0 ,0 ); + clks[IMX8MQ_CLK_SDMA2_ROOT ] =imx_clk_gate4 ("sdma2_clk" ,"ipg_audio_root" , base +0x43b0 ,0 ); + + clks[IMX8MQ_GPT_3M_CLK ] =imx_clk_fixed_factor ("gpt_3m" ,"osc_25m" ,1 ,8 ); + clks[IMX8MQ_CLK_DRAM_ALT_ROOT ] =imx_clk_fixed_factor ("dram_alt_root" ,"dram_alt_div" ,1 ,4 ); + +for (i =0 ; i <IMX8MQ_CLK_END ; i++) +if (IS_ERR (clks[i])) +pr_err ("i.MX8mq clk %u register failed with %ld\n" , + i,PTR_ERR (clks[i])); + + clk_data.clks = clks; + clk_data.clk_num =ARRAY_SIZE (clks); +of_clk_add_provider (np, of_clk_src_onecell_get, &clk_data); + +clk_set_parent (clks[IMX8MQ_VIDEO2_PLL1_OUT ], clks[IMX8MQ_VIDEO2_PLL1 ]); +clk_set_parent (clks[IMX8MQ_VIDEO2_PLL2_OUT ], clks[IMX8MQ_VIDEO2_PLL2_DIV ]); + +clk_set_parent (clks[IMX8MQ_CLK_AHB_SRC ], clks[IMX8MQ_SYS1_PLL_133M ]); +clk_set_parent (clks[IMX8MQ_CLK_NAND_USDHC_BUS_SRC ], clks[IMX8MQ_SYS1_PLL_266M ]); +clk_set_parent (clks[IMX8MQ_CLK_AUDIO_AHB_SRC ], clks[IMX8MQ_SYS2_PLL_500M ]); + +/* config video_pll1 clock */ +clk_set_parent (clks[IMX8MQ_VIDEO_PLL1_REF_SEL ], clks[IMX8MQ_CLK_27M ]); +clk_set_rate (clks[IMX8MQ_VIDEO_PLL1 ],593999999 ); + +/* increase NOC clock to achieve best DDR access performance */ +clk_set_rate (clks[IMX8MQ_CLK_NOC_DIV ],clk_get_rate (clks[IMX8MQ_SYS1_PLL_800M ])); + +/* set pcie root's parent clk source */ +clk_set_parent (clks[IMX8MQ_CLK_PCIE1_CTRL_SRC ], clks[IMX8MQ_SYS2_PLL_250M ]); +clk_set_parent (clks[IMX8MQ_CLK_PCIE1_PHY_SRC ], clks[IMX8MQ_SYS2_PLL_100M ]); +clk_set_parent (clks[IMX8MQ_CLK_PCIE2_CTRL_SRC ], clks[IMX8MQ_SYS2_PLL_250M ]);
drivers/clk/imx/clk-imx8mq.c line 860
Quoted 10 lines
drivers/clk/imx/clk-imx8mq.c new file +10
-0+clk_set_parent (clks[IMX8MQ_CLK_PCIE2_PHY_SRC ], clks[IMX8MQ_SYS2_PLL_100M ]); + +clk_set_parent (clks[IMX8MQ_CLK_CSI1_CORE_SRC ], clks[IMX8MQ_SYS1_PLL_266M ]); +clk_set_parent (clks[IMX8MQ_CLK_CSI1_PHY_REF_SRC ], clks[IMX8MQ_SYS2_PLL_1000M ]); +clk_set_parent (clks[IMX8MQ_CLK_CSI1_ESC_SRC ], clks[IMX8MQ_SYS1_PLL_800M ]); +clk_set_parent (clks[IMX8MQ_CLK_CSI2_CORE_SRC ], clks[IMX8MQ_SYS1_PLL_266M ]); +clk_set_parent (clks[IMX8MQ_CLK_CSI2_PHY_REF_SRC ], clks[IMX8MQ_SYS2_PLL_1000M ]); +clk_set_parent (clks[IMX8MQ_CLK_CSI2_ESC_SRC ], clks[IMX8MQ_SYS1_PLL_800M ]); +} +
For this whole part, can we make a better code indent as mx6sx clk driver?
Quoted 70 lines
drivers/clk/imx/clk-imx8mq.c new file +1
-0+CLK_OF_DECLARE (imx8mq,"fsl,imx8mq-ccm" , imx8mq_clocks_init);drivers/clk/imx/clk.h +34
-0@@ -128,6 +128,15 @@ static inline struct clk *imx_clk_divider2(const char *name, const char *parent, reg, shift, width, 0, &imx_ccm_lock); } +static inline struct clk *imx_clk_divider2_flags (const char *name, +const char *parent,void __iomem *reg,u8 shift,u8 width, +unsigned long flags) +{ +return clk_register_divider (NULL , name, parent, + flags |CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE , + reg, shift, width,0 , &imx_ccm_lock); +} +static inline struct clk *imx_clk_gate (const char *name,const char *parent,void __iomem *reg,u8 shift) {@@ -149,6 +158,13 @@ static inline struct clk *imx_clk_gate2(const char *name, const char *parent, shift, 0x3, 0, &imx_ccm_lock, NULL); } +static inline struct clk *imx_clk_gate2_flags (const char *name,const char *parent, +void __iomem *reg,u8 shift,unsigned long flags) +{ +return clk_register_gate2 (NULL , name, parent, flags, reg, + shift,0x3 ,0 , &imx_ccm_lock,NULL ); +} +static inline struct clk *imx_clk_gate2_shared (const char *name,const char *parent,void __iomem *reg,u8 shift,unsigned int *share_count)@@ -181,6 +197,15 @@ static inline struct clk *imx_clk_gate3(const char *name, const char *parent, reg, shift, 0, &imx_ccm_lock); } +static inline struct clk *imx_clk_gate3_flags (const char *name, +const char *parent,void __iomem *reg,u8 shift, +unsigned long flags) +{ +return clk_register_gate (NULL , name, parent, + flags |CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE , + reg, shift,0 , &imx_ccm_lock); +} +static inline struct clk *imx_clk_gate4 (const char *name,const char *parent,void __iomem *reg,u8 shift) {@@ -189,6 +214,15 @@ static inline struct clk *imx_clk_gate4(const char *name, const char *parent, reg, shift, 0x3, 0, &imx_ccm_lock, NULL); } +static inline struct clk *imx_clk_gate4_flags (const char *name, +const char *parent,void __iomem *reg,u8 shift, +unsigned long flags) +{ +return clk_register_gate2 (NULL , name, parent, + flags |CLK_SET_RATE_PARENT |CLK_OPS_PARENT_ENABLE , + reg, shift,0x3 ,0 , &imx_ccm_lock,NULL ); +} +static inline struct clk *imx_clk_mux (const char *name,void __iomem *reg,u8 shift,u8 width,const char **parents,int num_parents) {@@ -214,6 +248,15 @@ static inline struct clk *imx_clk_mux_flags(const char *name, &imx_ccm_lock); }
drivers/clk/imx/clk.h static inline struct clk *imx_clk_mux_flags(const char *name, · line 259
Quoted 10 lines
drivers/clk/imx/clk.h +9
-0+static inline struct clk *imx_clk_mux2_flags (const char *name, +void __iomem *reg,u8 shift,u8 width,const char **parents, +int num_parents,unsigned long flags) +{ +return clk_register_mux (NULL , name, parents, num_parents, + flags |CLK_SET_RATE_NO_REPARENT |CLK_OPS_PARENT_ENABLE , + reg, shift, width,0 , &imx_ccm_lock); +} +
Last, overally, as mentioned in another mail, maintainer would like us switch to clk_hw API. We probably may need change.
Regards
Dong Aisheng
Quoted 10 lines
drivers/clk/imx/clk.h +0
-0struct clk *imx_clk_cpu (const char *name,const char *parent_name,struct clk *div,struct clk *mux,struct clk *pll,struct clk *step);Signature · 6 lines
2.15.1 -- To unsubscribe from this list: send the line "unsubscribe linux-clk" in the body of a message to majordomo at vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Sascha Hauer
maintainerPATCH v2 4/4 clk: imx: add clock driver for i.MX8MQ CCM
In reply to Lucas StachQuoted 6 lines · Lucas Stach
Add driver for the Clock Control Module found on i.MX8MQ.
This is largely based on the downstream driver from Anson Huang and Bai Ping at NXP, with only some small adaptions to mainline from me.
Signed-off-by Lucas Stach <[email protected]>
A general thought: The i.MX8M finally has a consistent clock tree. We have for example 70 Peripheral clock slices consisting of a mux, a gate and two dividers, all 70 looking the same.
For these it might make sense to create a more complex clock type providing mux, gate and set rate functionality in one clock. This would drastically reduce the number of clocks we have to handle.
Sascha
Signature · 4 lines
Pengutronix e.K. | | Industrial Linux Solutions | http://www.pengutronix.de/ | Peiner Str. 6-8, 31137 Hildesheim, Germany | Phone: +49-5121-206917-0 | Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
PATCH v2 4/4 clk: imx: add clock driver for i.MX8MQ CCM
Am Donnerstag, den 15.03.2018, 22:33 +0100 schrieb Sascha Hauer:
Quoted 6 lines · Lucas Stach
Quoted 5 lines
Add driver for the Clock Control Module found on i.MX8MQ.
This is largely based on the downstream driver from Anson Huang and Bai Ping at NXP, with only some small adaptions to mainline from me.
Quoted 8 lines
Quoted 1 line
Signed-off-by Lucas Stach <[email protected]>A general thought: The i.MX8M finally has a consistent clock tree. We have for example 70 Peripheral clock slices consisting of a mux, a gate and two dividers, all 70 looking the same.
For these it might make sense to create a more complex clock type providing mux, gate and set rate functionality in one clock. This would drastically reduce the number of clocks we have to handle.
I agree. It seems we are missing the 4.17 merge window with this anyways, due to the large number of changes still required and time constraints on my side, so a larger rework of the driver might be possible if we target 4.18.
Regards,
Lucas
PATCH v2 4/4 clk: imx: add clock driver for i.MX8MQ CCM
Quoted 29 lines
-----Original Message-----
From: Lucas Stach [mailto:l.stach at pengutronix.de]
Sent: Friday, March 16, 2018 6:10 PM
To: Sascha Hauer <[email protected]>
Cc: Michael Turquette <[email protected]>; Stephen Boyd <[email protected]>; A.s. Dong <[email protected]>; devicetree at vger.kernel.org; patchwork-lst at pengutronix.de; Rob Herring <[email protected]>; dl-linux-imx <[email protected]>;
kernel at pengutronix.de; Fabio Estevam <[email protected]>; Shawn Guo <[email protected]>; linux-clk at vger.kernel.org; linux-arm- kernel at lists.infradead.org
Subject: Re: [PATCH v2 4/4] clk: imx: add clock driver for i.MX8MQ CCMAm Donnerstag, den 15.03.2018, 22:33 +0100 schrieb Sascha Hauer:
Quoted 6 lines · Lucas Stach
Quoted 5 lines
Add driver for the Clock Control Module found on i.MX8MQ.
This is largely based on the downstream driver from Anson Huang and Bai Ping at NXP, with only some small adaptions to mainline from me.
Quoted 8 lines
Quoted 1 line
Signed-off-by Lucas Stach <[email protected]>A general thought: The i.MX8M finally has a consistent clock tree. We have for example 70 Peripheral clock slices consisting of a mux, a gate and two dividers, all 70 looking the same.
For these it might make sense to create a more complex clock type providing mux, gate and set rate functionality in one clock. This would drastically reduce the number of clocks we have to handle.
Quoted 4 lines
I agree. It seems we are missing the 4.17 merge window with this anyways, due to the large number of changes still required and time constraints on my side, so a larger rework of the driver might be possible if we target 4.18.
Yes, that would be worth a try.
Thanks for doing it.
Regards
Dong Aisheng
Quoted 2 lines
Regards,
Lucas
PATCH v2 1/4 dt-bindings: add binding for i.MX8MQ CCM
In reply to Lucas StachQuoted 4 lines · Lucas Stach
This adds the binding for the i.MX8MQ Clock Controller Module.
Signed-off-by Lucas Stach <[email protected]>Reviewed-by Rob Herring <[email protected]>
Hi Stephen,
To make your life a bit easier, I plan to collect drivers/clk/imx/ patches and send you pull request at a proper time. Doing this will also help resolve the clock ID dependency between clock driver and device trees. Sounds good to you?
Shawn
Shawn Guo
AppliedPATCH v2 1/4 dt-bindings: add binding for i.MX8MQ CCM
In reply to Lucas StachQuoted 4 lines · Lucas Stach
This adds the binding for the i.MX8MQ Clock Controller Module.
Signed-off-by Lucas Stach <[email protected]>Reviewed-by Rob Herring <[email protected]>
Applied all, thanks.
PATCH v2 1/4 dt-bindings: add binding for i.MX8MQ CCM
Quoted 7 lines · Shawn Guo
Quoted 4 lines · Lucas Stach
This adds the binding for the i.MX8MQ Clock Controller Module.
Signed-off-by Lucas Stach <[email protected]>Reviewed-by Rob Herring <[email protected]>Applied all, thanks.
I decided to hold it a bit, as I found something which needs a bit more discussion. Will reply to individual patch tomorrow.
Shawn
PATCH v2 1/4 dt-bindings: add binding for i.MX8MQ CCM
Quoted 11 lines · Shawn Guo
Quoted 7 lines · Shawn Guo
Quoted 4 lines · Lucas Stach
This adds the binding for the i.MX8MQ Clock Controller Module.
Signed-off-by Lucas Stach <[email protected]>Reviewed-by Rob Herring <[email protected]>Applied all, thanks.
I decided to hold it a bit, as I found something which needs a bit more discussion. Will reply to individual patch tomorrow.
Besides the comments I put on individual patches, please also go through the checkpatch results. We ignore MAINTAINERS updating and line over 80 characters warnings, but I see the following ones which I think we should fix.
- ERROR: code indent should use tabs where possible
- WARNING: please, no space before tabs
Shawn
PATCH v2 1/4 dt-bindings: add binding for i.MX8MQ CCM
In reply to Lucas Stachinclude/dt-bindings/clock/imx8mq-clock.h line 156
Quoted 5 lines · Lucas Stach
include/dt-bindings/clock/imx8mq-clock.h new file +5
-0+/* ENET AXI */ +#define IMX8MQ_CLK_ENET_AXI_SRC 107 +#define IMX8MQ_CLK_ENET_AXI_CG 108 +#define IMX8MQ_CLK_ENET_AXI_PRE_DIV 109 +#define IMX8MQ_CLK_ENET_AXI_DIV 110
The indentation changes from here. Since these defines are added in one time, the indentation can be unified.
Shawn
Quoted 5 lines
include/dt-bindings/clock/imx8mq-clock.h new file +5
-0+/* NAND_USDHC_BUS */ +#define IMX8MQ_CLK_NAND_USDHC_BUS_SRC 111 +#define IMX8MQ_CLK_NAND_USDHC_BUS_CG 112 +#define IMX8MQ_CLK_NAND_USDHC_BUS_PRE_DIV 113 +#define IMX8MQ_CLK_NAND_USDHC_BUS_DIV 114