Skip to content

L
linux
Commit 0dfc86b3 authored by Scott Wood's avatar Scott Wood
Browse files
Options

clk: qoriq: Move chip-specific knowledge into driver 

The device tree should describe the chips (or chip-like subblocks) in
the system, but it generally does not describe individual registers --
it should identify, rather than describe, a programming interface.

This has not been the case with the QorIQ clockgen nodes.  The
knowledge of what each bit setting of CLKCnCSR means is encoded in
three places (binding, pll node, and mux node), and the last also needs
to know which options are valid on a particular chip.  All three of
these locations are considered stable ABI, making it difficult to fix
mistakes (of which I have found several), much less refactor the
abstraction to be able to address problems, limitations, or new chips.

Under the current binding, a pll clock specifier of 2 means that the
PLL is divided by 4 -- and the driver implements this, unless there
happen to be four clock-output-names rather than 3, in which case it
interprets it as PLL divided by 3.  This does not appear in the binding
documentation at all.  That hack is now considered stable ABI.

The current device tree nodes contain errors, such as saying that
T1040 can set a core clock to PLL/4 when only PLL and PLL/2 are options.
The current binding also ignores some restrictions on clock selection,
such as p5020's requirement that if a core uses the "wrong" PLL, that
PLL must be clocked lower than the "correct" PLL and be at most 80% of
the rated CPU frequency.

Possibly because of the lack of the ability to express such nuance in
the binding, some valid options are omitted from the device trees, such
as the ability on p4080 to run cores 0-3 from PLL3 and cores 4-7 from
PLL1 (again, only if they are at most 80% of rated CPU frequency).
This omission, combined with excessive caution in the cpufreq driver
(addressed in a subsequent patch), means that currently on a 1500 MHz
p4080 with typical PLL configuration, cpufreq can lower the frequency
to 1200 MHz on half the CPUs and do nothing on the others.  With this
patchset, all CPUs can be lowered to 1200 MHz on a rev2 p4080, and on a
rev3 p4080 half can be lowered to 750 MHz and the other half to 600
MHz.

The current binding only deals with CPU clocks.  To describe FMan in
the device tree, we need to describe its clock.  Some chips have
additional muxes that work like the CPU muxes, but are not described in
the device tree.  Others require inspecting the Reset Control Word to
determine which PLL is used.  Rather than continue to extend this mess,
replace it.  Have the driver bind to the chip-specific clockgen
compatible, and keep the detailed description of quirky chip variations
in the driver, where it can be easily fixed, refactored, and extended.

Older device trees will continue to work (including a workaround for
old ls1021a device trees that are missing compatible and reg in the
clockgen node, which even the old binding required).  The pll/mux
details in old device trees will be ignored, but "clocks" properties
pointing at the old nodes will still work, and be directed at the
corresponding new clock.
Signed-off-by: default avatarScott Wood <scottwood@freescale.com>
Acked-by: default avatarStephen Boyd <sboyd@codeaurora.org>
parent 94848654
Hide whitespace changes
Inline Side-by-side
Showing with 1090 additions and 232 deletions
Documentation/devicetree/bindings/clock/qoriq-clock.txt
View file @ 0dfc86b3
* Clock Block on Freescale QorIQ Platforms * Clock Block on Freescale QorIQ Platforms
Freescale qoriq chips take primary clocking input from the external Freescale QorIQ chips take primary clocking input from the external
SYSCLK signal. The SYSCLK input (frequency) is multiplied using SYSCLK signal. The SYSCLK input (frequency) is multiplied using
multiple phase locked loops (PLL) to create a variety of frequencies multiple phase locked loops (PLL) to create a variety of frequencies
which can then be passed to a variety of internal logic, including which can then be passed to a variety of internal logic, including
...@@ -13,14 +13,16 @@ which the chip complies. ...@@ -13,14 +13,16 @@ which the chip complies.
Chassis Version Example Chips Chassis Version Example Chips
--------------- ------------- --------------- -------------
1.0 p4080, p5020, p5040 1.0 p4080, p5020, p5040
2.0 t4240, b4860, t1040 2.0 t4240, b4860
1. Clock Block Binding 1. Clock Block Binding
Required properties: Required properties:
- compatible: Should contain a specific clock block compatible string - compatible: Should contain a chip-specific clock block compatible
and a single chassis clock compatible string. string and (if applicable) may contain a chassis-version clock
Clock block strings include, but not limited to, one of the: compatible string.
Chip-specific strings are of the form "fsl,<chip>-clockgen", such as:
* "fsl,p2041-clockgen" * "fsl,p2041-clockgen"
* "fsl,p3041-clockgen" * "fsl,p3041-clockgen"
* "fsl,p4080-clockgen" * "fsl,p4080-clockgen"
...@@ -30,15 +32,14 @@ Required properties: ...@@ -30,15 +32,14 @@ Required properties:
* "fsl,b4420-clockgen" * "fsl,b4420-clockgen"
* "fsl,b4860-clockgen" * "fsl,b4860-clockgen"
* "fsl,ls1021a-clockgen" * "fsl,ls1021a-clockgen"
Chassis clock strings include: Chassis-version clock strings include:
* "fsl,qoriq-clockgen-1.0": for chassis 1.0 clocks * "fsl,qoriq-clockgen-1.0": for chassis 1.0 clocks
* "fsl,qoriq-clockgen-2.0": for chassis 2.0 clocks * "fsl,qoriq-clockgen-2.0": for chassis 2.0 clocks
- reg: Describes the address of the device's resources within the - reg: Describes the address of the device's resources within the
address space defined by its parent bus, and resource zero address space defined by its parent bus, and resource zero
represents the clock register set represents the clock register set
- clock-frequency: Input system clock frequency
Recommended properties: Optional properties:
- ranges: Allows valid translation between child's address space and - ranges: Allows valid translation between child's address space and
parent's. Must be present if the device has sub-nodes. parent's. Must be present if the device has sub-nodes.
- #address-cells: Specifies the number of cells used to represent - #address-cells: Specifies the number of cells used to represent
...@@ -47,8 +48,46 @@ Recommended properties: ...@@ -47,8 +48,46 @@ Recommended properties:
- #size-cells: Specifies the number of cells used to represent - #size-cells: Specifies the number of cells used to represent
the size of an address. Must be present if the device has the size of an address. Must be present if the device has
sub-nodes and set to 1 if present sub-nodes and set to 1 if present
- clock-frequency: Input system clock frequency (SYSCLK)
- clocks: If clock-frequency is not specified, sysclk may be provided
as an input clock. Either clock-frequency or clocks must be
provided.
2. Clock Provider
The clockgen node should act as a clock provider, though in older device
trees the children of the clockgen node are the clock providers.
When the clockgen node is a clock provider, #clock-cells = <2>.
The first cell of the clock specifier is the clock type, and the
second cell is the clock index for the specified type.
Type# Name Index Cell
0 sysclk must be 0
1 cmux index (n in CLKCnCSR)
2 hwaccel index (n in CLKCGnHWACSR)
3 fman 0 for fm1, 1 for fm2
4 platform pll 0=pll, 1=pll/2, 2=pll/3, 3=pll/4
3. Example
clockgen: global-utilities@e1000 {
compatible = "fsl,p5020-clockgen", "fsl,qoriq-clockgen-1.0";
clock-frequency = <133333333>;
reg = <0xe1000 0x1000>;
#clock-cells = <2>;
};
fman@400000 {
...
clocks = <&clockgen 3 0>;
...
};
}
4. Legacy Child Nodes
2. Clock Provider/Consumer Binding NOTE: These nodes are deprecated. Kernels should continue to support
device trees with these nodes, but new device trees should not use them.
Most of the bindings are from the common clock binding[1]. Most of the bindings are from the common clock binding[1].
[1] Documentation/devicetree/bindings/clock/clock-bindings.txt [1] Documentation/devicetree/bindings/clock/clock-bindings.txt
...@@ -82,7 +121,7 @@ Recommended properties: ...@@ -82,7 +121,7 @@ Recommended properties:
- reg: Should be the offset and length of clock block base address. - reg: Should be the offset and length of clock block base address.
The length should be 4. The length should be 4.
Example for clock block and clock provider: Legacy Example:
/ { / {
clockgen: global-utilities@e1000 { clockgen: global-utilities@e1000 {
compatible = "fsl,p5020-clockgen", "fsl,qoriq-clockgen-1.0"; compatible = "fsl,p5020-clockgen", "fsl,qoriq-clockgen-1.0";
...@@ -142,7 +181,7 @@ Example for clock block and clock provider: ...@@ -142,7 +181,7 @@ Example for clock block and clock provider:
}; };
}; };
Example for clock consumer: Example for legacy clock consumer:
/ { / {
cpu0: PowerPC,e5500@0 { cpu0: PowerPC,e5500@0 {
......
drivers/clk/clk-qoriq.c
View file @ 0dfc86b3
...@@ -10,7 +10,9 @@ ...@@ -10,7 +10,9 @@
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/clk.h>
#include <linux/clk-provider.h> #include <linux/clk-provider.h>
#include <linux/fsl/guts.h>
#include <linux/io.h> #include <linux/io.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/module.h> #include <linux/module.h>
...@@ -19,213 +21,934 @@ ...@@ -19,213 +21,934 @@
#include <linux/of.h> #include <linux/of.h>
#include <linux/slab.h> #include <linux/slab.h>
struct cmux_clk { #define PLL_DIV1 0
#define PLL_DIV2 1
#define PLL_DIV3 2
#define PLL_DIV4 3
#define PLATFORM_PLL 0
#define CGA_PLL1 1
#define CGA_PLL2 2
#define CGA_PLL3 3
#define CGA_PLL4 4 /* only on clockgen-1.0, which lacks CGB */
#define CGB_PLL1 4
#define CGB_PLL2 5
struct clockgen_pll_div {
struct clk *clk;
char name[32];
};
struct clockgen_pll {
struct clockgen_pll_div div[4];
};
#define CLKSEL_VALID 1
#define CLKSEL_80PCT 2 /* Only allowed if PLL <= 80% of max cpu freq */
struct clockgen_sourceinfo {
u32 flags; /* CLKSEL_xxx */
int pll; /* CGx_PLLn */
int div; /* PLL_DIVn */
};
#define NUM_MUX_PARENTS 16
struct clockgen_muxinfo {
struct clockgen_sourceinfo clksel[NUM_MUX_PARENTS];
};
#define NUM_HWACCEL 5
#define NUM_CMUX 8
struct clockgen;
/*
* cmux freq must be >= platform pll.
* If not set, cmux freq must be >= platform pll/2
*/
#define CG_CMUX_GE_PLAT 1
#define CG_PLL_8BIT 2 /* PLLCnGSR[CFG] is 8 bits, not 6 */
struct clockgen_chipinfo {
const char *compat, *guts_compat;
const struct clockgen_muxinfo *cmux_groups[2];
const struct clockgen_muxinfo *hwaccel[NUM_HWACCEL];
void (*init_periph)(struct clockgen *cg);
int cmux_to_group[NUM_CMUX]; /* -1 terminates if fewer than NUM_CMUX */
u32 pll_mask; /* 1 << n bit set if PLL n is valid */
u32 flags; /* CG_xxx */
};
struct clockgen {
struct device_node *node;
void __iomem *regs;
struct clockgen_chipinfo info; /* mutable copy */
struct clk *sysclk;
struct clockgen_pll pll[6];
struct clk *cmux[NUM_CMUX];
struct clk *hwaccel[NUM_HWACCEL];
struct clk *fman[2];
struct ccsr_guts __iomem *guts;
};
static struct clockgen clockgen;
static const struct clockgen_muxinfo p2041_cmux_grp1 = {
{
[0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
[1] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
[4] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
}
};
static const struct clockgen_muxinfo p2041_cmux_grp2 = {
{
[0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
[4] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
[5] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
}
};
static const struct clockgen_muxinfo p5020_cmux_grp1 = {
{
[0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
[1] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
[4] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL2, PLL_DIV1 },
}
};
static const struct clockgen_muxinfo p5020_cmux_grp2 = {
{
[0] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL1, PLL_DIV1 },
[4] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
[5] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
}
};
static const struct clockgen_muxinfo p5040_cmux_grp1 = {
{
[0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
[1] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
[4] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL2, PLL_DIV1 },
[5] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL2, PLL_DIV2 },
}
};
static const struct clockgen_muxinfo p5040_cmux_grp2 = {
{
[0] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL1, PLL_DIV1 },
[1] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL1, PLL_DIV2 },
[4] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
[5] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
}
};
static const struct clockgen_muxinfo p4080_cmux_grp1 = {
{
[0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
[1] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
[4] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
[5] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
[8] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL3, PLL_DIV1 },
}
};
static const struct clockgen_muxinfo p4080_cmux_grp2 = {
{
[0] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL1, PLL_DIV1 },
[8] = { CLKSEL_VALID, CGA_PLL3, PLL_DIV1 },
[9] = { CLKSEL_VALID, CGA_PLL3, PLL_DIV2 },
[12] = { CLKSEL_VALID, CGA_PLL4, PLL_DIV1 },
[13] = { CLKSEL_VALID, CGA_PLL4, PLL_DIV2 },
}
};
static const struct clockgen_muxinfo t1023_cmux = {
{
[0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
[1] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
}
};
static const struct clockgen_muxinfo t1040_cmux = {
{
[0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
[1] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
[4] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
[5] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
}
};
static const struct clockgen_muxinfo clockgen2_cmux_cga = {
{
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV4 },
{},
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV4 },
{},
{ CLKSEL_VALID, CGA_PLL3, PLL_DIV1 },
{ CLKSEL_VALID, CGA_PLL3, PLL_DIV2 },
{ CLKSEL_VALID, CGA_PLL3, PLL_DIV4 },
},
};
static const struct clockgen_muxinfo clockgen2_cmux_cga12 = {
{
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV4 },
{},
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV4 },
},
};
static const struct clockgen_muxinfo clockgen2_cmux_cgb = {
{
{ CLKSEL_VALID, CGB_PLL1, PLL_DIV1 },
{ CLKSEL_VALID, CGB_PLL1, PLL_DIV2 },
{ CLKSEL_VALID, CGB_PLL1, PLL_DIV4 },
{},
{ CLKSEL_VALID, CGB_PLL2, PLL_DIV1 },
{ CLKSEL_VALID, CGB_PLL2, PLL_DIV2 },
{ CLKSEL_VALID, CGB_PLL2, PLL_DIV4 },
},
};
static const struct clockgen_muxinfo t1023_hwa1 = {
{
{},
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV3 },
},
};
static const struct clockgen_muxinfo t1023_hwa2 = {
{
[6] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
},
};
static const struct clockgen_muxinfo t2080_hwa1 = {
{
{},
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV3 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV4 },
{ CLKSEL_VALID, PLATFORM_PLL, PLL_DIV1 },
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV3 },
},
};
static const struct clockgen_muxinfo t2080_hwa2 = {
{
{},
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV3 },
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV4 },
{ CLKSEL_VALID, PLATFORM_PLL, PLL_DIV1 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV3 },
},
};
static const struct clockgen_muxinfo t4240_hwa1 = {
{
{ CLKSEL_VALID, PLATFORM_PLL, PLL_DIV2 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV3 },
{ CLKSEL_VALID, CGA_PLL1, PLL_DIV4 },
{},
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
{ CLKSEL_VALID, CGA_PLL2, PLL_DIV3 },
},
};
static const struct clockgen_muxinfo t4240_hwa4 = {
{
[2] = { CLKSEL_VALID, CGB_PLL1, PLL_DIV2 },
[3] = { CLKSEL_VALID, CGB_PLL1, PLL_DIV3 },
[4] = { CLKSEL_VALID, CGB_PLL1, PLL_DIV4 },
[5] = { CLKSEL_VALID, PLATFORM_PLL, PLL_DIV1 },
[6] = { CLKSEL_VALID, CGB_PLL2, PLL_DIV2 },
},
};
static const struct clockgen_muxinfo t4240_hwa5 = {
{
[2] = { CLKSEL_VALID, CGB_PLL2, PLL_DIV2 },
[3] = { CLKSEL_VALID, CGB_PLL2, PLL_DIV3 },
[4] = { CLKSEL_VALID, CGB_PLL2, PLL_DIV4 },
[5] = { CLKSEL_VALID, PLATFORM_PLL, PLL_DIV1 },
[6] = { CLKSEL_VALID, CGB_PLL1, PLL_DIV2 },
[7] = { CLKSEL_VALID, CGB_PLL1, PLL_DIV3 },
},
};
#define RCWSR7_FM1_CLK_SEL 0x40000000
#define RCWSR7_FM2_CLK_SEL 0x20000000
#define RCWSR7_HWA_ASYNC_DIV 0x04000000
static void __init p2041_init_periph(struct clockgen *cg)
{
u32 reg;
reg = ioread32be(&cg->guts->rcwsr[7]);
if (reg & RCWSR7_FM1_CLK_SEL)
cg->fman[0] = cg->pll[CGA_PLL2].div[PLL_DIV2].clk;
else
cg->fman[0] = cg->pll[PLATFORM_PLL].div[PLL_DIV2].clk;
}
static void __init p4080_init_periph(struct clockgen *cg)
{
u32 reg;
reg = ioread32be(&cg->guts->rcwsr[7]);
if (reg & RCWSR7_FM1_CLK_SEL)
cg->fman[0] = cg->pll[CGA_PLL3].div[PLL_DIV2].clk;
else
cg->fman[0] = cg->pll[PLATFORM_PLL].div[PLL_DIV2].clk;
if (reg & RCWSR7_FM2_CLK_SEL)
cg->fman[1] = cg->pll[CGA_PLL3].div[PLL_DIV2].clk;
else
cg->fman[1] = cg->pll[PLATFORM_PLL].div[PLL_DIV2].clk;
}
static void __init p5020_init_periph(struct clockgen *cg)
{
u32 reg;
int div = PLL_DIV2;
reg = ioread32be(&cg->guts->rcwsr[7]);
if (reg & RCWSR7_HWA_ASYNC_DIV)
div = PLL_DIV4;
if (reg & RCWSR7_FM1_CLK_SEL)
cg->fman[0] = cg->pll[CGA_PLL2].div[div].clk;
else
cg->fman[0] = cg->pll[PLATFORM_PLL].div[PLL_DIV2].clk;
}
static void __init p5040_init_periph(struct clockgen *cg)
{
u32 reg;
int div = PLL_DIV2;
reg = ioread32be(&cg->guts->rcwsr[7]);
if (reg & RCWSR7_HWA_ASYNC_DIV)
div = PLL_DIV4;
if (reg & RCWSR7_FM1_CLK_SEL)
cg->fman[0] = cg->pll[CGA_PLL3].div[div].clk;
else
cg->fman[0] = cg->pll[PLATFORM_PLL].div[PLL_DIV2].clk;
if (reg & RCWSR7_FM2_CLK_SEL)
cg->fman[1] = cg->pll[CGA_PLL3].div[div].clk;
else
cg->fman[1] = cg->pll[PLATFORM_PLL].div[PLL_DIV2].clk;
}
static void __init t1023_init_periph(struct clockgen *cg)
{
cg->fman[0] = cg->hwaccel[1];
}
static void __init t1040_init_periph(struct clockgen *cg)
{
cg->fman[0] = cg->pll[PLATFORM_PLL].div[PLL_DIV1].clk;
}
static void __init t2080_init_periph(struct clockgen *cg)
{
cg->fman[0] = cg->hwaccel[0];
}
static void __init t4240_init_periph(struct clockgen *cg)
{
cg->fman[0] = cg->hwaccel[3];
cg->fman[1] = cg->hwaccel[4];
}
static const struct clockgen_chipinfo chipinfo[] = {
{
.compat = "fsl,b4420-clockgen",
.guts_compat = "fsl,b4860-device-config",
.init_periph = t2080_init_periph,
.cmux_groups = {
&clockgen2_cmux_cga12, &clockgen2_cmux_cgb
},
.hwaccel = {
&t2080_hwa1
},
.cmux_to_group = {
0, 1, 1, 1, -1
},
.pll_mask = 0x3f,
.flags = CG_PLL_8BIT,
},
{
.compat = "fsl,b4860-clockgen",
.guts_compat = "fsl,b4860-device-config",
.init_periph = t2080_init_periph,
.cmux_groups = {
&clockgen2_cmux_cga12, &clockgen2_cmux_cgb
},
.hwaccel = {
&t2080_hwa1
},
.cmux_to_group = {
0, 1, 1, 1, -1
},
.pll_mask = 0x3f,
.flags = CG_PLL_8BIT,
},
{
.compat = "fsl,ls1021a-clockgen",
.cmux_groups = {
&t1023_cmux
},
.cmux_to_group = {
0, -1
},
.pll_mask = 0x03,
},
{
.compat = "fsl,p2041-clockgen",
.guts_compat = "fsl,qoriq-device-config-1.0",
.init_periph = p2041_init_periph,
.cmux_groups = {
&p2041_cmux_grp1, &p2041_cmux_grp2
},
.cmux_to_group = {
0, 0, 1, 1, -1
},
.pll_mask = 0x07,
},
{
.compat = "fsl,p3041-clockgen",
.guts_compat = "fsl,qoriq-device-config-1.0",
.init_periph = p2041_init_periph,
.cmux_groups = {
&p2041_cmux_grp1, &p2041_cmux_grp2
},
.cmux_to_group = {
0, 0, 1, 1, -1
},
.pll_mask = 0x07,
},
{
.compat = "fsl,p4080-clockgen",
.guts_compat = "fsl,qoriq-device-config-1.0",
.init_periph = p4080_init_periph,
.cmux_groups = {
&p4080_cmux_grp1, &p4080_cmux_grp2
},
.cmux_to_group = {
0, 0, 0, 0, 1, 1, 1, 1
},
.pll_mask = 0x1f,
},
{
.compat = "fsl,p5020-clockgen",
.guts_compat = "fsl,qoriq-device-config-1.0",
.init_periph = p5020_init_periph,
.cmux_groups = {
&p2041_cmux_grp1, &p2041_cmux_grp2
},
.cmux_to_group = {
0, 1, -1
},
.pll_mask = 0x07,
},
{
.compat = "fsl,p5040-clockgen",
.guts_compat = "fsl,p5040-device-config",
.init_periph = p5040_init_periph,
.cmux_groups = {
&p5040_cmux_grp1, &p5040_cmux_grp2
},
.cmux_to_group = {
0, 0, 1, 1, -1
},
.pll_mask = 0x0f,
},
{
.compat = "fsl,t1023-clockgen",
.guts_compat = "fsl,t1023-device-config",
.init_periph = t1023_init_periph,
.cmux_groups = {
&t1023_cmux
},
.hwaccel = {
&t1023_hwa1, &t1023_hwa2
},
.cmux_to_group = {
0, 0, -1
},
.pll_mask = 0x03,
.flags = CG_PLL_8BIT,
},
{
.compat = "fsl,t1040-clockgen",
.guts_compat = "fsl,t1040-device-config",
.init_periph = t1040_init_periph,
.cmux_groups = {
&t1040_cmux
},
.cmux_to_group = {
0, 0, 0, 0, -1
},
.pll_mask = 0x07,
.flags = CG_PLL_8BIT,
},
{
.compat = "fsl,t2080-clockgen",
.guts_compat = "fsl,t2080-device-config",
.init_periph = t2080_init_periph,
.cmux_groups = {
&clockgen2_cmux_cga12
},
.hwaccel = {
&t2080_hwa1, &t2080_hwa2
},
.cmux_to_group = {
0, -1
},
.pll_mask = 0x07,
.flags = CG_PLL_8BIT,
},
{
.compat = "fsl,t4240-clockgen",
.guts_compat = "fsl,t4240-device-config",
.init_periph = t4240_init_periph,
.cmux_groups = {
&clockgen2_cmux_cga, &clockgen2_cmux_cgb
},
.hwaccel = {
&t4240_hwa1, NULL, NULL, &t4240_hwa4, &t4240_hwa5
},
.cmux_to_group = {
0, 0, 1, -1
},
.pll_mask = 0x3f,
.flags = CG_PLL_8BIT,
},
{},
};
struct mux_hwclock {
struct clk_hw hw; struct clk_hw hw;
void __iomem *reg; struct clockgen *cg;
unsigned int clk_per_pll; const struct clockgen_muxinfo *info;
u32 flags; u32 __iomem *reg;
u8 parent_to_clksel[NUM_MUX_PARENTS];
s8 clksel_to_parent[NUM_MUX_PARENTS];
int num_parents;
}; };
#define PLL_KILL BIT(31) #define to_mux_hwclock(p) container_of(p, struct mux_hwclock, hw)
#define CLKSEL_MASK 0x78000000
#define CLKSEL_SHIFT 27 #define CLKSEL_SHIFT 27
#define CLKSEL_ADJUST BIT(0)
#define to_cmux_clk(p) container_of(p, struct cmux_clk, hw)
static int cmux_set_parent(struct clk_hw *hw, u8 idx) static int mux_set_parent(struct clk_hw *hw, u8 idx)
{ {
struct cmux_clk *clk = to_cmux_clk(hw); struct mux_hwclock *hwc = to_mux_hwclock(hw);
u32 clksel; u32 clksel;
clksel = ((idx / clk->clk_per_pll) << 2) + idx % clk->clk_per_pll; if (idx >= hwc->num_parents)
if (clk->flags & CLKSEL_ADJUST) return -EINVAL;
clksel += 8;
clksel = (clksel & 0xf) << CLKSEL_SHIFT; clksel = hwc->parent_to_clksel[idx];
iowrite32be(clksel, clk->reg); iowrite32be((clksel << CLKSEL_SHIFT) & CLKSEL_MASK, hwc->reg);
return 0; return 0;
} }
static u8 cmux_get_parent(struct clk_hw *hw) static u8 mux_get_parent(struct clk_hw *hw)
{ {
struct cmux_clk *clk = to_cmux_clk(hw); struct mux_hwclock *hwc = to_mux_hwclock(hw);
u32 clksel; u32 clksel;
s8 ret;
clksel = ioread32be(clk->reg); clksel = (ioread32be(hwc->reg) & CLKSEL_MASK) >> CLKSEL_SHIFT;
clksel = (clksel >> CLKSEL_SHIFT) & 0xf;
if (clk->flags & CLKSEL_ADJUST)
clksel -= 8;
clksel = (clksel >> 2) * clk->clk_per_pll + clksel % 4;
return clksel; ret = hwc->clksel_to_parent[clksel];
if (ret < 0) {
pr_err("%s: mux at %p has bad clksel\n", __func__, hwc->reg);
return 0;
}
return ret;
} }
static const struct clk_ops cmux_ops = { static const struct clk_ops cmux_ops = {
.get_parent = cmux_get_parent, .get_parent = mux_get_parent,
.set_parent = cmux_set_parent, .set_parent = mux_set_parent,
}; };
static void __init core_mux_init(struct device_node *np) /*
* Don't allow setting for now, as the clock options haven't been
* sanitized for additional restrictions.
*/
static const struct clk_ops hwaccel_ops = {
.get_parent = mux_get_parent,
};
static const struct clockgen_pll_div *get_pll_div(struct clockgen *cg,
struct mux_hwclock *hwc,
int idx)
{ {
struct clk *clk; int pll, div;
struct clk_init_data init;
struct cmux_clk *cmux_clk;
struct device_node *node;
int rc, count, i;
u32 offset;
const char *clk_name;
const char **parent_names;
struct of_phandle_args clkspec;
rc = of_property_read_u32(np, "reg", &offset); if (!(hwc->info->clksel[idx].flags & CLKSEL_VALID))
if (rc) { return NULL;
pr_err("%s: could not get reg property\n", np->name);
return;
}
/* get the input clock source count */ pll = hwc->info->clksel[idx].pll;
count = of_property_count_strings(np, "clock-names"); div = hwc->info->clksel[idx].div;
if (count < 0) {
pr_err("%s: get clock count error\n", np->name);
return;
}
parent_names = kcalloc(count, sizeof(char *), GFP_KERNEL);
if (!parent_names)
return;
for (i = 0; i < count; i++) return &cg->pll[pll].div[div];
parent_names[i] = of_clk_get_parent_name(np, i); }
cmux_clk = kzalloc(sizeof(*cmux_clk), GFP_KERNEL); static struct clk * __init create_mux_common(struct clockgen *cg,
if (!cmux_clk) struct mux_hwclock *hwc,
goto err_name; const struct clk_ops *ops,
unsigned long min_rate,
unsigned long pct80_rate,
const char *fmt, int idx)
{
struct clk_init_data init = {};
struct clk *clk;
const struct clockgen_pll_div *div;
const char *parent_names[NUM_MUX_PARENTS];
char name[32];
int i, j;
cmux_clk->reg = of_iomap(np, 0); snprintf(name, sizeof(name), fmt, idx);
if (!cmux_clk->reg) {
pr_err("%s: could not map register\n", __func__);
goto err_clk;
}
rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", 0, for (i = 0, j = 0; i < NUM_MUX_PARENTS; i++) {
&clkspec); unsigned long rate;
if (rc) {
pr_err("%s: parse clock node error\n", __func__);
goto err_clk;
}
cmux_clk->clk_per_pll = of_property_count_strings(clkspec.np, hwc->clksel_to_parent[i] = -1;
"clock-output-names");
of_node_put(clkspec.np);
node = of_find_compatible_node(NULL, NULL, "fsl,p4080-clockgen"); div = get_pll_div(cg, hwc, i);
if (node && (offset >= 0x80)) if (!div)
cmux_clk->flags = CLKSEL_ADJUST; continue;
rc = of_property_read_string_index(np, "clock-output-names", rate = clk_get_rate(div->clk);
0, &clk_name);
if (rc) { if (hwc->info->clksel[i].flags & CLKSEL_80PCT &&
pr_err("%s: read clock names error\n", np->name); rate > pct80_rate)
goto err_clk; continue;
if (rate < min_rate)
continue;
parent_names[j] = div->name;
hwc->parent_to_clksel[j] = i;
hwc->clksel_to_parent[i] = j;
j++;
} }
init.name = clk_name; init.name = name;
init.ops = &cmux_ops; init.ops = ops;
init.parent_names = parent_names; init.parent_names = parent_names;
init.num_parents = count; init.num_parents = hwc->num_parents = j;
init.flags = 0; init.flags = 0;
cmux_clk->hw.init = &init; hwc->hw.init = &init;
hwc->cg = cg;
clk = clk_register(NULL, &cmux_clk->hw); clk = clk_register(NULL, &hwc->hw);
if (IS_ERR(clk)) { if (IS_ERR(clk)) {
pr_err("%s: could not register clock\n", clk_name); pr_err("%s: Couldn't register %s: %ld\n", __func__, name,
goto err_clk; PTR_ERR(clk));
kfree(hwc);
return NULL;
}
return clk;
}
static struct clk * __init create_one_cmux(struct clockgen *cg, int idx)
{
struct mux_hwclock *hwc;
const struct clockgen_pll_div *div;
unsigned long plat_rate, min_rate;
u64 pct80_rate;
u32 clksel;
hwc = kzalloc(sizeof(*hwc), GFP_KERNEL);
if (!hwc)
return NULL;
hwc->reg = cg->regs + 0x20 * idx;
hwc->info = cg->info.cmux_groups[cg->info.cmux_to_group[idx]];
/*
* Find the rate for the default clksel, and treat it as the
* maximum rated core frequency. If this is an incorrect
* assumption, certain clock options (possibly including the
* default clksel) may be inappropriately excluded on certain
* chips.
*/
clksel = (ioread32be(hwc->reg) & CLKSEL_MASK) >> CLKSEL_SHIFT;
div = get_pll_div(cg, hwc, clksel);
if (!div)
return NULL;
pct80_rate = clk_get_rate(div->clk);
pct80_rate *= 8;
do_div(pct80_rate, 10);
plat_rate = clk_get_rate(cg->pll[PLATFORM_PLL].div[PLL_DIV1].clk);
if (cg->info.flags & CG_CMUX_GE_PLAT)
min_rate = plat_rate;
else
min_rate = plat_rate / 2;
return create_mux_common(cg, hwc, &cmux_ops, min_rate,
pct80_rate, "cg-cmux%d", idx);
}
static struct clk * __init create_one_hwaccel(struct clockgen *cg, int idx)
{
struct mux_hwclock *hwc;
hwc = kzalloc(sizeof(*hwc), GFP_KERNEL);
if (!hwc)
return NULL;
hwc->reg = cg->regs + 0x20 * idx + 0x10;
hwc->info = cg->info.hwaccel[idx];
return create_mux_common(cg, hwc, &hwaccel_ops, 0, 0,
"cg-hwaccel%d", idx);
}
static void __init create_muxes(struct clockgen *cg)
{
int i;
for (i = 0; i < ARRAY_SIZE(cg->cmux); i++) {
if (cg->info.cmux_to_group[i] < 0)
break;
if (cg->info.cmux_to_group[i] >=
ARRAY_SIZE(cg->info.cmux_groups)) {
WARN_ON_ONCE(1);
continue;
}
cg->cmux[i] = create_one_cmux(cg, i);
} }
for (i = 0; i < ARRAY_SIZE(cg->hwaccel); i++) {
if (!cg->info.hwaccel[i])
continue;
cg->hwaccel[i] = create_one_hwaccel(cg, i);
}
}
static void __init clockgen_init(struct device_node *np);
/* Legacy nodes may get probed before the parent clockgen node */
static void __init legacy_init_clockgen(struct device_node *np)
{
if (!clockgen.node)
clockgen_init(of_get_parent(np));
}
/* Legacy node */
static void __init core_mux_init(struct device_node *np)
{
struct clk *clk;
struct resource res;
int idx, rc;
legacy_init_clockgen(np);
if (of_address_to_resource(np, 0, &res))
return;
idx = (res.start & 0xf0) >> 5;
clk = clockgen.cmux[idx];
rc = of_clk_add_provider(np, of_clk_src_simple_get, clk); rc = of_clk_add_provider(np, of_clk_src_simple_get, clk);
if (rc) { if (rc) {
pr_err("Could not register clock provider for node:%s\n", pr_err("%s: Couldn't register clk provider for node %s: %d\n",
np->name); __func__, np->name, rc);
goto err_clk; return;
} }
goto err_name; }
err_clk: static struct clk *sysclk_from_fixed(struct device_node *node, const char *name)
kfree(cmux_clk); {
err_name: u32 rate;
/* free *_names because they are reallocated when registered */
kfree(parent_names); if (of_property_read_u32(node, "clock-frequency", &rate))
return ERR_PTR(-ENODEV);
return clk_register_fixed_rate(NULL, name, NULL, CLK_IS_ROOT, rate);
} }
static void __init core_pll_init(struct device_node *np) static struct clk *sysclk_from_parent(const char *name)
{
struct clk *clk;
const char *parent_name;
clk = of_clk_get(clockgen.node, 0);
if (IS_ERR(clk))
return clk;
/* Register the input clock under the desired name. */
parent_name = __clk_get_name(clk);
clk = clk_register_fixed_factor(NULL, name, parent_name,
0, 1, 1);
if (IS_ERR(clk))
pr_err("%s: Couldn't register %s: %ld\n", __func__, name,
PTR_ERR(clk));
return clk;
}
static struct clk * __init create_sysclk(const char *name)
{
struct device_node *sysclk;
struct clk *clk;
clk = sysclk_from_fixed(clockgen.node, name);
if (!IS_ERR(clk))
return clk;
clk = sysclk_from_parent(name);
if (!IS_ERR(clk))
return clk;
sysclk = of_get_child_by_name(clockgen.node, "sysclk");
if (sysclk) {
clk = sysclk_from_fixed(sysclk, name);
if (!IS_ERR(clk))
return clk;
}
pr_err("%s: No input clock\n", __func__);
return NULL;
}
/* Legacy node */
static void __init sysclk_init(struct device_node *node)
{
struct clk *clk;
legacy_init_clockgen(node);
clk = clockgen.sysclk;
if (clk)
of_clk_add_provider(node, of_clk_src_simple_get, clk);
}
#define PLL_KILL BIT(31)
static void __init create_one_pll(struct clockgen *cg, int idx)
{ {
u32 __iomem *reg;
u32 mult; u32 mult;
int i, rc, count; struct clockgen_pll *pll = &cg->pll[idx];
const char *clk_name, *parent_name; int i;
struct clk_onecell_data *onecell_data;
struct clk **subclks;
void __iomem *base;
base = of_iomap(np, 0); if (!(cg->info.pll_mask & (1 << idx)))
if (!base) {
pr_err("iomap error\n");
return; return;
}
/* get the multiple of PLL */ if (idx == PLATFORM_PLL)
mult = ioread32be(base); reg = cg->regs + 0xc00;
else
reg = cg->regs + 0x800 + 0x20 * (idx - 1);
/* check if this PLL is disabled */ /* Get the multiple of PLL */
mult = ioread32be(reg);
/* Check if this PLL is disabled */
if (mult & PLL_KILL) { if (mult & PLL_KILL) {
pr_debug("PLL:%s is disabled\n", np->name); pr_debug("%s(): pll %p disabled\n", __func__, reg);
goto err_map; return;
} }
mult = (mult >> 1) & 0x3f;
parent_name = of_clk_get_parent_name(np, 0); if ((cg->info.flags & CG_PLL_8BIT) && idx != PLATFORM_PLL)
if (!parent_name) { mult = (mult & GENMASK(8, 1)) >> 1;
pr_err("PLL: %s must have a parent\n", np->name); else
goto err_map; mult = (mult & GENMASK(6, 1)) >> 1;
for (i = 0; i < ARRAY_SIZE(pll->div); i++) {
struct clk *clk;
snprintf(pll->div[i].name, sizeof(pll->div[i].name),
"cg-pll%d-div%d", idx, i + 1);
clk = clk_register_fixed_factor(NULL,
pll->div[i].name, "cg-sysclk", 0, mult, i + 1);
if (IS_ERR(clk)) {
pr_err("%s: %s: register failed %ld\n",
__func__, pll->div[i].name, PTR_ERR(clk));
continue;
}
pll->div[i].clk = clk;
} }
}
static void __init create_plls(struct clockgen *cg)
{
int i;
for (i = 0; i < ARRAY_SIZE(cg->pll); i++)
create_one_pll(cg, i);
}
static void __init legacy_pll_init(struct device_node *np, int idx)
{
struct clockgen_pll *pll;
struct clk_onecell_data *onecell_data;
struct clk **subclks;
int count, rc;
legacy_init_clockgen(np);
pll = &clockgen.pll[idx];
count = of_property_count_strings(np, "clock-output-names"); count = of_property_count_strings(np, "clock-output-names");
if (count < 0 || count > 4) {
pr_err("%s: clock is not supported\n", np->name);
goto err_map;
}
subclks = kcalloc(count, sizeof(struct clk *), GFP_KERNEL); BUILD_BUG_ON(ARRAY_SIZE(pll->div) < 4);
subclks = kcalloc(4, sizeof(struct clk *), GFP_KERNEL);
if (!subclks) if (!subclks)
goto err_map; return;
onecell_data = kmalloc(sizeof(*onecell_data), GFP_KERNEL); onecell_data = kmalloc(sizeof(*onecell_data), GFP_KERNEL);
if (!onecell_data) if (!onecell_data)
goto err_clks; goto err_clks;
for (i = 0; i < count; i++) { if (count <= 3) {
rc = of_property_read_string_index(np, "clock-output-names", subclks[0] = pll->div[0].clk;
i, &clk_name); subclks[1] = pll->div[1].clk;
if (rc) { subclks[2] = pll->div[3].clk;
pr_err("%s: could not get clock names\n", np->name); } else {
goto err_cell; subclks[0] = pll->div[0].clk;
} subclks[1] = pll->div[1].clk;
subclks[2] = pll->div[2].clk;
/* subclks[3] = pll->div[3].clk;
* when count == 4, there are 4 output clocks:
* /1, /2, /3, /4 respectively
* when count < 4, there are at least 2 output clocks:
* /1, /2, (/4, if count == 3) respectively.
*/
if (count == 4)
subclks[i] = clk_register_fixed_factor(NULL, clk_name,
parent_name, 0, mult, 1 + i);
else
subclks[i] = clk_register_fixed_factor(NULL, clk_name,
parent_name, 0, mult, 1 << i);
if (IS_ERR(subclks[i])) {
pr_err("%s: could not register clock\n", clk_name);
goto err_cell;
}
} }
onecell_data->clks = subclks; onecell_data->clks = subclks;
...@@ -233,125 +956,221 @@ static void __init core_pll_init(struct device_node *np) ...@@ -233,125 +956,221 @@ static void __init core_pll_init(struct device_node *np)
rc = of_clk_add_provider(np, of_clk_src_onecell_get, onecell_data); rc = of_clk_add_provider(np, of_clk_src_onecell_get, onecell_data);
if (rc) { if (rc) {
pr_err("Could not register clk provider for node:%s\n", pr_err("%s: Couldn't register clk provider for node %s: %d\n",
np->name); __func__, np->name, rc);
goto err_cell; goto err_cell;
} }
iounmap(base);
return; return;
err_cell: err_cell:
kfree(onecell_data); kfree(onecell_data);
err_clks: err_clks:
kfree(subclks); kfree(subclks);
err_map:
iounmap(base);
} }
static void __init sysclk_init(struct device_node *node) /* Legacy node */
static void __init pltfrm_pll_init(struct device_node *np)
{ {
struct clk *clk; legacy_pll_init(np, PLATFORM_PLL);
const char *clk_name = node->name; }
struct device_node *np = of_get_parent(node);
u32 rate;
if (!np) { /* Legacy node */
pr_err("could not get parent node\n"); static void __init core_pll_init(struct device_node *np)
{
struct resource res;
int idx;
if (of_address_to_resource(np, 0, &res))
return; return;
if ((res.start & 0xfff) == 0xc00) {
/*
* ls1021a devtree labels the platform PLL
* with the core PLL compatible
*/
pltfrm_pll_init(np);
} else {
idx = (res.start & 0xf0) >> 5;
legacy_pll_init(np, CGA_PLL1 + idx);
} }
}
if (of_property_read_u32(np, "clock-frequency", &rate)) { static struct clk *clockgen_clk_get(struct of_phandle_args *clkspec, void *data)
of_node_put(node); {
return; struct clockgen *cg = data;
struct clk *clk;
struct clockgen_pll *pll;
u32 type, idx;
if (clkspec->args_count < 2) {
pr_err("%s: insufficient phandle args\n", __func__);
return ERR_PTR(-EINVAL);
} }
of_property_read_string(np, "clock-output-names", &clk_name); type = clkspec->args[0];
idx = clkspec->args[1];
clk = clk_register_fixed_rate(NULL, clk_name, NULL, CLK_IS_ROOT, rate); switch (type) {
if (!IS_ERR(clk)) case 0:
of_clk_add_provider(np, of_clk_src_simple_get, clk); if (idx != 0)
goto bad_args;
clk = cg->sysclk;
break;
case 1:
if (idx >= ARRAY_SIZE(cg->cmux))
goto bad_args;
clk = cg->cmux[idx];
break;
case 2:
if (idx >= ARRAY_SIZE(cg->hwaccel))
goto bad_args;
clk = cg->hwaccel[idx];
break;
case 3:
if (idx >= ARRAY_SIZE(cg->fman))
goto bad_args;
clk = cg->fman[idx];
break;
case 4:
pll = &cg->pll[PLATFORM_PLL];
if (idx >= ARRAY_SIZE(pll->div))
goto bad_args;
clk = pll->div[idx].clk;
break;
default:
goto bad_args;
}
if (!clk)
return ERR_PTR(-ENOENT);
return clk;
bad_args:
pr_err("%s: Bad phandle args %u %u\n", __func__, type, idx);
return ERR_PTR(-EINVAL);
} }
static void __init pltfrm_pll_init(struct device_node *np) #ifdef CONFIG_PPC
#include <asm/mpc85xx.h>
static const u32 a4510_svrs[] __initconst = {
(SVR_P2040 << 8) | 0x10, /* P2040 1.0 */
(SVR_P2040 << 8) | 0x11, /* P2040 1.1 */
(SVR_P2041 << 8) | 0x10, /* P2041 1.0 */
(SVR_P2041 << 8) | 0x11, /* P2041 1.1 */
(SVR_P3041 << 8) | 0x10, /* P3041 1.0 */
(SVR_P3041 << 8) | 0x11, /* P3041 1.1 */
(SVR_P4040 << 8) | 0x20, /* P4040 2.0 */
(SVR_P4080 << 8) | 0x20, /* P4080 2.0 */
(SVR_P5010 << 8) | 0x10, /* P5010 1.0 */
(SVR_P5010 << 8) | 0x20, /* P5010 2.0 */
(SVR_P5020 << 8) | 0x10, /* P5020 1.0 */
(SVR_P5021 << 8) | 0x10, /* P5021 1.0 */
(SVR_P5040 << 8) | 0x10, /* P5040 1.0 */
};
#define SVR_SECURITY 0x80000 /* The Security (E) bit */
static bool __init has_erratum_a4510(void)
{ {
void __iomem *base; u32 svr = mfspr(SPRN_SVR);
uint32_t mult; int i;
const char *parent_name, *clk_name;
int i, _errno; svr &= ~SVR_SECURITY;
struct clk_onecell_data *cod;
for (i = 0; i < ARRAY_SIZE(a4510_svrs); i++) {
base = of_iomap(np, 0); if (svr == a4510_svrs[i])
if (!base) { return true;
pr_err("%s(): %s: of_iomap() failed\n", __func__, np->name);
return;
} }
/* Get the multiple of PLL */ return false;
mult = ioread32be(base); }
#else
static bool __init has_erratum_a4510(void)
{
return false;
}
#endif
iounmap(base); static void __init clockgen_init(struct device_node *np)
{
int i, ret;
bool is_old_ls1021a = false;
/* Check if this PLL is disabled */ /* May have already been called by a legacy probe */
if (mult & PLL_KILL) { if (clockgen.node)
pr_debug("%s(): %s: Disabled\n", __func__, np->name);
return; return;
}
mult = (mult & GENMASK(6, 1)) >> 1;
parent_name = of_clk_get_parent_name(np, 0); clockgen.node = np;
if (!parent_name) { clockgen.regs = of_iomap(np, 0);
pr_err("%s(): %s: of_clk_get_parent_name() failed\n", if (!clockgen.regs &&
__func__, np->name); of_device_is_compatible(of_root, "fsl,ls1021a")) {
/* Compatibility hack for old, broken device trees */
clockgen.regs = ioremap(0x1ee1000, 0x1000);
is_old_ls1021a = true;
}
if (!clockgen.regs) {
pr_err("%s(): %s: of_iomap() failed\n", __func__, np->name);
return; return;
} }
i = of_property_count_strings(np, "clock-output-names"); for (i = 0; i < ARRAY_SIZE(chipinfo); i++) {
if (i < 0) { if (of_device_is_compatible(np, chipinfo[i].compat))
pr_err("%s(): %s: of_property_count_strings(clock-output-names) = %d\n", break;
__func__, np->name, i); if (is_old_ls1021a &&
return; !strcmp(chipinfo[i].compat, "fsl,ls1021a-clockgen"))
break;
} }
cod = kmalloc(sizeof(*cod) + i * sizeof(struct clk *), GFP_KERNEL); if (i == ARRAY_SIZE(chipinfo)) {
if (!cod) pr_err("%s: unknown clockgen node %s\n", __func__,
return; np->full_name);
cod->clks = (struct clk **)(cod + 1); goto err;
cod->clk_num = i; }
clockgen.info = chipinfo[i];
for (i = 0; i < cod->clk_num; i++) {
_errno = of_property_read_string_index(np, "clock-output-names", if (clockgen.info.guts_compat) {
i, &clk_name); struct device_node *guts;
if (_errno < 0) {
pr_err("%s(): %s: of_property_read_string_index(clock-output-names) = %d\n",
__func__, np->name, _errno);
goto return_clk_unregister;
}
cod->clks[i] = clk_register_fixed_factor(NULL, clk_name, guts = of_find_compatible_node(NULL, NULL,
parent_name, 0, mult, 1 + i); clockgen.info.guts_compat);
if (IS_ERR(cod->clks[i])) { if (guts) {
pr_err("%s(): %s: clk_register_fixed_factor(%s) = %ld\n", clockgen.guts = of_iomap(guts, 0);
__func__, np->name, if (!clockgen.guts) {
clk_name, PTR_ERR(cod->clks[i])); pr_err("%s: Couldn't map %s regs\n", __func__,
goto return_clk_unregister; guts->full_name);
}
} }
} }
_errno = of_clk_add_provider(np, of_clk_src_onecell_get, cod); if (has_erratum_a4510())
if (_errno < 0) { clockgen.info.flags |= CG_CMUX_GE_PLAT;
pr_err("%s(): %s: of_clk_add_provider() = %d\n",
__func__, np->name, _errno); clockgen.sysclk = create_sysclk("cg-sysclk");
goto return_clk_unregister; create_plls(&clockgen);
create_muxes(&clockgen);
if (clockgen.info.init_periph)
clockgen.info.init_periph(&clockgen);
ret = of_clk_add_provider(np, clockgen_clk_get, &clockgen);
if (ret) {
pr_err("%s: Couldn't register clk provider for node %s: %d\n",
__func__, np->name, ret);
} }
return; return;
err:
return_clk_unregister: iounmap(clockgen.regs);
while (--i >= 0) clockgen.regs = NULL;
clk_unregister(cod->clks[i]);
kfree(cod);
} }
CLK_OF_DECLARE(qoriq_clockgen_1, "fsl,qoriq-clockgen-1.0", clockgen_init);
CLK_OF_DECLARE(qoriq_clockgen_2, "fsl,qoriq-clockgen-2.0", clockgen_init);
CLK_OF_DECLARE(qoriq_clockgen_ls1021a, "fsl,ls1021a-clockgen", clockgen_init);
/* Legacy nodes */
CLK_OF_DECLARE(qoriq_sysclk_1, "fsl,qoriq-sysclk-1.0", sysclk_init); CLK_OF_DECLARE(qoriq_sysclk_1, "fsl,qoriq-sysclk-1.0", sysclk_init);
CLK_OF_DECLARE(qoriq_sysclk_2, "fsl,qoriq-sysclk-2.0", sysclk_init); CLK_OF_DECLARE(qoriq_sysclk_2, "fsl,qoriq-sysclk-2.0", sysclk_init);
CLK_OF_DECLARE(qoriq_core_pll_1, "fsl,qoriq-core-pll-1.0", core_pll_init); CLK_OF_DECLARE(qoriq_core_pll_1, "fsl,qoriq-core-pll-1.0", core_pll_init);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7