The changes to the common clock framework for 4.2 are dominated by new
drivers and updates to existing ones, as usual. There are some fixes to the framework itself and several cleanups for sparse warnings, etc. Please consider pulling. -----BEGIN PGP SIGNATURE----- Version: GnuPG v1 iQIcBAABAgAGBQJVlCubAAoJEKI6nJvDJaTUJ3cQAKdaU+NpWX9Qajt6snIHcqB6 nBg57DltuPh1XFMPHDIdPe+8rK0RDQjao6jwzzqUKGaZJ3sycPCIn8mh+iZCP7Se yxhacQIAIp2qbIlIQ8Epcc6jnma/8cUyfB0BuYMddzb7bk2PXLfLxzJgAo5pXZM1 LQoBxdpBh3Y7vcdBFLuHsnORTZdRI29Nu7p5dRK27vxWFBoCqL3bshHSS8g7lTBc XUWcFhfFe7WvMvBqqF8pSJlCmHzO90S0MmFPT4OQy4NtAysPpjsqI6RPCHBTyvy+ oniMM6zM/RdN1VnLB49HvAL4mArjAdsQGxNywsUpvD/IcZPbpM8N3VA3xHzANMfy iJ9374zgjRn3/YBfjYFCcyVUY7SPeiRsXh97ZMZJGY5BC5FbXuKMn3STPrUilhw/ CMSq9ARdmjlPQDW5EuEGFeap+7oz4q4Kgk0qgmOktIVYhtt9Pn0ddMKINIpokzbi 4w0z1kc/YVHZpFMNYxAQoxYzejU9hxybUvYUEnu9RFzzOW+o7DsmMv7k5r1XY+oO P1Kz0jVWCw46XnvP6z1V4SforZOQXr1Om698O8fd7ke7Q7gFCr2UQjIuXliC/g8u NREqu1kceXTeWnt0LFZB7GMOo2Edo21qYIAILyqTO50QJL2at5WLoibaM03y7I7x GeMP1APDHJI0E5dn0v5P =Iv72 -----END PGP SIGNATURE----- Merge tag 'clk-for-linus-4.2' of git://git.kernel.org/pub/scm/linux/kernel/git/clk/linux Pull clock framework updates from Michael Turquette: "The changes to the common clock framework for 4.2 are dominated by new drivers and updates to existing ones, as usual. There are some fixes to the framework itself and several cleanups for sparse warnings, etc" * tag 'clk-for-linus-4.2' of git://git.kernel.org/pub/scm/linux/kernel/git/clk/linux: (135 commits) clk: stm32: Add clock driver for STM32F4[23]xxx devices dt-bindings: Document the STM32F4 clock bindings cpufreq: exynos: remove Exynos4210 specific cpufreq driver support ARM: Exynos: switch to using generic cpufreq driver for Exynos4210 clk: samsung: exynos4: add cpu clock configuration data and instantiate cpu clock clk: samsung: add infrastructure to register cpu clocks clk: add CLK_RECALC_NEW_RATES clock flag for Exynos cpu clock support doc: dt: add documentation for lpc1850-ccu clk driver clk: add lpc18xx ccu clk driver doc: dt: add documentation for lpc1850-cgu clk driver clk: add lpc18xx cgu clk driver clk: keystone: add support for post divider register for main pll clk: mvebu: flag the crypto clk as CLK_IGNORE_UNUSED clk: cygnus: remove Cygnus dummy clock binding clk: cygnus: add clock support for Broadcom Cygnus clk: Change bcm clocks build dependency clk: iproc: add initial common clock support clk: iproc: define Broadcom iProc clock binding MAINTAINERS: update email for Michael Turquette clk: meson: add some error handling in meson_clk_register_cpu() ...
This commit is contained in:
Linus Torvalds
commit
5f1201d515
|
|
@ -230,30 +230,7 @@ clk_register(...)
|
|||
|
||||
See the basic clock types in drivers/clk/clk-*.c for examples.
|
||||
|
||||
Part 5 - static initialization of clock data
|
||||
|
||||
For platforms with many clocks (often numbering into the hundreds) it
|
||||
may be desirable to statically initialize some clock data. This
|
||||
presents a problem since the definition of struct clk should be hidden
|
||||
from everyone except for the clock core in drivers/clk/clk.c.
|
||||
|
||||
To get around this problem struct clk's definition is exposed in
|
||||
include/linux/clk-private.h along with some macros for more easily
|
||||
initializing instances of the basic clock types. These clocks must
|
||||
still be initialized with the common clock framework via a call to
|
||||
__clk_init.
|
||||
|
||||
clk-private.h must NEVER be included by code which implements struct
|
||||
clk_ops callbacks, nor must it be included by any logic which pokes
|
||||
around inside of struct clk at run-time. To do so is a layering
|
||||
violation.
|
||||
|
||||
To better enforce this policy, always follow this simple rule: any
|
||||
statically initialized clock data MUST be defined in a separate file
|
||||
from the logic that implements its ops. Basically separate the logic
|
||||
from the data and all is well.
|
||||
|
||||
Part 6 - Disabling clock gating of unused clocks
|
||||
Part 5 - Disabling clock gating of unused clocks
|
||||
|
||||
Sometimes during development it can be useful to be able to bypass the
|
||||
default disabling of unused clocks. For example, if drivers aren't enabling
|
||||
|
|
@ -264,7 +241,7 @@ are sorted out.
|
|||
To bypass this disabling, include "clk_ignore_unused" in the bootargs to the
|
||||
kernel.
|
||||
|
||||
Part 7 - Locking
|
||||
Part 6 - Locking
|
||||
|
||||
The common clock framework uses two global locks, the prepare lock and the
|
||||
enable lock.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,23 @@
|
|||
Mediatek apmixedsys controller
|
||||
==============================
|
||||
|
||||
The Mediatek apmixedsys controller provides the PLLs to the system.
|
||||
|
||||
Required Properties:
|
||||
|
||||
- compatible: Should be:
|
||||
- "mediatek,mt8135-apmixedsys"
|
||||
- "mediatek,mt8173-apmixedsys"
|
||||
- #clock-cells: Must be 1
|
||||
|
||||
The apmixedsys controller uses the common clk binding from
|
||||
Documentation/devicetree/bindings/clock/clock-bindings.txt
|
||||
The available clocks are defined in dt-bindings/clock/mt*-clk.h.
|
||||
|
||||
Example:
|
||||
|
||||
apmixedsys: clock-controller@10209000 {
|
||||
compatible = "mediatek,mt8173-apmixedsys";
|
||||
reg = <0 0x10209000 0 0x1000>;
|
||||
#clock-cells = <1>;
|
||||
};
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
Mediatek infracfg controller
|
||||
============================
|
||||
|
||||
The Mediatek infracfg controller provides various clocks and reset
|
||||
outputs to the system.
|
||||
|
||||
Required Properties:
|
||||
|
||||
- compatible: Should be:
|
||||
- "mediatek,mt8135-infracfg", "syscon"
|
||||
- "mediatek,mt8173-infracfg", "syscon"
|
||||
- #clock-cells: Must be 1
|
||||
- #reset-cells: Must be 1
|
||||
|
||||
The infracfg controller uses the common clk binding from
|
||||
Documentation/devicetree/bindings/clock/clock-bindings.txt
|
||||
The available clocks are defined in dt-bindings/clock/mt*-clk.h.
|
||||
Also it uses the common reset controller binding from
|
||||
Documentation/devicetree/bindings/reset/reset.txt.
|
||||
The available reset outputs are defined in
|
||||
dt-bindings/reset-controller/mt*-resets.h
|
||||
|
||||
Example:
|
||||
|
||||
infracfg: power-controller@10001000 {
|
||||
compatible = "mediatek,mt8173-infracfg", "syscon";
|
||||
reg = <0 0x10001000 0 0x1000>;
|
||||
#clock-cells = <1>;
|
||||
#reset-cells = <1>;
|
||||
};
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
Mediatek pericfg controller
|
||||
===========================
|
||||
|
||||
The Mediatek pericfg controller provides various clocks and reset
|
||||
outputs to the system.
|
||||
|
||||
Required Properties:
|
||||
|
||||
- compatible: Should be:
|
||||
- "mediatek,mt8135-pericfg", "syscon"
|
||||
- "mediatek,mt8173-pericfg", "syscon"
|
||||
- #clock-cells: Must be 1
|
||||
- #reset-cells: Must be 1
|
||||
|
||||
The pericfg controller uses the common clk binding from
|
||||
Documentation/devicetree/bindings/clock/clock-bindings.txt
|
||||
The available clocks are defined in dt-bindings/clock/mt*-clk.h.
|
||||
Also it uses the common reset controller binding from
|
||||
Documentation/devicetree/bindings/reset/reset.txt.
|
||||
The available reset outputs are defined in
|
||||
dt-bindings/reset-controller/mt*-resets.h
|
||||
|
||||
Example:
|
||||
|
||||
pericfg: power-controller@10003000 {
|
||||
compatible = "mediatek,mt8173-pericfg", "syscon";
|
||||
reg = <0 0x10003000 0 0x1000>;
|
||||
#clock-cells = <1>;
|
||||
#reset-cells = <1>;
|
||||
};
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
Mediatek topckgen controller
|
||||
============================
|
||||
|
||||
The Mediatek topckgen controller provides various clocks to the system.
|
||||
|
||||
Required Properties:
|
||||
|
||||
- compatible: Should be:
|
||||
- "mediatek,mt8135-topckgen"
|
||||
- "mediatek,mt8173-topckgen"
|
||||
- #clock-cells: Must be 1
|
||||
|
||||
The topckgen controller uses the common clk binding from
|
||||
Documentation/devicetree/bindings/clock/clock-bindings.txt
|
||||
The available clocks are defined in dt-bindings/clock/mt*-clk.h.
|
||||
|
||||
Example:
|
||||
|
||||
topckgen: power-controller@10000000 {
|
||||
compatible = "mediatek,mt8173-topckgen";
|
||||
reg = <0 0x10000000 0 0x1000>;
|
||||
#clock-cells = <1>;
|
||||
};
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
* Amlogic Meson8b Clock and Reset Unit
|
||||
|
||||
The Amlogic Meson8b clock controller generates and supplies clock to various
|
||||
controllers within the SoC.
|
||||
|
||||
Required Properties:
|
||||
|
||||
- compatible: should be "amlogic,meson8b-clkc"
|
||||
- reg: it must be composed by two tuples:
|
||||
0) physical base address of the xtal register and length of memory
|
||||
mapped region.
|
||||
1) physical base address of the clock controller and length of memory
|
||||
mapped region.
|
||||
|
||||
- #clock-cells: should be 1.
|
||||
|
||||
Each clock is assigned an identifier and client nodes can use this identifier
|
||||
to specify the clock which they consume. All available clocks are defined as
|
||||
preprocessor macros in the dt-bindings/clock/meson8b-clkc.h header and can be
|
||||
used in device tree sources.
|
||||
|
||||
Example: Clock controller node:
|
||||
|
||||
clkc: clock-controller@c1104000 {
|
||||
#clock-cells = <1>;
|
||||
compatible = "amlogic,meson8b-clkc";
|
||||
reg = <0xc1108000 0x4>, <0xc1104000 0x460>;
|
||||
};
|
||||
|
||||
|
||||
Example: UART controller node that consumes the clock generated by the clock
|
||||
controller:
|
||||
|
||||
uart_AO: serial@c81004c0 {
|
||||
compatible = "amlogic,meson-uart";
|
||||
reg = <0xc81004c0 0x14>;
|
||||
interrupts = <0 90 1>;
|
||||
clocks = <&clkc CLKID_CLK81>;
|
||||
status = "disabled";
|
||||
};
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
Broadcom Cygnus Clocks
|
||||
|
||||
This binding uses the common clock binding:
|
||||
Documentation/devicetree/bindings/clock/clock-bindings.txt
|
||||
|
||||
Currently various "fixed" clocks are declared for peripheral drivers that use
|
||||
the common clock framework to reference their core clocks. Proper support of
|
||||
these clocks will be added later
|
||||
|
||||
Device tree example:
|
||||
|
||||
clocks {
|
||||
#address-cells = <1>;
|
||||
#size-cells = <1>;
|
||||
ranges;
|
||||
|
||||
osc: oscillator {
|
||||
compatible = "fixed-clock";
|
||||
#clock-cells = <1>;
|
||||
clock-frequency = <25000000>;
|
||||
};
|
||||
|
||||
apb_clk: apb_clk {
|
||||
compatible = "fixed-clock";
|
||||
#clock-cells = <0>;
|
||||
clock-frequency = <1000000000>;
|
||||
};
|
||||
|
||||
periph_clk: periph_clk {
|
||||
compatible = "fixed-clock";
|
||||
#clock-cells = <0>;
|
||||
clock-frequency = <500000000>;
|
||||
};
|
||||
};
|
||||
|
|
@ -0,0 +1,132 @@
|
|||
Broadcom iProc Family Clocks
|
||||
|
||||
This binding uses the common clock binding:
|
||||
Documentation/devicetree/bindings/clock/clock-bindings.txt
|
||||
|
||||
The iProc clock controller manages clocks that are common to the iProc family.
|
||||
An SoC from the iProc family may have several PPLs, e.g., ARMPLL, GENPLL,
|
||||
LCPLL0, MIPIPLL, and etc., all derived from an onboard crystal. Each PLL
|
||||
comprises of several leaf clocks
|
||||
|
||||
Required properties for a PLL and its leaf clocks:
|
||||
|
||||
- compatible:
|
||||
Should have a value of the form "brcm,<soc>-<pll>". For example, GENPLL on
|
||||
Cygnus has a compatible string of "brcm,cygnus-genpll"
|
||||
|
||||
- #clock-cells:
|
||||
Have a value of <1> since there are more than 1 leaf clock of a given PLL
|
||||
|
||||
- reg:
|
||||
Define the base and range of the I/O address space that contain the iProc
|
||||
clock control registers required for the PLL
|
||||
|
||||
- clocks:
|
||||
The input parent clock phandle for the PLL. For most iProc PLLs, this is an
|
||||
onboard crystal with a fixed rate
|
||||
|
||||
- clock-output-names:
|
||||
An ordered list of strings defining the names of the clocks
|
||||
|
||||
Example:
|
||||
|
||||
osc: oscillator {
|
||||
#clock-cells = <0>;
|
||||
compatible = "fixed-clock";
|
||||
clock-frequency = <25000000>;
|
||||
};
|
||||
|
||||
genpll: genpll {
|
||||
#clock-cells = <1>;
|
||||
compatible = "brcm,cygnus-genpll";
|
||||
reg = <0x0301d000 0x2c>, <0x0301c020 0x4>;
|
||||
clocks = <&osc>;
|
||||
clock-output-names = "genpll", "axi21", "250mhz", "ihost_sys",
|
||||
"enet_sw", "audio_125", "can";
|
||||
};
|
||||
|
||||
Required properties for ASIU clocks:
|
||||
|
||||
ASIU clocks are a special case. These clocks are derived directly from the
|
||||
reference clock of the onboard crystal
|
||||
|
||||
- compatible:
|
||||
Should have a value of the form "brcm,<soc>-asiu-clk". For example, ASIU
|
||||
clocks for Cygnus have a compatible string of "brcm,cygnus-asiu-clk"
|
||||
|
||||
- #clock-cells:
|
||||
Have a value of <1> since there are more than 1 ASIU clocks
|
||||
|
||||
- reg:
|
||||
Define the base and range of the I/O address space that contain the iProc
|
||||
clock control registers required for ASIU clocks
|
||||
|
||||
- clocks:
|
||||
The input parent clock phandle for the ASIU clock, i.e., the onboard
|
||||
crystal
|
||||
|
||||
- clock-output-names:
|
||||
An ordered list of strings defining the names of the ASIU clocks
|
||||
|
||||
Example:
|
||||
|
||||
osc: oscillator {
|
||||
#clock-cells = <0>;
|
||||
compatible = "fixed-clock";
|
||||
clock-frequency = <25000000>;
|
||||
};
|
||||
|
||||
asiu_clks: asiu_clks {
|
||||
#clock-cells = <1>;
|
||||
compatible = "brcm,cygnus-asiu-clk";
|
||||
reg = <0x0301d048 0xc>, <0x180aa024 0x4>;
|
||||
clocks = <&osc>;
|
||||
clock-output-names = "keypad", "adc/touch", "pwm";
|
||||
};
|
||||
|
||||
Cygnus
|
||||
------
|
||||
PLL and leaf clock compatible strings for Cygnus are:
|
||||
"brcm,cygnus-armpll"
|
||||
"brcm,cygnus-genpll"
|
||||
"brcm,cygnus-lcpll0"
|
||||
"brcm,cygnus-mipipll"
|
||||
"brcm,cygnus-asiu-clk"
|
||||
|
||||
The following table defines the set of PLL/clock index and ID for Cygnus.
|
||||
These clock IDs are defined in:
|
||||
"include/dt-bindings/clock/bcm-cygnus.h"
|
||||
|
||||
Clock Source (Parent) Index ID
|
||||
--- ----- ----- ---------
|
||||
crystal N/A N/A N/A
|
||||
|
||||
armpll crystal N/A N/A
|
||||
|
||||
keypad crystal (ASIU) 0 BCM_CYGNUS_ASIU_KEYPAD_CLK
|
||||
adc/tsc crystal (ASIU) 1 BCM_CYGNUS_ASIU_ADC_CLK
|
||||
pwm crystal (ASIU) 2 BCM_CYGNUS_ASIU_PWM_CLK
|
||||
|
||||
genpll crystal 0 BCM_CYGNUS_GENPLL
|
||||
axi21 genpll 1 BCM_CYGNUS_GENPLL_AXI21_CLK
|
||||
250mhz genpll 2 BCM_CYGNUS_GENPLL_250MHZ_CLK
|
||||
ihost_sys genpll 3 BCM_CYGNUS_GENPLL_IHOST_SYS_CLK
|
||||
enet_sw genpll 4 BCM_CYGNUS_GENPLL_ENET_SW_CLK
|
||||
audio_125 genpll 5 BCM_CYGNUS_GENPLL_AUDIO_125_CLK
|
||||
can genpll 6 BCM_CYGNUS_GENPLL_CAN_CLK
|
||||
|
||||
lcpll0 crystal 0 BCM_CYGNUS_LCPLL0
|
||||
pcie_phy lcpll0 1 BCM_CYGNUS_LCPLL0_PCIE_PHY_REF_CLK
|
||||
ddr_phy lcpll0 2 BCM_CYGNUS_LCPLL0_DDR_PHY_CLK
|
||||
sdio lcpll0 3 BCM_CYGNUS_LCPLL0_SDIO_CLK
|
||||
usb_phy lcpll0 4 BCM_CYGNUS_LCPLL0_USB_PHY_REF_CLK
|
||||
smart_card lcpll0 5 BCM_CYGNUS_LCPLL0_SMART_CARD_CLK
|
||||
ch5_unused lcpll0 6 BCM_CYGNUS_LCPLL0_CH5_UNUSED
|
||||
|
||||
mipipll crystal 0 BCM_CYGNUS_MIPIPLL
|
||||
ch0_unused mipipll 1 BCM_CYGNUS_MIPIPLL_CH0_UNUSED
|
||||
ch1_lcd mipipll 2 BCM_CYGNUS_MIPIPLL_CH1_LCD
|
||||
ch2_v3d mipipll 3 BCM_CYGNUS_MIPIPLL_CH2_V3D
|
||||
ch3_unused mipipll 4 BCM_CYGNUS_MIPIPLL_CH3_UNUSED
|
||||
ch4_unused mipipll 5 BCM_CYGNUS_MIPIPLL_CH4_UNUSED
|
||||
ch5_unused mipipll 6 BCM_CYGNUS_MIPIPLL_CH5_UNUSED
|
||||
|
|
@ -138,9 +138,10 @@ Some platforms may require initial configuration of default parent clocks
|
|||
and clock frequencies. Such a configuration can be specified in a device tree
|
||||
node through assigned-clocks, assigned-clock-parents and assigned-clock-rates
|
||||
properties. The assigned-clock-parents property should contain a list of parent
|
||||
clocks in form of phandle and clock specifier pairs, the assigned-clock-parents
|
||||
property the list of assigned clock frequency values - corresponding to clocks
|
||||
listed in the assigned-clocks property.
|
||||
clocks in the form of a phandle and clock specifier pair and the
|
||||
assigned-clock-rates property should contain a list of frequencies in Hz. Both
|
||||
these properties should correspond to the clocks listed in the assigned-clocks
|
||||
property.
|
||||
|
||||
To skip setting parent or rate of a clock its corresponding entry should be
|
||||
set to 0, or can be omitted if it is not followed by any non-zero entry.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,55 @@
|
|||
* Clock and reset bindings for CSR atlas7
|
||||
|
||||
Required properties:
|
||||
- compatible: Should be "sirf,atlas7-car"
|
||||
- reg: Address and length of the register set
|
||||
- #clock-cells: Should be <1>
|
||||
- #reset-cells: Should be <1>
|
||||
|
||||
The clock consumer should specify the desired clock by having the clock
|
||||
ID in its "clocks" phandle cell.
|
||||
The ID list atlas7_clks defined in drivers/clk/sirf/clk-atlas7.c
|
||||
|
||||
The reset consumer should specify the desired reset by having the reset
|
||||
ID in its "reset" phandle cell.
|
||||
The ID list atlas7_reset_unit defined in drivers/clk/sirf/clk-atlas7.c
|
||||
|
||||
Examples: Clock and reset controller node:
|
||||
|
||||
car: clock-controller@18620000 {
|
||||
compatible = "sirf,atlas7-car";
|
||||
reg = <0x18620000 0x1000>;
|
||||
#clock-cells = <1>;
|
||||
#reset-cells = <1>;
|
||||
};
|
||||
|
||||
Examples: Consumers using clock or reset:
|
||||
|
||||
timer@10dc0000 {
|
||||
compatible = "sirf,macro-tick";
|
||||
reg = <0x10dc0000 0x1000>;
|
||||
clocks = <&car 54>;
|
||||
interrupts = <0 0 0>,
|
||||
<0 1 0>,
|
||||
<0 2 0>,
|
||||
<0 49 0>,
|
||||
<0 50 0>,
|
||||
<0 51 0>;
|
||||
};
|
||||
|
||||
uart1: uart@18020000 {
|
||||
cell-index = <1>;
|
||||
compatible = "sirf,macro-uart";
|
||||
reg = <0x18020000 0x1000>;
|
||||
clocks = <&clks 95>;
|
||||
interrupts = <0 18 0>;
|
||||
fifosize = <32>;
|
||||
};
|
||||
|
||||
vpp@13110000 {
|
||||
compatible = "sirf,prima2-vpp";
|
||||
reg = <0x13110000 0x10000>;
|
||||
interrupts = <0 31 0>;
|
||||
clocks = <&car 85>;
|
||||
resets = <&car 29>;
|
||||
};
|
||||
|
|
@ -52,7 +52,7 @@ usia_u0_sclk: usia_u0_sclk {
|
|||
|
||||
Example of consumer:
|
||||
|
||||
uart@e1020000 {
|
||||
serial@e1020000 {
|
||||
compatible = "renesas,em-uart";
|
||||
reg = <0xe1020000 0x38>;
|
||||
interrupts = <0 8 0>;
|
||||
|
|
|
|||
|
|
@ -15,8 +15,8 @@ Required properties:
|
|||
- compatible : shall be "ti,keystone,main-pll-clock" or "ti,keystone,pll-clock"
|
||||
- clocks : parent clock phandle
|
||||
- reg - pll control0 and pll multipler registers
|
||||
- reg-names : control and multiplier. The multiplier is applicable only for
|
||||
main pll clock
|
||||
- reg-names : control, multiplier and post-divider. The multiplier and
|
||||
post-divider registers are applicable only for main pll clock
|
||||
- fixed-postdiv : fixed post divider value. If absent, use clkod register bits
|
||||
for postdiv
|
||||
|
||||
|
|
@ -25,8 +25,8 @@ Example:
|
|||
#clock-cells = <0>;
|
||||
compatible = "ti,keystone,main-pll-clock";
|
||||
clocks = <&refclksys>;
|
||||
reg = <0x02620350 4>, <0x02310110 4>;
|
||||
reg-names = "control", "multiplier";
|
||||
reg = <0x02620350 4>, <0x02310110 4>, <0x02310108 4>;
|
||||
reg-names = "control", "multiplier", "post-divider";
|
||||
fixed-postdiv = <2>;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,77 @@
|
|||
* NXP LPC1850 Clock Control Unit (CCU)
|
||||
|
||||
Each CGU base clock has several clock branches which can be turned on
|
||||
or off independently by the Clock Control Units CCU1 or CCU2. The
|
||||
branch clocks are distributed between CCU1 and CCU2.
|
||||
|
||||
- Above text taken from NXP LPC1850 User Manual.
|
||||
|
||||
This binding uses the common clock binding:
|
||||
Documentation/devicetree/bindings/clock/clock-bindings.txt
|
||||
|
||||
Required properties:
|
||||
- compatible:
|
||||
Should be "nxp,lpc1850-ccu"
|
||||
- reg:
|
||||
Shall define the base and range of the address space
|
||||
containing clock control registers
|
||||
- #clock-cells:
|
||||
Shall have value <1>. The permitted clock-specifier values
|
||||
are the branch clock names defined in table below.
|
||||
- clocks:
|
||||
Shall contain a list of phandles for the base clocks routed
|
||||
from the CGU to the specific CCU. See mapping of base clocks
|
||||
and CCU in table below.
|
||||
- clock-names:
|
||||
Shall contain a list of names for the base clock routed
|
||||
from the CGU to the specific CCU. Valid CCU clock names:
|
||||
"base_usb0_clk", "base_periph_clk", "base_usb1_clk",
|
||||
"base_cpu_clk", "base_spifi_clk", "base_spi_clk",
|
||||
"base_apb1_clk", "base_apb3_clk", "base_adchs_clk",
|
||||
"base_sdio_clk", "base_ssp0_clk", "base_ssp1_clk",
|
||||
"base_uart0_clk", "base_uart1_clk", "base_uart2_clk",
|
||||
"base_uart3_clk", "base_audio_clk"
|
||||
|
||||
Which branch clocks that are available on the CCU depends on the
|
||||
specific LPC part. Check the user manual for your specific part.
|
||||
|
||||
A list of CCU clocks can be found in dt-bindings/clock/lpc18xx-ccu.h.
|
||||
|
||||
Example board file:
|
||||
|
||||
soc {
|
||||
ccu1: clock-controller@40051000 {
|
||||
compatible = "nxp,lpc1850-ccu";
|
||||
reg = <0x40051000 0x1000>;
|
||||
#clock-cells = <1>;
|
||||
clocks = <&cgu BASE_APB3_CLK>, <&cgu BASE_APB1_CLK>,
|
||||
<&cgu BASE_SPIFI_CLK>, <&cgu BASE_CPU_CLK>,
|
||||
<&cgu BASE_PERIPH_CLK>, <&cgu BASE_USB0_CLK>,
|
||||
<&cgu BASE_USB1_CLK>, <&cgu BASE_SPI_CLK>;
|
||||
clock-names = "base_apb3_clk", "base_apb1_clk",
|
||||
"base_spifi_clk", "base_cpu_clk",
|
||||
"base_periph_clk", "base_usb0_clk",
|
||||
"base_usb1_clk", "base_spi_clk";
|
||||
};
|
||||
|
||||
ccu2: clock-controller@40052000 {
|
||||
compatible = "nxp,lpc1850-ccu";
|
||||
reg = <0x40052000 0x1000>;
|
||||
#clock-cells = <1>;
|
||||
clocks = <&cgu BASE_AUDIO_CLK>, <&cgu BASE_UART3_CLK>,
|
||||
<&cgu BASE_UART2_CLK>, <&cgu BASE_UART1_CLK>,
|
||||
<&cgu BASE_UART0_CLK>, <&cgu BASE_SSP1_CLK>,
|
||||
<&cgu BASE_SSP0_CLK>, <&cgu BASE_SDIO_CLK>;
|
||||
clock-names = "base_audio_clk", "base_uart3_clk",
|
||||
"base_uart2_clk", "base_uart1_clk",
|
||||
"base_uart0_clk", "base_ssp1_clk",
|
||||
"base_ssp0_clk", "base_sdio_clk";
|
||||
};
|
||||
|
||||
/* A user of CCU brach clocks */
|
||||
uart1: serial@40082000 {
|
||||
...
|
||||
clocks = <&ccu2 CLK_APB0_UART1>, <&ccu1 CLK_CPU_UART1>;
|
||||
...
|
||||
};
|
||||
};
|
||||
|
|
@ -0,0 +1,131 @@
|
|||
* NXP LPC1850 Clock Generation Unit (CGU)
|
||||
|
||||
The CGU generates multiple independent clocks for the core and the
|
||||
peripheral blocks of the LPC18xx. Each independent clock is called
|
||||
a base clock and itself is one of the inputs to the two Clock
|
||||
Control Units (CCUs) which control the branch clocks to the
|
||||
individual peripherals.
|
||||
|
||||
The CGU selects the inputs to the clock generators from multiple
|
||||
clock sources, controls the clock generation, and routes the outputs
|
||||
of the clock generators through the clock source bus to the output
|
||||
stages. Each output stage provides an independent clock source and
|
||||
corresponds to one of the base clocks for the LPC18xx.
|
||||
|
||||
- Above text taken from NXP LPC1850 User Manual.
|
||||
|
||||
|
||||
This binding uses the common clock binding:
|
||||
Documentation/devicetree/bindings/clock/clock-bindings.txt
|
||||
|
||||
Required properties:
|
||||
- compatible:
|
||||
Should be "nxp,lpc1850-cgu"
|
||||
- reg:
|
||||
Shall define the base and range of the address space
|
||||
containing clock control registers
|
||||
- #clock-cells:
|
||||
Shall have value <1>. The permitted clock-specifier values
|
||||
are the base clock numbers defined below.
|
||||
- clocks:
|
||||
Shall contain a list of phandles for the external input
|
||||
sources to the CGU. The list shall be in the following
|
||||
order: xtal, 32khz, enet_rx_clk, enet_tx_clk, gp_clkin.
|
||||
- clock-indices:
|
||||
Shall be an ordered list of numbers defining the base clock
|
||||
number provided by the CGU.
|
||||
- clock-output-names:
|
||||
Shall be an ordered list of strings defining the names of
|
||||
the clocks provided by the CGU.
|
||||
|
||||
Which base clocks that are available on the CGU depends on the
|
||||
specific LPC part. Base clocks are numbered from 0 to 27.
|
||||
|
||||
Number: Name: Description:
|
||||
0 BASE_SAFE_CLK Base safe clock (always on) for WWDT
|
||||
1 BASE_USB0_CLK Base clock for USB0
|
||||
2 BASE_PERIPH_CLK Base clock for Cortex-M0SUB subsystem,
|
||||
SPI, and SGPIO
|
||||
3 BASE_USB1_CLK Base clock for USB1
|
||||
4 BASE_CPU_CLK System base clock for ARM Cortex-M core
|
||||
and APB peripheral blocks #0 and #2
|
||||
5 BASE_SPIFI_CLK Base clock for SPIFI
|
||||
6 BASE_SPI_CLK Base clock for SPI
|
||||
7 BASE_PHY_RX_CLK Base clock for Ethernet PHY Receive clock
|
||||
8 BASE_PHY_TX_CLK Base clock for Ethernet PHY Transmit clock
|
||||
9 BASE_APB1_CLK Base clock for APB peripheral block # 1
|
||||
10 BASE_APB3_CLK Base clock for APB peripheral block # 3
|
||||
11 BASE_LCD_CLK Base clock for LCD
|
||||
12 BASE_ADCHS_CLK Base clock for ADCHS
|
||||
13 BASE_SDIO_CLK Base clock for SD/MMC
|
||||
14 BASE_SSP0_CLK Base clock for SSP0
|
||||
15 BASE_SSP1_CLK Base clock for SSP1
|
||||
16 BASE_UART0_CLK Base clock for UART0
|
||||
17 BASE_UART1_CLK Base clock for UART1
|
||||
18 BASE_UART2_CLK Base clock for UART2
|
||||
19 BASE_UART3_CLK Base clock for UART3
|
||||
20 BASE_OUT_CLK Base clock for CLKOUT pin
|
||||
24-21 - Reserved
|
||||
25 BASE_AUDIO_CLK Base clock for audio system (I2S)
|
||||
26 BASE_CGU_OUT0_CLK Base clock for CGU_OUT0 clock output
|
||||
27 BASE_CGU_OUT1_CLK Base clock for CGU_OUT1 clock output
|
||||
|
||||
BASE_PERIPH_CLK and BASE_SPI_CLK is only available on LPC43xx.
|
||||
BASE_ADCHS_CLK is only available on LPC4370.
|
||||
|
||||
|
||||
Example board file:
|
||||
|
||||
/ {
|
||||
clocks {
|
||||
xtal: xtal {
|
||||
compatible = "fixed-clock";
|
||||
#clock-cells = <0>;
|
||||
clock-frequency = <12000000>;
|
||||
};
|
||||
|
||||
xtal32: xtal32 {
|
||||
compatible = "fixed-clock";
|
||||
#clock-cells = <0>;
|
||||
clock-frequency = <32768>;
|
||||
};
|
||||
|
||||
enet_rx_clk: enet_rx_clk {
|
||||
compatible = "fixed-clock";
|
||||
#clock-cells = <0>;
|
||||
clock-frequency = <0>;
|
||||
clock-output-names = "enet_rx_clk";
|
||||
};
|
||||
|
||||
enet_tx_clk: enet_tx_clk {
|
||||
compatible = "fixed-clock";
|
||||
#clock-cells = <0>;
|
||||
clock-frequency = <0>;
|
||||
clock-output-names = "enet_tx_clk";
|
||||
};
|
||||
|
||||
gp_clkin: gp_clkin {
|
||||
compatible = "fixed-clock";
|
||||
#clock-cells = <0>;
|
||||
clock-frequency = <0>;
|
||||
clock-output-names = "gp_clkin";
|
||||
};
|
||||
};
|
||||
|
||||
soc {
|
||||
cgu: clock-controller@40050000 {
|
||||
compatible = "nxp,lpc1850-cgu";
|
||||
reg = <0x40050000 0x1000>;
|
||||
#clock-cells = <1>;
|
||||
clocks = <&xtal>, <&creg_clk 1>, <&enet_rx_clk>, <&enet_tx_clk>, <&gp_clkin>;
|
||||
};
|
||||
|
||||
/* A CGU and CCU clock consumer */
|
||||
lcdc: lcdc@40008000 {
|
||||
...
|
||||
clocks = <&cgu BASE_LCD_CLK>, <&ccu1 CLK_CPU_LCD>;
|
||||
clock-names = "clcdclk", "apb_pclk";
|
||||
...
|
||||
};
|
||||
};
|
||||
};
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
* Marvell PXA1928 Clock Controllers
|
||||
|
||||
The PXA1928 clock subsystem generates and supplies clock to various
|
||||
controllers within the PXA1928 SoC. The PXA1928 contains 3 clock controller
|
||||
blocks called APMU, MPMU, and APBC roughly corresponding to internal buses.
|
||||
|
||||
Required Properties:
|
||||
|
||||
- compatible: should be one of the following.
|
||||
- "marvell,pxa1928-apmu" - APMU controller compatible
|
||||
- "marvell,pxa1928-mpmu" - MPMU controller compatible
|
||||
- "marvell,pxa1928-apbc" - APBC controller compatible
|
||||
- reg: physical base address of the clock controller and length of memory mapped
|
||||
region.
|
||||
- #clock-cells: should be 1.
|
||||
- #reset-cells: should be 1.
|
||||
|
||||
Each clock is assigned an identifier and client nodes use the clock controller
|
||||
phandle and this identifier to specify the clock which they consume.
|
||||
|
||||
All these identifiers can be found in <dt-bindings/clock/marvell,pxa1928.h>.
|
||||
|
|
@ -19,6 +19,7 @@ ID Clock Peripheral
|
|||
9 pex1 PCIe Cntrl 1
|
||||
15 sata0 SATA Host 0
|
||||
17 sdio SDHCI Host
|
||||
23 crypto CESA (crypto engine)
|
||||
25 tdm Time Division Mplx
|
||||
28 ddr DDR Cntrl
|
||||
30 sata1 SATA Host 0
|
||||
|
|
|
|||
|
|
@ -20,15 +20,38 @@ Required properties :
|
|||
- #reset-cells : Should be 1.
|
||||
In clock consumers, this cell represents the bit number in the CAR's
|
||||
array of CLK_RST_CONTROLLER_RST_DEVICES_* registers.
|
||||
- nvidia,external-memory-controller : phandle of the EMC driver.
|
||||
|
||||
The node should contain a "emc-timings" subnode for each supported RAM type (see
|
||||
field RAM_CODE in register PMC_STRAPPING_OPT_A).
|
||||
|
||||
Required properties for "emc-timings" nodes :
|
||||
- nvidia,ram-code : Should contain the value of RAM_CODE this timing set
|
||||
is used for.
|
||||
|
||||
Each "emc-timings" node should contain a "timing" subnode for every supported
|
||||
EMC clock rate.
|
||||
|
||||
Required properties for "timing" nodes :
|
||||
- clock-frequency : Should contain the memory clock rate to which this timing
|
||||
relates.
|
||||
- nvidia,parent-clock-frequency : Should contain the rate at which the current
|
||||
parent of the EMC clock should be running at this timing.
|
||||
- clocks : Must contain an entry for each entry in clock-names.
|
||||
See ../clocks/clock-bindings.txt for details.
|
||||
- clock-names : Must include the following entries:
|
||||
- emc-parent : the clock that should be the parent of the EMC clock at this
|
||||
timing.
|
||||
|
||||
Example SoC include file:
|
||||
|
||||
/ {
|
||||
tegra_car: clock {
|
||||
tegra_car: clock@60006000 {
|
||||
compatible = "nvidia,tegra124-car";
|
||||
reg = <0x60006000 0x1000>;
|
||||
#clock-cells = <1>;
|
||||
#reset-cells = <1>;
|
||||
nvidia,external-memory-controller = <&emc>;
|
||||
};
|
||||
|
||||
usb@c5004000 {
|
||||
|
|
@ -62,4 +85,23 @@ Example board file:
|
|||
&tegra_car {
|
||||
clocks = <&clk_32k> <&osc>;
|
||||
};
|
||||
|
||||
clock@60006000 {
|
||||
emc-timings-3 {
|
||||
nvidia,ram-code = <3>;
|
||||
|
||||
timing-12750000 {
|
||||
clock-frequency = <12750000>;
|
||||
nvidia,parent-clock-frequency = <408000000>;
|
||||
clocks = <&tegra_car TEGRA124_CLK_PLL_P>;
|
||||
clock-names = "emc-parent";
|
||||
};
|
||||
timing-20400000 {
|
||||
clock-frequency = <20400000>;
|
||||
nvidia,parent-clock-frequency = <408000000>;
|
||||
clocks = <&tegra_car TEGRA124_CLK_PLL_P>;
|
||||
clock-names = "emc-parent";
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
|
|
|
|||
|
|
@ -10,9 +10,11 @@ Required Properties:
|
|||
- "renesas,r8a73a4-div6-clock" for R8A73A4 (R-Mobile APE6) DIV6 clocks
|
||||
- "renesas,r8a7740-div6-clock" for R8A7740 (R-Mobile A1) DIV6 clocks
|
||||
- "renesas,r8a7790-div6-clock" for R8A7790 (R-Car H2) DIV6 clocks
|
||||
- "renesas,r8a7791-div6-clock" for R8A7791 (R-Car M2) DIV6 clocks
|
||||
- "renesas,r8a7791-div6-clock" for R8A7791 (R-Car M2-W) DIV6 clocks
|
||||
- "renesas,r8a7793-div6-clock" for R8A7793 (R-Car M2-N) DIV6 clocks
|
||||
- "renesas,r8a7794-div6-clock" for R8A7794 (R-Car E2) DIV6 clocks
|
||||
- "renesas,sh73a0-div6-clock" for SH73A0 (SH-Mobile AG5) DIV6 clocks
|
||||
- "renesas,cpg-div6-clock" for generic DIV6 clocks
|
||||
and "renesas,cpg-div6-clock" as a fallback.
|
||||
- reg: Base address and length of the memory resource used by the DIV6 clock
|
||||
- clocks: Reference to the parent clock(s); either one, four, or eight
|
||||
clocks must be specified. For clocks with multiple parents, invalid
|
||||
|
|
|
|||
|
|
@ -13,12 +13,14 @@ Required Properties:
|
|||
- "renesas,r7s72100-mstp-clocks" for R7S72100 (RZ) MSTP gate clocks
|
||||
- "renesas,r8a73a4-mstp-clocks" for R8A73A4 (R-Mobile APE6) MSTP gate clocks
|
||||
- "renesas,r8a7740-mstp-clocks" for R8A7740 (R-Mobile A1) MSTP gate clocks
|
||||
- "renesas,r8a7778-mstp-clocks" for R8A7778 (R-Car M1) MSTP gate clocks
|
||||
- "renesas,r8a7779-mstp-clocks" for R8A7779 (R-Car H1) MSTP gate clocks
|
||||
- "renesas,r8a7790-mstp-clocks" for R8A7790 (R-Car H2) MSTP gate clocks
|
||||
- "renesas,r8a7791-mstp-clocks" for R8A7791 (R-Car M2) MSTP gate clocks
|
||||
- "renesas,r8a7791-mstp-clocks" for R8A7791 (R-Car M2-W) MSTP gate clocks
|
||||
- "renesas,r8a7793-mstp-clocks" for R8A7793 (R-Car M2-N) MSTP gate clocks
|
||||
- "renesas,r8a7794-mstp-clocks" for R8A7794 (R-Car E2) MSTP gate clocks
|
||||
- "renesas,sh73a0-mstp-clocks" for SH73A0 (SH-MobileAG5) MSTP gate clocks
|
||||
- "renesas,cpg-mstp-clock" for generic MSTP gate clocks
|
||||
and "renesas,cpg-mstp-clocks" as a fallback.
|
||||
- reg: Base address and length of the I/O mapped registers used by the MSTP
|
||||
clocks. The first register is the clock control register and is mandatory.
|
||||
The second register is the clock status register and is optional when not
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ Required Properties:
|
|||
- "renesas,r8a7791-cpg-clocks" for the r8a7791 CPG
|
||||
- "renesas,r8a7793-cpg-clocks" for the r8a7793 CPG
|
||||
- "renesas,r8a7794-cpg-clocks" for the r8a7794 CPG
|
||||
- "renesas,rcar-gen2-cpg-clocks" for the generic R-Car Gen2 CPG
|
||||
and "renesas,rcar-gen2-cpg-clocks" as a fallback.
|
||||
|
||||
- reg: Base address and length of the memory resource used by the CPG
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ Required Properties:
|
|||
|
||||
- compatible: Must be one of
|
||||
- "renesas,r7s72100-cpg-clocks" for the r7s72100 CPG
|
||||
- "renesas,rz-cpg-clocks" for the generic RZ CPG
|
||||
and "renesas,rz-cpg-clocks" as a fallback.
|
||||
- reg: Base address and length of the memory resource used by the CPG
|
||||
- clocks: References to possible parent clocks. Order must match clock modes
|
||||
in the datasheet. For the r7s72100, this is extal, usb_x1.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,65 @@
|
|||
STMicroelectronics STM32 Reset and Clock Controller
|
||||
===================================================
|
||||
|
||||
The RCC IP is both a reset and a clock controller. This documentation only
|
||||
describes the clock part.
|
||||
|
||||
Please also refer to clock-bindings.txt in this directory for common clock
|
||||
controller binding usage.
|
||||
|
||||
Required properties:
|
||||
- compatible: Should be "st,stm32f42xx-rcc"
|
||||
- reg: should be register base and length as documented in the
|
||||
datasheet
|
||||
- #clock-cells: 2, device nodes should specify the clock in their "clocks"
|
||||
property, containing a phandle to the clock device node, an index selecting
|
||||
between gated clocks and other clocks and an index specifying the clock to
|
||||
use.
|
||||
|
||||
Example:
|
||||
|
||||
rcc: rcc@40023800 {
|
||||
#clock-cells = <2>
|
||||
compatible = "st,stm32f42xx-rcc", "st,stm32-rcc";
|
||||
reg = <0x40023800 0x400>;
|
||||
};
|
||||
|
||||
Specifying gated clocks
|
||||
=======================
|
||||
|
||||
The primary index must be set to 0.
|
||||
|
||||
The secondary index is the bit number within the RCC register bank, starting
|
||||
from the first RCC clock enable register (RCC_AHB1ENR, address offset 0x30).
|
||||
|
||||
It is calculated as: index = register_offset / 4 * 32 + bit_offset.
|
||||
Where bit_offset is the bit offset within the register (LSB is 0, MSB is 31).
|
||||
|
||||
Example:
|
||||
|
||||
/* Gated clock, AHB1 bit 0 (GPIOA) */
|
||||
... {
|
||||
clocks = <&rcc 0 0>
|
||||
};
|
||||
|
||||
/* Gated clock, AHB2 bit 4 (CRYP) */
|
||||
... {
|
||||
clocks = <&rcc 0 36>
|
||||
};
|
||||
|
||||
Specifying other clocks
|
||||
=======================
|
||||
|
||||
The primary index must be set to 1.
|
||||
|
||||
The secondary index is bound with the following magic numbers:
|
||||
|
||||
0 SYSTICK
|
||||
1 FCLK
|
||||
|
||||
Example:
|
||||
|
||||
/* Misc clock, FCLK */
|
||||
... {
|
||||
clocks = <&rcc 1 1>
|
||||
};
|
||||
|
|
@ -67,6 +67,7 @@ Required properties:
|
|||
"allwinner,sun4i-a10-usb-clk" - for usb gates + resets on A10 / A20
|
||||
"allwinner,sun5i-a13-usb-clk" - for usb gates + resets on A13
|
||||
"allwinner,sun6i-a31-usb-clk" - for usb gates + resets on A31
|
||||
"allwinner,sun8i-a23-usb-clk" - for usb gates + resets on A23
|
||||
"allwinner,sun9i-a80-usb-mod-clk" - for usb gates + resets on A80
|
||||
"allwinner,sun9i-a80-usb-phy-clk" - for usb phy gates + resets on A80
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,42 @@
|
|||
Binding for TO CDCE925 programmable I2C clock synthesizers.
|
||||
|
||||
Reference
|
||||
This binding uses the common clock binding[1].
|
||||
|
||||
[1] Documentation/devicetree/bindings/clock/clock-bindings.txt
|
||||
[2] http://www.ti.com/product/cdce925
|
||||
|
||||
The driver provides clock sources for each output Y1 through Y5.
|
||||
|
||||
Required properties:
|
||||
- compatible: Shall be "ti,cdce925"
|
||||
- reg: I2C device address.
|
||||
- clocks: Points to a fixed parent clock that provides the input frequency.
|
||||
- #clock-cells: From common clock bindings: Shall be 1.
|
||||
|
||||
Optional properties:
|
||||
- xtal-load-pf: Crystal load-capacitor value to fine-tune performance on a
|
||||
board, or to compensate for external influences.
|
||||
|
||||
For both PLL1 and PLL2 an optional child node can be used to specify spread
|
||||
spectrum clocking parameters for a board.
|
||||
- spread-spectrum: SSC mode as defined in the data sheet.
|
||||
- spread-spectrum-center: Use "centered" mode instead of "max" mode. When
|
||||
present, the clock runs at the requested frequency on average. Otherwise
|
||||
the requested frequency is the maximum value of the SCC range.
|
||||
|
||||
|
||||
Example:
|
||||
|
||||
clockgen: cdce925pw@64 {
|
||||
compatible = "cdce925";
|
||||
reg = <0x64>;
|
||||
clocks = <&xtal_27Mhz>;
|
||||
#clock-cells = <1>;
|
||||
xtal-load-pf = <5>;
|
||||
/* PLL options to get SSC 1% centered */
|
||||
PLL2 {
|
||||
spread-spectrum = <4>;
|
||||
spread-spectrum-center;
|
||||
};
|
||||
};
|
||||
|
|
@ -2763,7 +2763,7 @@ F: Documentation/devicetree/bindings/media/coda.txt
|
|||
F: drivers/media/platform/coda/
|
||||
|
||||
COMMON CLK FRAMEWORK
|
||||
M: Mike Turquette <mturquette@linaro.org>
|
||||
M: Michael Turquette <mturquette@baylibre.com>
|
||||
M: Stephen Boyd <sboyd@codeaurora.org>
|
||||
L: linux-clk@vger.kernel.org
|
||||
T: git git://git.kernel.org/pub/scm/linux/kernel/git/clk/linux.git
|
||||
|
|
|
|||
|
|
@ -38,6 +38,21 @@
|
|||
};
|
||||
};
|
||||
|
||||
clocks {
|
||||
xinw {
|
||||
compatible = "fixed-clock";
|
||||
#clock-cells = <0>;
|
||||
clock-frequency = <32768>;
|
||||
clock-output-names = "xinw";
|
||||
};
|
||||
xin {
|
||||
compatible = "fixed-clock";
|
||||
#clock-cells = <0>;
|
||||
clock-frequency = <26000000>;
|
||||
clock-output-names = "xin";
|
||||
};
|
||||
};
|
||||
|
||||
noc {
|
||||
compatible = "simple-bus";
|
||||
#address-cells = <1>;
|
||||
|
|
|
|||
|
|
@ -224,6 +224,25 @@ static void __init exynos_init_irq(void)
|
|||
exynos_map_pmu();
|
||||
}
|
||||
|
||||
static const struct of_device_id exynos_cpufreq_matches[] = {
|
||||
{ .compatible = "samsung,exynos4210", .data = "cpufreq-dt" },
|
||||
{ /* sentinel */ }
|
||||
};
|
||||
|
||||
static void __init exynos_cpufreq_init(void)
|
||||
{
|
||||
struct device_node *root = of_find_node_by_path("/");
|
||||
const struct of_device_id *match;
|
||||
|
||||
match = of_match_node(exynos_cpufreq_matches, root);
|
||||
if (!match) {
|
||||
platform_device_register_simple("exynos-cpufreq", -1, NULL, 0);
|
||||
return;
|
||||
}
|
||||
|
||||
platform_device_register_simple(match->data, -1, NULL, 0);
|
||||
}
|
||||
|
||||
static void __init exynos_dt_machine_init(void)
|
||||
{
|
||||
/*
|
||||
|
|
@ -246,7 +265,7 @@ static void __init exynos_dt_machine_init(void)
|
|||
of_machine_is_compatible("samsung,exynos5250"))
|
||||
platform_device_register(&exynos_cpuidle);
|
||||
|
||||
platform_device_register_simple("exynos-cpufreq", -1, NULL, 0);
|
||||
exynos_cpufreq_init();
|
||||
|
||||
of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -78,6 +78,23 @@ config COMMON_CLK_SI570
|
|||
This driver supports Silicon Labs 570/571/598/599 programmable
|
||||
clock generators.
|
||||
|
||||
config COMMON_CLK_CDCE925
|
||||
tristate "Clock driver for TI CDCE925 devices"
|
||||
depends on I2C
|
||||
depends on OF
|
||||
select REGMAP_I2C
|
||||
help
|
||||
---help---
|
||||
This driver supports the TI CDCE925 programmable clock synthesizer.
|
||||
The chip contains two PLLs with spread-spectrum clocking support and
|
||||
five output dividers. The driver only supports the following setup,
|
||||
and uses a fixed setting for the output muxes.
|
||||
Y1 is derived from the input clock
|
||||
Y2 and Y3 derive from PLL1
|
||||
Y4 and Y5 derive from PLL2
|
||||
Given a target output frequency, the driver will set the PLL and
|
||||
divider to best approximate the desired output.
|
||||
|
||||
config COMMON_CLK_S2MPS11
|
||||
tristate "Clock driver for S2MPS1X/S5M8767 MFD"
|
||||
depends on MFD_SEC_CORE
|
||||
|
|
@ -150,11 +167,13 @@ config COMMON_CLK_CDCE706
|
|||
---help---
|
||||
This driver supports TI CDCE706 programmable 3-PLL clock synthesizer.
|
||||
|
||||
source "drivers/clk/bcm/Kconfig"
|
||||
source "drivers/clk/hisilicon/Kconfig"
|
||||
source "drivers/clk/qcom/Kconfig"
|
||||
|
||||
endmenu
|
||||
|
||||
source "drivers/clk/bcm/Kconfig"
|
||||
source "drivers/clk/mvebu/Kconfig"
|
||||
|
||||
source "drivers/clk/samsung/Kconfig"
|
||||
source "drivers/clk/tegra/Kconfig"
|
||||
|
|
|
|||
|
|
@ -38,6 +38,8 @@ obj-$(CONFIG_COMMON_CLK_RK808) += clk-rk808.o
|
|||
obj-$(CONFIG_COMMON_CLK_S2MPS11) += clk-s2mps11.o
|
||||
obj-$(CONFIG_COMMON_CLK_SI5351) += clk-si5351.o
|
||||
obj-$(CONFIG_COMMON_CLK_SI570) += clk-si570.o
|
||||
obj-$(CONFIG_COMMON_CLK_CDCE925) += clk-cdce925.o
|
||||
obj-$(CONFIG_ARCH_STM32) += clk-stm32f4.o
|
||||
obj-$(CONFIG_CLK_TWL6040) += clk-twl6040.o
|
||||
obj-$(CONFIG_ARCH_U300) += clk-u300.o
|
||||
obj-$(CONFIG_ARCH_VT8500) += clk-vt8500.o
|
||||
|
|
@ -45,19 +47,20 @@ obj-$(CONFIG_COMMON_CLK_WM831X) += clk-wm831x.o
|
|||
obj-$(CONFIG_COMMON_CLK_XGENE) += clk-xgene.o
|
||||
obj-$(CONFIG_COMMON_CLK_PWM) += clk-pwm.o
|
||||
obj-$(CONFIG_COMMON_CLK_AT91) += at91/
|
||||
obj-$(CONFIG_ARCH_BCM_MOBILE) += bcm/
|
||||
obj-$(CONFIG_ARCH_BCM) += bcm/
|
||||
obj-$(CONFIG_ARCH_BERLIN) += berlin/
|
||||
obj-$(CONFIG_ARCH_HI3xxx) += hisilicon/
|
||||
obj-$(CONFIG_ARCH_HIP04) += hisilicon/
|
||||
obj-$(CONFIG_ARCH_HIX5HD2) += hisilicon/
|
||||
obj-$(CONFIG_ARCH_HISI) += hisilicon/
|
||||
obj-$(CONFIG_ARCH_MXC) += imx/
|
||||
obj-$(CONFIG_MACH_INGENIC) += ingenic/
|
||||
obj-$(CONFIG_COMMON_CLK_KEYSTONE) += keystone/
|
||||
obj-$(CONFIG_ARCH_MEDIATEK) += mediatek/
|
||||
ifeq ($(CONFIG_COMMON_CLK), y)
|
||||
obj-$(CONFIG_ARCH_MMP) += mmp/
|
||||
endif
|
||||
obj-$(CONFIG_PLAT_ORION) += mvebu/
|
||||
obj-$(CONFIG_ARCH_MESON) += meson/
|
||||
obj-$(CONFIG_ARCH_MXS) += mxs/
|
||||
obj-$(CONFIG_ARCH_LPC18XX) += nxp/
|
||||
obj-$(CONFIG_MACH_PISTACHIO) += pistachio/
|
||||
obj-$(CONFIG_COMMON_CLK_PXA) += pxa/
|
||||
obj-$(CONFIG_COMMON_CLK_QCOM) += qcom/
|
||||
|
|
|
|||
|
|
@ -614,7 +614,7 @@ void __init of_at91sam9x5_clk_main_setup(struct device_node *np,
|
|||
const char *name = np->name;
|
||||
int i;
|
||||
|
||||
num_parents = of_count_phandle_with_args(np, "clocks", "#clock-cells");
|
||||
num_parents = of_clk_get_parent_count(np);
|
||||
if (num_parents <= 0 || num_parents > 2)
|
||||
return;
|
||||
|
||||
|
|
|
|||
|
|
@ -224,7 +224,7 @@ of_at91_clk_master_setup(struct device_node *np, struct at91_pmc *pmc,
|
|||
const char *name = np->name;
|
||||
struct clk_master_characteristics *characteristics;
|
||||
|
||||
num_parents = of_count_phandle_with_args(np, "clocks", "#clock-cells");
|
||||
num_parents = of_clk_get_parent_count(np);
|
||||
if (num_parents <= 0 || num_parents > MASTER_SOURCE_MAX)
|
||||
return;
|
||||
|
||||
|
|
|
|||
|
|
@ -237,7 +237,7 @@ of_at91_clk_prog_setup(struct device_node *np, struct at91_pmc *pmc,
|
|||
const char *name;
|
||||
struct device_node *progclknp;
|
||||
|
||||
num_parents = of_count_phandle_with_args(np, "clocks", "#clock-cells");
|
||||
num_parents = of_clk_get_parent_count(np);
|
||||
if (num_parents <= 0 || num_parents > PROG_SOURCE_MAX)
|
||||
return;
|
||||
|
||||
|
|
|
|||
|
|
@ -373,7 +373,7 @@ void __init of_at91sam9x5_clk_slow_setup(struct device_node *np,
|
|||
const char *name = np->name;
|
||||
int i;
|
||||
|
||||
num_parents = of_count_phandle_with_args(np, "clocks", "#clock-cells");
|
||||
num_parents = of_clk_get_parent_count(np);
|
||||
if (num_parents <= 0 || num_parents > 2)
|
||||
return;
|
||||
|
||||
|
|
@ -451,7 +451,7 @@ void __init of_at91sam9260_clk_slow_setup(struct device_node *np,
|
|||
const char *name = np->name;
|
||||
int i;
|
||||
|
||||
num_parents = of_count_phandle_with_args(np, "clocks", "#clock-cells");
|
||||
num_parents = of_clk_get_parent_count(np);
|
||||
if (num_parents != 2)
|
||||
return;
|
||||
|
||||
|
|
|
|||
|
|
@ -150,7 +150,7 @@ void __init of_at91sam9x5_clk_smd_setup(struct device_node *np,
|
|||
const char *parent_names[SMD_SOURCE_MAX];
|
||||
const char *name = np->name;
|
||||
|
||||
num_parents = of_count_phandle_with_args(np, "clocks", "#clock-cells");
|
||||
num_parents = of_clk_get_parent_count(np);
|
||||
if (num_parents <= 0 || num_parents > SMD_SOURCE_MAX)
|
||||
return;
|
||||
|
||||
|
|
|
|||
|
|
@ -378,7 +378,7 @@ void __init of_at91sam9x5_clk_usb_setup(struct device_node *np,
|
|||
const char *parent_names[USB_SOURCE_MAX];
|
||||
const char *name = np->name;
|
||||
|
||||
num_parents = of_count_phandle_with_args(np, "clocks", "#clock-cells");
|
||||
num_parents = of_clk_get_parent_count(np);
|
||||
if (num_parents <= 0 || num_parents > USB_SOURCE_MAX)
|
||||
return;
|
||||
|
||||
|
|
|
|||
|
|
@ -153,7 +153,7 @@ static int pmc_irq_domain_xlate(struct irq_domain *d,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static struct irq_domain_ops pmc_irq_ops = {
|
||||
static const struct irq_domain_ops pmc_irq_ops = {
|
||||
.map = pmc_irq_map,
|
||||
.xlate = pmc_irq_domain_xlate,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -7,3 +7,12 @@ config CLK_BCM_KONA
|
|||
Enable common clock framework support for Broadcom SoCs
|
||||
using "Kona" style clock control units, including those
|
||||
in the BCM281xx and BCM21664 families.
|
||||
|
||||
config COMMON_CLK_IPROC
|
||||
bool "Broadcom iProc clock support"
|
||||
depends on ARCH_BCM_IPROC
|
||||
depends on COMMON_CLK
|
||||
default ARCH_BCM_IPROC
|
||||
help
|
||||
Enable common clock framework support for Broadcom SoCs
|
||||
based on the iProc architecture
|
||||
|
|
|
|||
|
|
@ -2,3 +2,5 @@ obj-$(CONFIG_CLK_BCM_KONA) += clk-kona.o
|
|||
obj-$(CONFIG_CLK_BCM_KONA) += clk-kona-setup.o
|
||||
obj-$(CONFIG_CLK_BCM_KONA) += clk-bcm281xx.o
|
||||
obj-$(CONFIG_CLK_BCM_KONA) += clk-bcm21664.o
|
||||
obj-$(CONFIG_COMMON_CLK_IPROC) += clk-iproc-armpll.o clk-iproc-pll.o clk-iproc-asiu.o
|
||||
obj-$(CONFIG_ARCH_BCM_CYGNUS) += clk-cygnus.o
|
||||
|
|
|
|||
|
|
@ -0,0 +1,265 @@
|
|||
/*
|
||||
* Copyright (C) 2014 Broadcom Corporation
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation version 2.
|
||||
*
|
||||
* This program is distributed "as is" WITHOUT ANY WARRANTY of any
|
||||
* kind, whether express or implied; without even the implied warranty
|
||||
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/clk-provider.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/clkdev.h>
|
||||
#include <linux/of_address.h>
|
||||
#include <linux/delay.h>
|
||||
|
||||
#include <dt-bindings/clock/bcm-cygnus.h>
|
||||
#include "clk-iproc.h"
|
||||
|
||||
#define reg_val(o, s, w) { .offset = o, .shift = s, .width = w, }
|
||||
|
||||
#define aon_val(o, pw, ps, is) { .offset = o, .pwr_width = pw, \
|
||||
.pwr_shift = ps, .iso_shift = is }
|
||||
|
||||
#define sw_ctrl_val(o, s) { .offset = o, .shift = s, }
|
||||
|
||||
#define asiu_div_val(o, es, hs, hw, ls, lw) \
|
||||
{ .offset = o, .en_shift = es, .high_shift = hs, \
|
||||
.high_width = hw, .low_shift = ls, .low_width = lw }
|
||||
|
||||
#define reset_val(o, rs, prs, kis, kiw, kps, kpw, kas, kaw) { .offset = o, \
|
||||
.reset_shift = rs, .p_reset_shift = prs, .ki_shift = kis, \
|
||||
.ki_width = kiw, .kp_shift = kps, .kp_width = kpw, .ka_shift = kas, \
|
||||
.ka_width = kaw }
|
||||
|
||||
#define vco_ctrl_val(uo, lo) { .u_offset = uo, .l_offset = lo }
|
||||
|
||||
#define enable_val(o, es, hs, bs) { .offset = o, .enable_shift = es, \
|
||||
.hold_shift = hs, .bypass_shift = bs }
|
||||
|
||||
#define asiu_gate_val(o, es) { .offset = o, .en_shift = es }
|
||||
|
||||
static void __init cygnus_armpll_init(struct device_node *node)
|
||||
{
|
||||
iproc_armpll_setup(node);
|
||||
}
|
||||
CLK_OF_DECLARE(cygnus_armpll, "brcm,cygnus-armpll", cygnus_armpll_init);
|
||||
|
||||
static const struct iproc_pll_ctrl genpll = {
|
||||
.flags = IPROC_CLK_AON | IPROC_CLK_PLL_HAS_NDIV_FRAC |
|
||||
IPROC_CLK_PLL_NEEDS_SW_CFG,
|
||||
.aon = aon_val(0x0, 2, 1, 0),
|
||||
.reset = reset_val(0x0, 11, 10, 4, 3, 0, 4, 7, 3),
|
||||
.sw_ctrl = sw_ctrl_val(0x10, 31),
|
||||
.ndiv_int = reg_val(0x10, 20, 10),
|
||||
.ndiv_frac = reg_val(0x10, 0, 20),
|
||||
.pdiv = reg_val(0x14, 0, 4),
|
||||
.vco_ctrl = vco_ctrl_val(0x18, 0x1c),
|
||||
.status = reg_val(0x28, 12, 1),
|
||||
};
|
||||
|
||||
static const struct iproc_clk_ctrl genpll_clk[] = {
|
||||
[BCM_CYGNUS_GENPLL_AXI21_CLK] = {
|
||||
.channel = BCM_CYGNUS_GENPLL_AXI21_CLK,
|
||||
.flags = IPROC_CLK_AON,
|
||||
.enable = enable_val(0x4, 6, 0, 12),
|
||||
.mdiv = reg_val(0x20, 0, 8),
|
||||
},
|
||||
[BCM_CYGNUS_GENPLL_250MHZ_CLK] = {
|
||||
.channel = BCM_CYGNUS_GENPLL_250MHZ_CLK,
|
||||
.flags = IPROC_CLK_AON,
|
||||
.enable = enable_val(0x4, 7, 1, 13),
|
||||
.mdiv = reg_val(0x20, 10, 8),
|
||||
},
|
||||
[BCM_CYGNUS_GENPLL_IHOST_SYS_CLK] = {
|
||||
.channel = BCM_CYGNUS_GENPLL_IHOST_SYS_CLK,
|
||||
.flags = IPROC_CLK_AON,
|
||||
.enable = enable_val(0x4, 8, 2, 14),
|
||||
.mdiv = reg_val(0x20, 20, 8),
|
||||
},
|
||||
[BCM_CYGNUS_GENPLL_ENET_SW_CLK] = {
|
||||
.channel = BCM_CYGNUS_GENPLL_ENET_SW_CLK,
|
||||
.flags = IPROC_CLK_AON,
|
||||
.enable = enable_val(0x4, 9, 3, 15),
|
||||
.mdiv = reg_val(0x24, 0, 8),
|
||||
},
|
||||
[BCM_CYGNUS_GENPLL_AUDIO_125_CLK] = {
|
||||
.channel = BCM_CYGNUS_GENPLL_AUDIO_125_CLK,
|
||||
.flags = IPROC_CLK_AON,
|
||||
.enable = enable_val(0x4, 10, 4, 16),
|
||||
.mdiv = reg_val(0x24, 10, 8),
|
||||
},
|
||||
[BCM_CYGNUS_GENPLL_CAN_CLK] = {
|
||||
.channel = BCM_CYGNUS_GENPLL_CAN_CLK,
|
||||
.flags = IPROC_CLK_AON,
|
||||
.enable = enable_val(0x4, 11, 5, 17),
|
||||
.mdiv = reg_val(0x24, 20, 8),
|
||||
},
|
||||
};
|
||||
|
||||
static void __init cygnus_genpll_clk_init(struct device_node *node)
|
||||
{
|
||||
iproc_pll_clk_setup(node, &genpll, NULL, 0, genpll_clk,
|
||||
ARRAY_SIZE(genpll_clk));
|
||||
}
|
||||
CLK_OF_DECLARE(cygnus_genpll, "brcm,cygnus-genpll", cygnus_genpll_clk_init);
|
||||
|
||||
static const struct iproc_pll_ctrl lcpll0 = {
|
||||
.flags = IPROC_CLK_AON | IPROC_CLK_PLL_NEEDS_SW_CFG,
|
||||
.aon = aon_val(0x0, 2, 5, 4),
|
||||
.reset = reset_val(0x0, 31, 30, 27, 3, 23, 4, 19, 4),
|
||||
.sw_ctrl = sw_ctrl_val(0x4, 31),
|
||||
.ndiv_int = reg_val(0x4, 16, 10),
|
||||
.pdiv = reg_val(0x4, 26, 4),
|
||||
.vco_ctrl = vco_ctrl_val(0x10, 0x14),
|
||||
.status = reg_val(0x18, 12, 1),
|
||||
};
|
||||
|
||||
static const struct iproc_clk_ctrl lcpll0_clk[] = {
|
||||
[BCM_CYGNUS_LCPLL0_PCIE_PHY_REF_CLK] = {
|
||||
.channel = BCM_CYGNUS_LCPLL0_PCIE_PHY_REF_CLK,
|
||||
.flags = IPROC_CLK_AON,
|
||||
.enable = enable_val(0x0, 7, 1, 13),
|
||||
.mdiv = reg_val(0x8, 0, 8),
|
||||
},
|
||||
[BCM_CYGNUS_LCPLL0_DDR_PHY_CLK] = {
|
||||
.channel = BCM_CYGNUS_LCPLL0_DDR_PHY_CLK,
|
||||
.flags = IPROC_CLK_AON,
|
||||
.enable = enable_val(0x0, 8, 2, 14),
|
||||
.mdiv = reg_val(0x8, 10, 8),
|
||||
},
|
||||
[BCM_CYGNUS_LCPLL0_SDIO_CLK] = {
|
||||
.channel = BCM_CYGNUS_LCPLL0_SDIO_CLK,
|
||||
.flags = IPROC_CLK_AON,
|
||||
.enable = enable_val(0x0, 9, 3, 15),
|
||||
.mdiv = reg_val(0x8, 20, 8),
|
||||
},
|
||||
[BCM_CYGNUS_LCPLL0_USB_PHY_REF_CLK] = {
|
||||
.channel = BCM_CYGNUS_LCPLL0_USB_PHY_REF_CLK,
|
||||
.flags = IPROC_CLK_AON,
|
||||
.enable = enable_val(0x0, 10, 4, 16),
|
||||
.mdiv = reg_val(0xc, 0, 8),
|
||||
},
|
||||
[BCM_CYGNUS_LCPLL0_SMART_CARD_CLK] = {
|
||||
.channel = BCM_CYGNUS_LCPLL0_SMART_CARD_CLK,
|
||||
.flags = IPROC_CLK_AON,
|
||||
.enable = enable_val(0x0, 11, 5, 17),
|
||||
.mdiv = reg_val(0xc, 10, 8),
|
||||
},
|
||||
[BCM_CYGNUS_LCPLL0_CH5_UNUSED] = {
|
||||
.channel = BCM_CYGNUS_LCPLL0_CH5_UNUSED,
|
||||
.flags = IPROC_CLK_AON,
|
||||
.enable = enable_val(0x0, 12, 6, 18),
|
||||
.mdiv = reg_val(0xc, 20, 8),
|
||||
},
|
||||
};
|
||||
|
||||
static void __init cygnus_lcpll0_clk_init(struct device_node *node)
|
||||
{
|
||||
iproc_pll_clk_setup(node, &lcpll0, NULL, 0, lcpll0_clk,
|
||||
ARRAY_SIZE(lcpll0_clk));
|
||||
}
|
||||
CLK_OF_DECLARE(cygnus_lcpll0, "brcm,cygnus-lcpll0", cygnus_lcpll0_clk_init);
|
||||
|
||||
/*
|
||||
* MIPI PLL VCO frequency parameter table
|
||||
*/
|
||||
static const struct iproc_pll_vco_param mipipll_vco_params[] = {
|
||||
/* rate (Hz) ndiv_int ndiv_frac pdiv */
|
||||
{ 750000000UL, 30, 0, 1 },
|
||||
{ 1000000000UL, 40, 0, 1 },
|
||||
{ 1350000000ul, 54, 0, 1 },
|
||||
{ 2000000000UL, 80, 0, 1 },
|
||||
{ 2100000000UL, 84, 0, 1 },
|
||||
{ 2250000000UL, 90, 0, 1 },
|
||||
{ 2500000000UL, 100, 0, 1 },
|
||||
{ 2700000000UL, 54, 0, 0 },
|
||||
{ 2975000000UL, 119, 0, 1 },
|
||||
{ 3100000000UL, 124, 0, 1 },
|
||||
{ 3150000000UL, 126, 0, 1 },
|
||||
};
|
||||
|
||||
static const struct iproc_pll_ctrl mipipll = {
|
||||
.flags = IPROC_CLK_PLL_ASIU | IPROC_CLK_PLL_HAS_NDIV_FRAC |
|
||||
IPROC_CLK_NEEDS_READ_BACK,
|
||||
.aon = aon_val(0x0, 4, 17, 16),
|
||||
.asiu = asiu_gate_val(0x0, 3),
|
||||
.reset = reset_val(0x0, 11, 10, 4, 3, 0, 4, 7, 4),
|
||||
.ndiv_int = reg_val(0x10, 20, 10),
|
||||
.ndiv_frac = reg_val(0x10, 0, 20),
|
||||
.pdiv = reg_val(0x14, 0, 4),
|
||||
.vco_ctrl = vco_ctrl_val(0x18, 0x1c),
|
||||
.status = reg_val(0x28, 12, 1),
|
||||
};
|
||||
|
||||
static const struct iproc_clk_ctrl mipipll_clk[] = {
|
||||
[BCM_CYGNUS_MIPIPLL_CH0_UNUSED] = {
|
||||
.channel = BCM_CYGNUS_MIPIPLL_CH0_UNUSED,
|
||||
.flags = IPROC_CLK_NEEDS_READ_BACK,
|
||||
.enable = enable_val(0x4, 12, 6, 18),
|
||||
.mdiv = reg_val(0x20, 0, 8),
|
||||
},
|
||||
[BCM_CYGNUS_MIPIPLL_CH1_LCD] = {
|
||||
.channel = BCM_CYGNUS_MIPIPLL_CH1_LCD,
|
||||
.flags = IPROC_CLK_NEEDS_READ_BACK,
|
||||
.enable = enable_val(0x4, 13, 7, 19),
|
||||
.mdiv = reg_val(0x20, 10, 8),
|
||||
},
|
||||
[BCM_CYGNUS_MIPIPLL_CH2_V3D] = {
|
||||
.channel = BCM_CYGNUS_MIPIPLL_CH2_V3D,
|
||||
.flags = IPROC_CLK_NEEDS_READ_BACK,
|
||||
.enable = enable_val(0x4, 14, 8, 20),
|
||||
.mdiv = reg_val(0x20, 20, 8),
|
||||
},
|
||||
[BCM_CYGNUS_MIPIPLL_CH3_UNUSED] = {
|
||||
.channel = BCM_CYGNUS_MIPIPLL_CH3_UNUSED,
|
||||
.flags = IPROC_CLK_NEEDS_READ_BACK,
|
||||
.enable = enable_val(0x4, 15, 9, 21),
|
||||
.mdiv = reg_val(0x24, 0, 8),
|
||||
},
|
||||
[BCM_CYGNUS_MIPIPLL_CH4_UNUSED] = {
|
||||
.channel = BCM_CYGNUS_MIPIPLL_CH4_UNUSED,
|
||||
.flags = IPROC_CLK_NEEDS_READ_BACK,
|
||||
.enable = enable_val(0x4, 16, 10, 22),
|
||||
.mdiv = reg_val(0x24, 10, 8),
|
||||
},
|
||||
[BCM_CYGNUS_MIPIPLL_CH5_UNUSED] = {
|
||||
.channel = BCM_CYGNUS_MIPIPLL_CH5_UNUSED,
|
||||
.flags = IPROC_CLK_NEEDS_READ_BACK,
|
||||
.enable = enable_val(0x4, 17, 11, 23),
|
||||
.mdiv = reg_val(0x24, 20, 8),
|
||||
},
|
||||
};
|
||||
|
||||
static void __init cygnus_mipipll_clk_init(struct device_node *node)
|
||||
{
|
||||
iproc_pll_clk_setup(node, &mipipll, mipipll_vco_params,
|
||||
ARRAY_SIZE(mipipll_vco_params), mipipll_clk,
|
||||
ARRAY_SIZE(mipipll_clk));
|
||||
}
|
||||
CLK_OF_DECLARE(cygnus_mipipll, "brcm,cygnus-mipipll", cygnus_mipipll_clk_init);
|
||||
|
||||
static const struct iproc_asiu_div asiu_div[] = {
|
||||
[BCM_CYGNUS_ASIU_KEYPAD_CLK] = asiu_div_val(0x0, 31, 16, 10, 0, 10),
|
||||
[BCM_CYGNUS_ASIU_ADC_CLK] = asiu_div_val(0x4, 31, 16, 10, 0, 10),
|
||||
[BCM_CYGNUS_ASIU_PWM_CLK] = asiu_div_val(0x8, 31, 16, 10, 0, 10),
|
||||
};
|
||||
|
||||
static const struct iproc_asiu_gate asiu_gate[] = {
|
||||
[BCM_CYGNUS_ASIU_KEYPAD_CLK] = asiu_gate_val(0x0, 7),
|
||||
[BCM_CYGNUS_ASIU_ADC_CLK] = asiu_gate_val(0x0, 9),
|
||||
[BCM_CYGNUS_ASIU_PWM_CLK] = asiu_gate_val(IPROC_CLK_INVALID_OFFSET, 0),
|
||||
};
|
||||
|
||||
static void __init cygnus_asiu_init(struct device_node *node)
|
||||
{
|
||||
iproc_asiu_setup(node, asiu_div, asiu_gate, ARRAY_SIZE(asiu_div));
|
||||
}
|
||||
CLK_OF_DECLARE(cygnus_asiu_clk, "brcm,cygnus-asiu-clk", cygnus_asiu_init);
|
||||
|
|
@ -0,0 +1,282 @@
|
|||
/*
|
||||
* Copyright (C) 2014 Broadcom Corporation
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation version 2.
|
||||
*
|
||||
* This program is distributed "as is" WITHOUT ANY WARRANTY of any
|
||||
* kind, whether express or implied; without even the implied warranty
|
||||
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/clk-provider.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/clkdev.h>
|
||||
#include <linux/of_address.h>
|
||||
|
||||
#define IPROC_CLK_MAX_FREQ_POLICY 0x3
|
||||
#define IPROC_CLK_POLICY_FREQ_OFFSET 0x008
|
||||
#define IPROC_CLK_POLICY_FREQ_POLICY_FREQ_SHIFT 8
|
||||
#define IPROC_CLK_POLICY_FREQ_POLICY_FREQ_MASK 0x7
|
||||
|
||||
#define IPROC_CLK_PLLARMA_OFFSET 0xc00
|
||||
#define IPROC_CLK_PLLARMA_LOCK_SHIFT 28
|
||||
#define IPROC_CLK_PLLARMA_PDIV_SHIFT 24
|
||||
#define IPROC_CLK_PLLARMA_PDIV_MASK 0xf
|
||||
#define IPROC_CLK_PLLARMA_NDIV_INT_SHIFT 8
|
||||
#define IPROC_CLK_PLLARMA_NDIV_INT_MASK 0x3ff
|
||||
|
||||
#define IPROC_CLK_PLLARMB_OFFSET 0xc04
|
||||
#define IPROC_CLK_PLLARMB_NDIV_FRAC_MASK 0xfffff
|
||||
|
||||
#define IPROC_CLK_PLLARMC_OFFSET 0xc08
|
||||
#define IPROC_CLK_PLLARMC_BYPCLK_EN_SHIFT 8
|
||||
#define IPROC_CLK_PLLARMC_MDIV_MASK 0xff
|
||||
|
||||
#define IPROC_CLK_PLLARMCTL5_OFFSET 0xc20
|
||||
#define IPROC_CLK_PLLARMCTL5_H_MDIV_MASK 0xff
|
||||
|
||||
#define IPROC_CLK_PLLARM_OFFSET_OFFSET 0xc24
|
||||
#define IPROC_CLK_PLLARM_SW_CTL_SHIFT 29
|
||||
#define IPROC_CLK_PLLARM_NDIV_INT_OFFSET_SHIFT 20
|
||||
#define IPROC_CLK_PLLARM_NDIV_INT_OFFSET_MASK 0xff
|
||||
#define IPROC_CLK_PLLARM_NDIV_FRAC_OFFSET_MASK 0xfffff
|
||||
|
||||
#define IPROC_CLK_ARM_DIV_OFFSET 0xe00
|
||||
#define IPROC_CLK_ARM_DIV_PLL_SELECT_OVERRIDE_SHIFT 4
|
||||
#define IPROC_CLK_ARM_DIV_ARM_PLL_SELECT_MASK 0xf
|
||||
|
||||
#define IPROC_CLK_POLICY_DBG_OFFSET 0xec0
|
||||
#define IPROC_CLK_POLICY_DBG_ACT_FREQ_SHIFT 12
|
||||
#define IPROC_CLK_POLICY_DBG_ACT_FREQ_MASK 0x7
|
||||
|
||||
enum iproc_arm_pll_fid {
|
||||
ARM_PLL_FID_CRYSTAL_CLK = 0,
|
||||
ARM_PLL_FID_SYS_CLK = 2,
|
||||
ARM_PLL_FID_CH0_SLOW_CLK = 6,
|
||||
ARM_PLL_FID_CH1_FAST_CLK = 7
|
||||
};
|
||||
|
||||
struct iproc_arm_pll {
|
||||
struct clk_hw hw;
|
||||
void __iomem *base;
|
||||
unsigned long rate;
|
||||
};
|
||||
|
||||
#define to_iproc_arm_pll(hw) container_of(hw, struct iproc_arm_pll, hw)
|
||||
|
||||
static unsigned int __get_fid(struct iproc_arm_pll *pll)
|
||||
{
|
||||
u32 val;
|
||||
unsigned int policy, fid, active_fid;
|
||||
|
||||
val = readl(pll->base + IPROC_CLK_ARM_DIV_OFFSET);
|
||||
if (val & (1 << IPROC_CLK_ARM_DIV_PLL_SELECT_OVERRIDE_SHIFT))
|
||||
policy = val & IPROC_CLK_ARM_DIV_ARM_PLL_SELECT_MASK;
|
||||
else
|
||||
policy = 0;
|
||||
|
||||
/* something is seriously wrong */
|
||||
BUG_ON(policy > IPROC_CLK_MAX_FREQ_POLICY);
|
||||
|
||||
val = readl(pll->base + IPROC_CLK_POLICY_FREQ_OFFSET);
|
||||
fid = (val >> (IPROC_CLK_POLICY_FREQ_POLICY_FREQ_SHIFT * policy)) &
|
||||
IPROC_CLK_POLICY_FREQ_POLICY_FREQ_MASK;
|
||||
|
||||
val = readl(pll->base + IPROC_CLK_POLICY_DBG_OFFSET);
|
||||
active_fid = IPROC_CLK_POLICY_DBG_ACT_FREQ_MASK &
|
||||
(val >> IPROC_CLK_POLICY_DBG_ACT_FREQ_SHIFT);
|
||||
if (fid != active_fid) {
|
||||
pr_debug("%s: fid override %u->%u\n", __func__, fid,
|
||||
active_fid);
|
||||
fid = active_fid;
|
||||
}
|
||||
|
||||
pr_debug("%s: active fid: %u\n", __func__, fid);
|
||||
|
||||
return fid;
|
||||
}
|
||||
|
||||
/*
|
||||
* Determine the mdiv (post divider) based on the frequency ID being used.
|
||||
* There are 4 sources that can be used to derive the output clock rate:
|
||||
* - 25 MHz Crystal
|
||||
* - System clock
|
||||
* - PLL channel 0 (slow clock)
|
||||
* - PLL channel 1 (fast clock)
|
||||
*/
|
||||
static int __get_mdiv(struct iproc_arm_pll *pll)
|
||||
{
|
||||
unsigned int fid;
|
||||
int mdiv;
|
||||
u32 val;
|
||||
|
||||
fid = __get_fid(pll);
|
||||
|
||||
switch (fid) {
|
||||
case ARM_PLL_FID_CRYSTAL_CLK:
|
||||
case ARM_PLL_FID_SYS_CLK:
|
||||
mdiv = 1;
|
||||
break;
|
||||
|
||||
case ARM_PLL_FID_CH0_SLOW_CLK:
|
||||
val = readl(pll->base + IPROC_CLK_PLLARMC_OFFSET);
|
||||
mdiv = val & IPROC_CLK_PLLARMC_MDIV_MASK;
|
||||
if (mdiv == 0)
|
||||
mdiv = 256;
|
||||
break;
|
||||
|
||||
case ARM_PLL_FID_CH1_FAST_CLK:
|
||||
val = readl(pll->base + IPROC_CLK_PLLARMCTL5_OFFSET);
|
||||
mdiv = val & IPROC_CLK_PLLARMCTL5_H_MDIV_MASK;
|
||||
if (mdiv == 0)
|
||||
mdiv = 256;
|
||||
break;
|
||||
|
||||
default:
|
||||
mdiv = -EFAULT;
|
||||
}
|
||||
|
||||
return mdiv;
|
||||
}
|
||||
|
||||
static unsigned int __get_ndiv(struct iproc_arm_pll *pll)
|
||||
{
|
||||
u32 val;
|
||||
unsigned int ndiv_int, ndiv_frac, ndiv;
|
||||
|
||||
val = readl(pll->base + IPROC_CLK_PLLARM_OFFSET_OFFSET);
|
||||
if (val & (1 << IPROC_CLK_PLLARM_SW_CTL_SHIFT)) {
|
||||
/*
|
||||
* offset mode is active. Read the ndiv from the PLLARM OFFSET
|
||||
* register
|
||||
*/
|
||||
ndiv_int = (val >> IPROC_CLK_PLLARM_NDIV_INT_OFFSET_SHIFT) &
|
||||
IPROC_CLK_PLLARM_NDIV_INT_OFFSET_MASK;
|
||||
if (ndiv_int == 0)
|
||||
ndiv_int = 256;
|
||||
|
||||
ndiv_frac = val & IPROC_CLK_PLLARM_NDIV_FRAC_OFFSET_MASK;
|
||||
} else {
|
||||
/* offset mode not active */
|
||||
val = readl(pll->base + IPROC_CLK_PLLARMA_OFFSET);
|
||||
ndiv_int = (val >> IPROC_CLK_PLLARMA_NDIV_INT_SHIFT) &
|
||||
IPROC_CLK_PLLARMA_NDIV_INT_MASK;
|
||||
if (ndiv_int == 0)
|
||||
ndiv_int = 1024;
|
||||
|
||||
val = readl(pll->base + IPROC_CLK_PLLARMB_OFFSET);
|
||||
ndiv_frac = val & IPROC_CLK_PLLARMB_NDIV_FRAC_MASK;
|
||||
}
|
||||
|
||||
ndiv = (ndiv_int << 20) | ndiv_frac;
|
||||
|
||||
return ndiv;
|
||||
}
|
||||
|
||||
/*
|
||||
* The output frequency of the ARM PLL is calculated based on the ARM PLL
|
||||
* divider values:
|
||||
* pdiv = ARM PLL pre-divider
|
||||
* ndiv = ARM PLL multiplier
|
||||
* mdiv = ARM PLL post divider
|
||||
*
|
||||
* The frequency is calculated by:
|
||||
* ((ndiv * parent clock rate) / pdiv) / mdiv
|
||||
*/
|
||||
static unsigned long iproc_arm_pll_recalc_rate(struct clk_hw *hw,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct iproc_arm_pll *pll = to_iproc_arm_pll(hw);
|
||||
u32 val;
|
||||
int mdiv;
|
||||
u64 ndiv;
|
||||
unsigned int pdiv;
|
||||
|
||||
/* in bypass mode, use parent rate */
|
||||
val = readl(pll->base + IPROC_CLK_PLLARMC_OFFSET);
|
||||
if (val & (1 << IPROC_CLK_PLLARMC_BYPCLK_EN_SHIFT)) {
|
||||
pll->rate = parent_rate;
|
||||
return pll->rate;
|
||||
}
|
||||
|
||||
/* PLL needs to be locked */
|
||||
val = readl(pll->base + IPROC_CLK_PLLARMA_OFFSET);
|
||||
if (!(val & (1 << IPROC_CLK_PLLARMA_LOCK_SHIFT))) {
|
||||
pll->rate = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
pdiv = (val >> IPROC_CLK_PLLARMA_PDIV_SHIFT) &
|
||||
IPROC_CLK_PLLARMA_PDIV_MASK;
|
||||
if (pdiv == 0)
|
||||
pdiv = 16;
|
||||
|
||||
ndiv = __get_ndiv(pll);
|
||||
mdiv = __get_mdiv(pll);
|
||||
if (mdiv <= 0) {
|
||||
pll->rate = 0;
|
||||
return 0;
|
||||
}
|
||||
pll->rate = (ndiv * parent_rate) >> 20;
|
||||
pll->rate = (pll->rate / pdiv) / mdiv;
|
||||
|
||||
pr_debug("%s: ARM PLL rate: %lu. parent rate: %lu\n", __func__,
|
||||
pll->rate, parent_rate);
|
||||
pr_debug("%s: ndiv_int: %u, pdiv: %u, mdiv: %d\n", __func__,
|
||||
(unsigned int)(ndiv >> 20), pdiv, mdiv);
|
||||
|
||||
return pll->rate;
|
||||
}
|
||||
|
||||
static const struct clk_ops iproc_arm_pll_ops = {
|
||||
.recalc_rate = iproc_arm_pll_recalc_rate,
|
||||
};
|
||||
|
||||
void __init iproc_armpll_setup(struct device_node *node)
|
||||
{
|
||||
int ret;
|
||||
struct clk *clk;
|
||||
struct iproc_arm_pll *pll;
|
||||
struct clk_init_data init;
|
||||
const char *parent_name;
|
||||
|
||||
pll = kzalloc(sizeof(*pll), GFP_KERNEL);
|
||||
if (WARN_ON(!pll))
|
||||
return;
|
||||
|
||||
pll->base = of_iomap(node, 0);
|
||||
if (WARN_ON(!pll->base))
|
||||
goto err_free_pll;
|
||||
|
||||
init.name = node->name;
|
||||
init.ops = &iproc_arm_pll_ops;
|
||||
init.flags = 0;
|
||||
parent_name = of_clk_get_parent_name(node, 0);
|
||||
init.parent_names = (parent_name ? &parent_name : NULL);
|
||||
init.num_parents = (parent_name ? 1 : 0);
|
||||
pll->hw.init = &init;
|
||||
|
||||
clk = clk_register(NULL, &pll->hw);
|
||||
if (WARN_ON(IS_ERR(clk)))
|
||||
goto err_iounmap;
|
||||
|
||||
ret = of_clk_add_provider(node, of_clk_src_simple_get, clk);
|
||||
if (WARN_ON(ret))
|
||||
goto err_clk_unregister;
|
||||
|
||||
return;
|
||||
|
||||
err_clk_unregister:
|
||||
clk_unregister(clk);
|
||||
err_iounmap:
|
||||
iounmap(pll->base);
|
||||
err_free_pll:
|
||||
kfree(pll);
|
||||
}
|
||||
|
|
@ -0,0 +1,276 @@
|
|||
/*
|
||||
* Copyright (C) 2014 Broadcom Corporation
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation version 2.
|
||||
*
|
||||
* This program is distributed "as is" WITHOUT ANY WARRANTY of any
|
||||
* kind, whether express or implied; without even the implied warranty
|
||||
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/clk-provider.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/clkdev.h>
|
||||
#include <linux/of_address.h>
|
||||
#include <linux/delay.h>
|
||||
|
||||
#include "clk-iproc.h"
|
||||
|
||||
struct iproc_asiu;
|
||||
|
||||
struct iproc_asiu_clk {
|
||||
struct clk_hw hw;
|
||||
const char *name;
|
||||
struct iproc_asiu *asiu;
|
||||
unsigned long rate;
|
||||
struct iproc_asiu_div div;
|
||||
struct iproc_asiu_gate gate;
|
||||
};
|
||||
|
||||
struct iproc_asiu {
|
||||
void __iomem *div_base;
|
||||
void __iomem *gate_base;
|
||||
|
||||
struct clk_onecell_data clk_data;
|
||||
struct iproc_asiu_clk *clks;
|
||||
};
|
||||
|
||||
#define to_asiu_clk(hw) container_of(hw, struct iproc_asiu_clk, hw)
|
||||
|
||||
static int iproc_asiu_clk_enable(struct clk_hw *hw)
|
||||
{
|
||||
struct iproc_asiu_clk *clk = to_asiu_clk(hw);
|
||||
struct iproc_asiu *asiu = clk->asiu;
|
||||
u32 val;
|
||||
|
||||
/* some clocks at the ASIU level are always enabled */
|
||||
if (clk->gate.offset == IPROC_CLK_INVALID_OFFSET)
|
||||
return 0;
|
||||
|
||||
val = readl(asiu->gate_base + clk->gate.offset);
|
||||
val |= (1 << clk->gate.en_shift);
|
||||
writel(val, asiu->gate_base + clk->gate.offset);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void iproc_asiu_clk_disable(struct clk_hw *hw)
|
||||
{
|
||||
struct iproc_asiu_clk *clk = to_asiu_clk(hw);
|
||||
struct iproc_asiu *asiu = clk->asiu;
|
||||
u32 val;
|
||||
|
||||
/* some clocks at the ASIU level are always enabled */
|
||||
if (clk->gate.offset == IPROC_CLK_INVALID_OFFSET)
|
||||
return;
|
||||
|
||||
val = readl(asiu->gate_base + clk->gate.offset);
|
||||
val &= ~(1 << clk->gate.en_shift);
|
||||
writel(val, asiu->gate_base + clk->gate.offset);
|
||||
}
|
||||
|
||||
static unsigned long iproc_asiu_clk_recalc_rate(struct clk_hw *hw,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct iproc_asiu_clk *clk = to_asiu_clk(hw);
|
||||
struct iproc_asiu *asiu = clk->asiu;
|
||||
u32 val;
|
||||
unsigned int div_h, div_l;
|
||||
|
||||
if (parent_rate == 0) {
|
||||
clk->rate = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* if clock divisor is not enabled, simply return parent rate */
|
||||
val = readl(asiu->div_base + clk->div.offset);
|
||||
if ((val & (1 << clk->div.en_shift)) == 0) {
|
||||
clk->rate = parent_rate;
|
||||
return parent_rate;
|
||||
}
|
||||
|
||||
/* clock rate = parent rate / (high_div + 1) + (low_div + 1) */
|
||||
div_h = (val >> clk->div.high_shift) & bit_mask(clk->div.high_width);
|
||||
div_h++;
|
||||
div_l = (val >> clk->div.low_shift) & bit_mask(clk->div.low_width);
|
||||
div_l++;
|
||||
|
||||
clk->rate = parent_rate / (div_h + div_l);
|
||||
pr_debug("%s: rate: %lu. parent rate: %lu div_h: %u div_l: %u\n",
|
||||
__func__, clk->rate, parent_rate, div_h, div_l);
|
||||
|
||||
return clk->rate;
|
||||
}
|
||||
|
||||
static long iproc_asiu_clk_round_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long *parent_rate)
|
||||
{
|
||||
unsigned int div;
|
||||
|
||||
if (rate == 0 || *parent_rate == 0)
|
||||
return -EINVAL;
|
||||
|
||||
if (rate == *parent_rate)
|
||||
return *parent_rate;
|
||||
|
||||
div = DIV_ROUND_UP(*parent_rate, rate);
|
||||
if (div < 2)
|
||||
return *parent_rate;
|
||||
|
||||
return *parent_rate / div;
|
||||
}
|
||||
|
||||
static int iproc_asiu_clk_set_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct iproc_asiu_clk *clk = to_asiu_clk(hw);
|
||||
struct iproc_asiu *asiu = clk->asiu;
|
||||
unsigned int div, div_h, div_l;
|
||||
u32 val;
|
||||
|
||||
if (rate == 0 || parent_rate == 0)
|
||||
return -EINVAL;
|
||||
|
||||
/* simply disable the divisor if one wants the same rate as parent */
|
||||
if (rate == parent_rate) {
|
||||
val = readl(asiu->div_base + clk->div.offset);
|
||||
val &= ~(1 << clk->div.en_shift);
|
||||
writel(val, asiu->div_base + clk->div.offset);
|
||||
return 0;
|
||||
}
|
||||
|
||||
div = DIV_ROUND_UP(parent_rate, rate);
|
||||
if (div < 2)
|
||||
return -EINVAL;
|
||||
|
||||
div_h = div_l = div >> 1;
|
||||
div_h--;
|
||||
div_l--;
|
||||
|
||||
val = readl(asiu->div_base + clk->div.offset);
|
||||
val |= 1 << clk->div.en_shift;
|
||||
if (div_h) {
|
||||
val &= ~(bit_mask(clk->div.high_width)
|
||||
<< clk->div.high_shift);
|
||||
val |= div_h << clk->div.high_shift;
|
||||
} else {
|
||||
val &= ~(bit_mask(clk->div.high_width)
|
||||
<< clk->div.high_shift);
|
||||
}
|
||||
if (div_l) {
|
||||
val &= ~(bit_mask(clk->div.low_width) << clk->div.low_shift);
|
||||
val |= div_l << clk->div.low_shift;
|
||||
} else {
|
||||
val &= ~(bit_mask(clk->div.low_width) << clk->div.low_shift);
|
||||
}
|
||||
writel(val, asiu->div_base + clk->div.offset);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct clk_ops iproc_asiu_ops = {
|
||||
.enable = iproc_asiu_clk_enable,
|
||||
.disable = iproc_asiu_clk_disable,
|
||||
.recalc_rate = iproc_asiu_clk_recalc_rate,
|
||||
.round_rate = iproc_asiu_clk_round_rate,
|
||||
.set_rate = iproc_asiu_clk_set_rate,
|
||||
};
|
||||
|
||||
void __init iproc_asiu_setup(struct device_node *node,
|
||||
const struct iproc_asiu_div *div,
|
||||
const struct iproc_asiu_gate *gate,
|
||||
unsigned int num_clks)
|
||||
{
|
||||
int i, ret;
|
||||
struct iproc_asiu *asiu;
|
||||
|
||||
if (WARN_ON(!gate || !div))
|
||||
return;
|
||||
|
||||
asiu = kzalloc(sizeof(*asiu), GFP_KERNEL);
|
||||
if (WARN_ON(!asiu))
|
||||
return;
|
||||
|
||||
asiu->clk_data.clk_num = num_clks;
|
||||
asiu->clk_data.clks = kcalloc(num_clks, sizeof(*asiu->clk_data.clks),
|
||||
GFP_KERNEL);
|
||||
if (WARN_ON(!asiu->clk_data.clks))
|
||||
goto err_clks;
|
||||
|
||||
asiu->clks = kcalloc(num_clks, sizeof(*asiu->clks), GFP_KERNEL);
|
||||
if (WARN_ON(!asiu->clks))
|
||||
goto err_asiu_clks;
|
||||
|
||||
asiu->div_base = of_iomap(node, 0);
|
||||
if (WARN_ON(!asiu->div_base))
|
||||
goto err_iomap_div;
|
||||
|
||||
asiu->gate_base = of_iomap(node, 1);
|
||||
if (WARN_ON(!asiu->gate_base))
|
||||
goto err_iomap_gate;
|
||||
|
||||
for (i = 0; i < num_clks; i++) {
|
||||
struct clk_init_data init;
|
||||
struct clk *clk;
|
||||
const char *parent_name;
|
||||
struct iproc_asiu_clk *asiu_clk;
|
||||
const char *clk_name;
|
||||
|
||||
clk_name = kzalloc(IPROC_CLK_NAME_LEN, GFP_KERNEL);
|
||||
if (WARN_ON(!clk_name))
|
||||
goto err_clk_register;
|
||||
|
||||
ret = of_property_read_string_index(node, "clock-output-names",
|
||||
i, &clk_name);
|
||||
if (WARN_ON(ret))
|
||||
goto err_clk_register;
|
||||
|
||||
asiu_clk = &asiu->clks[i];
|
||||
asiu_clk->name = clk_name;
|
||||
asiu_clk->asiu = asiu;
|
||||
asiu_clk->div = div[i];
|
||||
asiu_clk->gate = gate[i];
|
||||
init.name = clk_name;
|
||||
init.ops = &iproc_asiu_ops;
|
||||
init.flags = 0;
|
||||
parent_name = of_clk_get_parent_name(node, 0);
|
||||
init.parent_names = (parent_name ? &parent_name : NULL);
|
||||
init.num_parents = (parent_name ? 1 : 0);
|
||||
asiu_clk->hw.init = &init;
|
||||
|
||||
clk = clk_register(NULL, &asiu_clk->hw);
|
||||
if (WARN_ON(IS_ERR(clk)))
|
||||
goto err_clk_register;
|
||||
asiu->clk_data.clks[i] = clk;
|
||||
}
|
||||
|
||||
ret = of_clk_add_provider(node, of_clk_src_onecell_get,
|
||||
&asiu->clk_data);
|
||||
if (WARN_ON(ret))
|
||||
goto err_clk_register;
|
||||
|
||||
return;
|
||||
|
||||
err_clk_register:
|
||||
for (i = 0; i < num_clks; i++)
|
||||
kfree(asiu->clks[i].name);
|
||||
iounmap(asiu->gate_base);
|
||||
|
||||
err_iomap_gate:
|
||||
iounmap(asiu->div_base);
|
||||
|
||||
err_iomap_div:
|
||||
kfree(asiu->clks);
|
||||
|
||||
err_asiu_clks:
|
||||
kfree(asiu->clk_data.clks);
|
||||
|
||||
err_clks:
|
||||
kfree(asiu);
|
||||
}
|
||||
|
|
@ -0,0 +1,716 @@
|
|||
/*
|
||||
* Copyright (C) 2014 Broadcom Corporation
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation version 2.
|
||||
*
|
||||
* This program is distributed "as is" WITHOUT ANY WARRANTY of any
|
||||
* kind, whether express or implied; without even the implied warranty
|
||||
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/clk-provider.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/clkdev.h>
|
||||
#include <linux/of_address.h>
|
||||
#include <linux/delay.h>
|
||||
|
||||
#include "clk-iproc.h"
|
||||
|
||||
#define PLL_VCO_HIGH_SHIFT 19
|
||||
#define PLL_VCO_LOW_SHIFT 30
|
||||
|
||||
/* number of delay loops waiting for PLL to lock */
|
||||
#define LOCK_DELAY 100
|
||||
|
||||
/* number of VCO frequency bands */
|
||||
#define NUM_FREQ_BANDS 8
|
||||
|
||||
#define NUM_KP_BANDS 3
|
||||
enum kp_band {
|
||||
KP_BAND_MID = 0,
|
||||
KP_BAND_HIGH,
|
||||
KP_BAND_HIGH_HIGH
|
||||
};
|
||||
|
||||
static const unsigned int kp_table[NUM_KP_BANDS][NUM_FREQ_BANDS] = {
|
||||
{ 5, 6, 6, 7, 7, 8, 9, 10 },
|
||||
{ 4, 4, 5, 5, 6, 7, 8, 9 },
|
||||
{ 4, 5, 5, 6, 7, 8, 9, 10 },
|
||||
};
|
||||
|
||||
static const unsigned long ref_freq_table[NUM_FREQ_BANDS][2] = {
|
||||
{ 10000000, 12500000 },
|
||||
{ 12500000, 15000000 },
|
||||
{ 15000000, 20000000 },
|
||||
{ 20000000, 25000000 },
|
||||
{ 25000000, 50000000 },
|
||||
{ 50000000, 75000000 },
|
||||
{ 75000000, 100000000 },
|
||||
{ 100000000, 125000000 },
|
||||
};
|
||||
|
||||
enum vco_freq_range {
|
||||
VCO_LOW = 700000000U,
|
||||
VCO_MID = 1200000000U,
|
||||
VCO_HIGH = 2200000000U,
|
||||
VCO_HIGH_HIGH = 3100000000U,
|
||||
VCO_MAX = 4000000000U,
|
||||
};
|
||||
|
||||
struct iproc_pll;
|
||||
|
||||
struct iproc_clk {
|
||||
struct clk_hw hw;
|
||||
const char *name;
|
||||
struct iproc_pll *pll;
|
||||
unsigned long rate;
|
||||
const struct iproc_clk_ctrl *ctrl;
|
||||
};
|
||||
|
||||
struct iproc_pll {
|
||||
void __iomem *pll_base;
|
||||
void __iomem *pwr_base;
|
||||
void __iomem *asiu_base;
|
||||
|
||||
const struct iproc_pll_ctrl *ctrl;
|
||||
const struct iproc_pll_vco_param *vco_param;
|
||||
unsigned int num_vco_entries;
|
||||
|
||||
struct clk_onecell_data clk_data;
|
||||
struct iproc_clk *clks;
|
||||
};
|
||||
|
||||
#define to_iproc_clk(hw) container_of(hw, struct iproc_clk, hw)
|
||||
|
||||
/*
|
||||
* Based on the target frequency, find a match from the VCO frequency parameter
|
||||
* table and return its index
|
||||
*/
|
||||
static int pll_get_rate_index(struct iproc_pll *pll, unsigned int target_rate)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < pll->num_vco_entries; i++)
|
||||
if (target_rate == pll->vco_param[i].rate)
|
||||
break;
|
||||
|
||||
if (i >= pll->num_vco_entries)
|
||||
return -EINVAL;
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
static int get_kp(unsigned long ref_freq, enum kp_band kp_index)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (ref_freq < ref_freq_table[0][0])
|
||||
return -EINVAL;
|
||||
|
||||
for (i = 0; i < NUM_FREQ_BANDS; i++) {
|
||||
if (ref_freq >= ref_freq_table[i][0] &&
|
||||
ref_freq < ref_freq_table[i][1])
|
||||
return kp_table[kp_index][i];
|
||||
}
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static int pll_wait_for_lock(struct iproc_pll *pll)
|
||||
{
|
||||
int i;
|
||||
const struct iproc_pll_ctrl *ctrl = pll->ctrl;
|
||||
|
||||
for (i = 0; i < LOCK_DELAY; i++) {
|
||||
u32 val = readl(pll->pll_base + ctrl->status.offset);
|
||||
|
||||
if (val & (1 << ctrl->status.shift))
|
||||
return 0;
|
||||
udelay(10);
|
||||
}
|
||||
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
static void __pll_disable(struct iproc_pll *pll)
|
||||
{
|
||||
const struct iproc_pll_ctrl *ctrl = pll->ctrl;
|
||||
u32 val;
|
||||
|
||||
if (ctrl->flags & IPROC_CLK_PLL_ASIU) {
|
||||
val = readl(pll->asiu_base + ctrl->asiu.offset);
|
||||
val &= ~(1 << ctrl->asiu.en_shift);
|
||||
writel(val, pll->asiu_base + ctrl->asiu.offset);
|
||||
}
|
||||
|
||||
/* latch input value so core power can be shut down */
|
||||
val = readl(pll->pwr_base + ctrl->aon.offset);
|
||||
val |= (1 << ctrl->aon.iso_shift);
|
||||
writel(val, pll->pwr_base + ctrl->aon.offset);
|
||||
|
||||
/* power down the core */
|
||||
val &= ~(bit_mask(ctrl->aon.pwr_width) << ctrl->aon.pwr_shift);
|
||||
writel(val, pll->pwr_base + ctrl->aon.offset);
|
||||
}
|
||||
|
||||
static int __pll_enable(struct iproc_pll *pll)
|
||||
{
|
||||
const struct iproc_pll_ctrl *ctrl = pll->ctrl;
|
||||
u32 val;
|
||||
|
||||
/* power up the PLL and make sure it's not latched */
|
||||
val = readl(pll->pwr_base + ctrl->aon.offset);
|
||||
val |= bit_mask(ctrl->aon.pwr_width) << ctrl->aon.pwr_shift;
|
||||
val &= ~(1 << ctrl->aon.iso_shift);
|
||||
writel(val, pll->pwr_base + ctrl->aon.offset);
|
||||
|
||||
/* certain PLLs also need to be ungated from the ASIU top level */
|
||||
if (ctrl->flags & IPROC_CLK_PLL_ASIU) {
|
||||
val = readl(pll->asiu_base + ctrl->asiu.offset);
|
||||
val |= (1 << ctrl->asiu.en_shift);
|
||||
writel(val, pll->asiu_base + ctrl->asiu.offset);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __pll_put_in_reset(struct iproc_pll *pll)
|
||||
{
|
||||
u32 val;
|
||||
const struct iproc_pll_ctrl *ctrl = pll->ctrl;
|
||||
const struct iproc_pll_reset_ctrl *reset = &ctrl->reset;
|
||||
|
||||
val = readl(pll->pll_base + reset->offset);
|
||||
val &= ~(1 << reset->reset_shift | 1 << reset->p_reset_shift);
|
||||
writel(val, pll->pll_base + reset->offset);
|
||||
if (unlikely(ctrl->flags & IPROC_CLK_NEEDS_READ_BACK))
|
||||
readl(pll->pll_base + reset->offset);
|
||||
}
|
||||
|
||||
static void __pll_bring_out_reset(struct iproc_pll *pll, unsigned int kp,
|
||||
unsigned int ka, unsigned int ki)
|
||||
{
|
||||
u32 val;
|
||||
const struct iproc_pll_ctrl *ctrl = pll->ctrl;
|
||||
const struct iproc_pll_reset_ctrl *reset = &ctrl->reset;
|
||||
|
||||
val = readl(pll->pll_base + reset->offset);
|
||||
val &= ~(bit_mask(reset->ki_width) << reset->ki_shift |
|
||||
bit_mask(reset->kp_width) << reset->kp_shift |
|
||||
bit_mask(reset->ka_width) << reset->ka_shift);
|
||||
val |= ki << reset->ki_shift | kp << reset->kp_shift |
|
||||
ka << reset->ka_shift;
|
||||
val |= 1 << reset->reset_shift | 1 << reset->p_reset_shift;
|
||||
writel(val, pll->pll_base + reset->offset);
|
||||
if (unlikely(ctrl->flags & IPROC_CLK_NEEDS_READ_BACK))
|
||||
readl(pll->pll_base + reset->offset);
|
||||
}
|
||||
|
||||
static int pll_set_rate(struct iproc_clk *clk, unsigned int rate_index,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct iproc_pll *pll = clk->pll;
|
||||
const struct iproc_pll_vco_param *vco = &pll->vco_param[rate_index];
|
||||
const struct iproc_pll_ctrl *ctrl = pll->ctrl;
|
||||
int ka = 0, ki, kp, ret;
|
||||
unsigned long rate = vco->rate;
|
||||
u32 val;
|
||||
enum kp_band kp_index;
|
||||
unsigned long ref_freq;
|
||||
|
||||
/*
|
||||
* reference frequency = parent frequency / PDIV
|
||||
* If PDIV = 0, then it becomes a multiplier (x2)
|
||||
*/
|
||||
if (vco->pdiv == 0)
|
||||
ref_freq = parent_rate * 2;
|
||||
else
|
||||
ref_freq = parent_rate / vco->pdiv;
|
||||
|
||||
/* determine Ki and Kp index based on target VCO frequency */
|
||||
if (rate >= VCO_LOW && rate < VCO_HIGH) {
|
||||
ki = 4;
|
||||
kp_index = KP_BAND_MID;
|
||||
} else if (rate >= VCO_HIGH && rate && rate < VCO_HIGH_HIGH) {
|
||||
ki = 3;
|
||||
kp_index = KP_BAND_HIGH;
|
||||
} else if (rate >= VCO_HIGH_HIGH && rate < VCO_MAX) {
|
||||
ki = 3;
|
||||
kp_index = KP_BAND_HIGH_HIGH;
|
||||
} else {
|
||||
pr_err("%s: pll: %s has invalid rate: %lu\n", __func__,
|
||||
clk->name, rate);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
kp = get_kp(ref_freq, kp_index);
|
||||
if (kp < 0) {
|
||||
pr_err("%s: pll: %s has invalid kp\n", __func__, clk->name);
|
||||
return kp;
|
||||
}
|
||||
|
||||
ret = __pll_enable(pll);
|
||||
if (ret) {
|
||||
pr_err("%s: pll: %s fails to enable\n", __func__, clk->name);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* put PLL in reset */
|
||||
__pll_put_in_reset(pll);
|
||||
|
||||
writel(0, pll->pll_base + ctrl->vco_ctrl.u_offset);
|
||||
if (unlikely(ctrl->flags & IPROC_CLK_NEEDS_READ_BACK))
|
||||
readl(pll->pll_base + ctrl->vco_ctrl.u_offset);
|
||||
val = readl(pll->pll_base + ctrl->vco_ctrl.l_offset);
|
||||
|
||||
if (rate >= VCO_LOW && rate < VCO_MID)
|
||||
val |= (1 << PLL_VCO_LOW_SHIFT);
|
||||
|
||||
if (rate < VCO_HIGH)
|
||||
val &= ~(1 << PLL_VCO_HIGH_SHIFT);
|
||||
else
|
||||
val |= (1 << PLL_VCO_HIGH_SHIFT);
|
||||
|
||||
writel(val, pll->pll_base + ctrl->vco_ctrl.l_offset);
|
||||
if (unlikely(ctrl->flags & IPROC_CLK_NEEDS_READ_BACK))
|
||||
readl(pll->pll_base + ctrl->vco_ctrl.l_offset);
|
||||
|
||||
/* program integer part of NDIV */
|
||||
val = readl(pll->pll_base + ctrl->ndiv_int.offset);
|
||||
val &= ~(bit_mask(ctrl->ndiv_int.width) << ctrl->ndiv_int.shift);
|
||||
val |= vco->ndiv_int << ctrl->ndiv_int.shift;
|
||||
writel(val, pll->pll_base + ctrl->ndiv_int.offset);
|
||||
if (unlikely(ctrl->flags & IPROC_CLK_NEEDS_READ_BACK))
|
||||
readl(pll->pll_base + ctrl->ndiv_int.offset);
|
||||
|
||||
/* program fractional part of NDIV */
|
||||
if (ctrl->flags & IPROC_CLK_PLL_HAS_NDIV_FRAC) {
|
||||
val = readl(pll->pll_base + ctrl->ndiv_frac.offset);
|
||||
val &= ~(bit_mask(ctrl->ndiv_frac.width) <<
|
||||
ctrl->ndiv_frac.shift);
|
||||
val |= vco->ndiv_frac << ctrl->ndiv_frac.shift;
|
||||
writel(val, pll->pll_base + ctrl->ndiv_frac.offset);
|
||||
if (unlikely(ctrl->flags & IPROC_CLK_NEEDS_READ_BACK))
|
||||
readl(pll->pll_base + ctrl->ndiv_frac.offset);
|
||||
}
|
||||
|
||||
/* program PDIV */
|
||||
val = readl(pll->pll_base + ctrl->pdiv.offset);
|
||||
val &= ~(bit_mask(ctrl->pdiv.width) << ctrl->pdiv.shift);
|
||||
val |= vco->pdiv << ctrl->pdiv.shift;
|
||||
writel(val, pll->pll_base + ctrl->pdiv.offset);
|
||||
if (unlikely(ctrl->flags & IPROC_CLK_NEEDS_READ_BACK))
|
||||
readl(pll->pll_base + ctrl->pdiv.offset);
|
||||
|
||||
__pll_bring_out_reset(pll, kp, ka, ki);
|
||||
|
||||
ret = pll_wait_for_lock(pll);
|
||||
if (ret < 0) {
|
||||
pr_err("%s: pll: %s failed to lock\n", __func__, clk->name);
|
||||
return ret;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int iproc_pll_enable(struct clk_hw *hw)
|
||||
{
|
||||
struct iproc_clk *clk = to_iproc_clk(hw);
|
||||
struct iproc_pll *pll = clk->pll;
|
||||
|
||||
return __pll_enable(pll);
|
||||
}
|
||||
|
||||
static void iproc_pll_disable(struct clk_hw *hw)
|
||||
{
|
||||
struct iproc_clk *clk = to_iproc_clk(hw);
|
||||
struct iproc_pll *pll = clk->pll;
|
||||
const struct iproc_pll_ctrl *ctrl = pll->ctrl;
|
||||
|
||||
if (ctrl->flags & IPROC_CLK_AON)
|
||||
return;
|
||||
|
||||
__pll_disable(pll);
|
||||
}
|
||||
|
||||
static unsigned long iproc_pll_recalc_rate(struct clk_hw *hw,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct iproc_clk *clk = to_iproc_clk(hw);
|
||||
struct iproc_pll *pll = clk->pll;
|
||||
const struct iproc_pll_ctrl *ctrl = pll->ctrl;
|
||||
u32 val;
|
||||
u64 ndiv;
|
||||
unsigned int ndiv_int, ndiv_frac, pdiv;
|
||||
|
||||
if (parent_rate == 0)
|
||||
return 0;
|
||||
|
||||
/* PLL needs to be locked */
|
||||
val = readl(pll->pll_base + ctrl->status.offset);
|
||||
if ((val & (1 << ctrl->status.shift)) == 0) {
|
||||
clk->rate = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* PLL output frequency =
|
||||
*
|
||||
* ((ndiv_int + ndiv_frac / 2^20) * (parent clock rate / pdiv)
|
||||
*/
|
||||
val = readl(pll->pll_base + ctrl->ndiv_int.offset);
|
||||
ndiv_int = (val >> ctrl->ndiv_int.shift) &
|
||||
bit_mask(ctrl->ndiv_int.width);
|
||||
ndiv = ndiv_int << ctrl->ndiv_int.shift;
|
||||
|
||||
if (ctrl->flags & IPROC_CLK_PLL_HAS_NDIV_FRAC) {
|
||||
val = readl(pll->pll_base + ctrl->ndiv_frac.offset);
|
||||
ndiv_frac = (val >> ctrl->ndiv_frac.shift) &
|
||||
bit_mask(ctrl->ndiv_frac.width);
|
||||
|
||||
if (ndiv_frac != 0)
|
||||
ndiv = (ndiv_int << ctrl->ndiv_int.shift) | ndiv_frac;
|
||||
}
|
||||
|
||||
val = readl(pll->pll_base + ctrl->pdiv.offset);
|
||||
pdiv = (val >> ctrl->pdiv.shift) & bit_mask(ctrl->pdiv.width);
|
||||
|
||||
clk->rate = (ndiv * parent_rate) >> ctrl->ndiv_int.shift;
|
||||
|
||||
if (pdiv == 0)
|
||||
clk->rate *= 2;
|
||||
else
|
||||
clk->rate /= pdiv;
|
||||
|
||||
return clk->rate;
|
||||
}
|
||||
|
||||
static long iproc_pll_round_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long *parent_rate)
|
||||
{
|
||||
unsigned i;
|
||||
struct iproc_clk *clk = to_iproc_clk(hw);
|
||||
struct iproc_pll *pll = clk->pll;
|
||||
|
||||
if (rate == 0 || *parent_rate == 0 || !pll->vco_param)
|
||||
return -EINVAL;
|
||||
|
||||
for (i = 0; i < pll->num_vco_entries; i++) {
|
||||
if (rate <= pll->vco_param[i].rate)
|
||||
break;
|
||||
}
|
||||
|
||||
if (i == pll->num_vco_entries)
|
||||
i--;
|
||||
|
||||
return pll->vco_param[i].rate;
|
||||
}
|
||||
|
||||
static int iproc_pll_set_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct iproc_clk *clk = to_iproc_clk(hw);
|
||||
struct iproc_pll *pll = clk->pll;
|
||||
int rate_index, ret;
|
||||
|
||||
rate_index = pll_get_rate_index(pll, rate);
|
||||
if (rate_index < 0)
|
||||
return rate_index;
|
||||
|
||||
ret = pll_set_rate(clk, rate_index, parent_rate);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static const struct clk_ops iproc_pll_ops = {
|
||||
.enable = iproc_pll_enable,
|
||||
.disable = iproc_pll_disable,
|
||||
.recalc_rate = iproc_pll_recalc_rate,
|
||||
.round_rate = iproc_pll_round_rate,
|
||||
.set_rate = iproc_pll_set_rate,
|
||||
};
|
||||
|
||||
static int iproc_clk_enable(struct clk_hw *hw)
|
||||
{
|
||||
struct iproc_clk *clk = to_iproc_clk(hw);
|
||||
const struct iproc_clk_ctrl *ctrl = clk->ctrl;
|
||||
struct iproc_pll *pll = clk->pll;
|
||||
u32 val;
|
||||
|
||||
/* channel enable is active low */
|
||||
val = readl(pll->pll_base + ctrl->enable.offset);
|
||||
val &= ~(1 << ctrl->enable.enable_shift);
|
||||
writel(val, pll->pll_base + ctrl->enable.offset);
|
||||
|
||||
/* also make sure channel is not held */
|
||||
val = readl(pll->pll_base + ctrl->enable.offset);
|
||||
val &= ~(1 << ctrl->enable.hold_shift);
|
||||
writel(val, pll->pll_base + ctrl->enable.offset);
|
||||
if (unlikely(ctrl->flags & IPROC_CLK_NEEDS_READ_BACK))
|
||||
readl(pll->pll_base + ctrl->enable.offset);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void iproc_clk_disable(struct clk_hw *hw)
|
||||
{
|
||||
struct iproc_clk *clk = to_iproc_clk(hw);
|
||||
const struct iproc_clk_ctrl *ctrl = clk->ctrl;
|
||||
struct iproc_pll *pll = clk->pll;
|
||||
u32 val;
|
||||
|
||||
if (ctrl->flags & IPROC_CLK_AON)
|
||||
return;
|
||||
|
||||
val = readl(pll->pll_base + ctrl->enable.offset);
|
||||
val |= 1 << ctrl->enable.enable_shift;
|
||||
writel(val, pll->pll_base + ctrl->enable.offset);
|
||||
if (unlikely(ctrl->flags & IPROC_CLK_NEEDS_READ_BACK))
|
||||
readl(pll->pll_base + ctrl->enable.offset);
|
||||
}
|
||||
|
||||
static unsigned long iproc_clk_recalc_rate(struct clk_hw *hw,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct iproc_clk *clk = to_iproc_clk(hw);
|
||||
const struct iproc_clk_ctrl *ctrl = clk->ctrl;
|
||||
struct iproc_pll *pll = clk->pll;
|
||||
u32 val;
|
||||
unsigned int mdiv;
|
||||
|
||||
if (parent_rate == 0)
|
||||
return 0;
|
||||
|
||||
val = readl(pll->pll_base + ctrl->mdiv.offset);
|
||||
mdiv = (val >> ctrl->mdiv.shift) & bit_mask(ctrl->mdiv.width);
|
||||
if (mdiv == 0)
|
||||
mdiv = 256;
|
||||
|
||||
clk->rate = parent_rate / mdiv;
|
||||
|
||||
return clk->rate;
|
||||
}
|
||||
|
||||
static long iproc_clk_round_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long *parent_rate)
|
||||
{
|
||||
unsigned int div;
|
||||
|
||||
if (rate == 0 || *parent_rate == 0)
|
||||
return -EINVAL;
|
||||
|
||||
if (rate == *parent_rate)
|
||||
return *parent_rate;
|
||||
|
||||
div = DIV_ROUND_UP(*parent_rate, rate);
|
||||
if (div < 2)
|
||||
return *parent_rate;
|
||||
|
||||
if (div > 256)
|
||||
div = 256;
|
||||
|
||||
return *parent_rate / div;
|
||||
}
|
||||
|
||||
static int iproc_clk_set_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct iproc_clk *clk = to_iproc_clk(hw);
|
||||
const struct iproc_clk_ctrl *ctrl = clk->ctrl;
|
||||
struct iproc_pll *pll = clk->pll;
|
||||
u32 val;
|
||||
unsigned int div;
|
||||
|
||||
if (rate == 0 || parent_rate == 0)
|
||||
return -EINVAL;
|
||||
|
||||
div = DIV_ROUND_UP(parent_rate, rate);
|
||||
if (div > 256)
|
||||
return -EINVAL;
|
||||
|
||||
val = readl(pll->pll_base + ctrl->mdiv.offset);
|
||||
if (div == 256) {
|
||||
val &= ~(bit_mask(ctrl->mdiv.width) << ctrl->mdiv.shift);
|
||||
} else {
|
||||
val &= ~(bit_mask(ctrl->mdiv.width) << ctrl->mdiv.shift);
|
||||
val |= div << ctrl->mdiv.shift;
|
||||
}
|
||||
writel(val, pll->pll_base + ctrl->mdiv.offset);
|
||||
if (unlikely(ctrl->flags & IPROC_CLK_NEEDS_READ_BACK))
|
||||
readl(pll->pll_base + ctrl->mdiv.offset);
|
||||
clk->rate = parent_rate / div;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct clk_ops iproc_clk_ops = {
|
||||
.enable = iproc_clk_enable,
|
||||
.disable = iproc_clk_disable,
|
||||
.recalc_rate = iproc_clk_recalc_rate,
|
||||
.round_rate = iproc_clk_round_rate,
|
||||
.set_rate = iproc_clk_set_rate,
|
||||
};
|
||||
|
||||
/**
|
||||
* Some PLLs require the PLL SW override bit to be set before changes can be
|
||||
* applied to the PLL
|
||||
*/
|
||||
static void iproc_pll_sw_cfg(struct iproc_pll *pll)
|
||||
{
|
||||
const struct iproc_pll_ctrl *ctrl = pll->ctrl;
|
||||
|
||||
if (ctrl->flags & IPROC_CLK_PLL_NEEDS_SW_CFG) {
|
||||
u32 val;
|
||||
|
||||
val = readl(pll->pll_base + ctrl->sw_ctrl.offset);
|
||||
val |= BIT(ctrl->sw_ctrl.shift);
|
||||
writel(val, pll->pll_base + ctrl->sw_ctrl.offset);
|
||||
if (unlikely(ctrl->flags & IPROC_CLK_NEEDS_READ_BACK))
|
||||
readl(pll->pll_base + ctrl->sw_ctrl.offset);
|
||||
}
|
||||
}
|
||||
|
||||
void __init iproc_pll_clk_setup(struct device_node *node,
|
||||
const struct iproc_pll_ctrl *pll_ctrl,
|
||||
const struct iproc_pll_vco_param *vco,
|
||||
unsigned int num_vco_entries,
|
||||
const struct iproc_clk_ctrl *clk_ctrl,
|
||||
unsigned int num_clks)
|
||||
{
|
||||
int i, ret;
|
||||
struct clk *clk;
|
||||
struct iproc_pll *pll;
|
||||
struct iproc_clk *iclk;
|
||||
struct clk_init_data init;
|
||||
const char *parent_name;
|
||||
|
||||
if (WARN_ON(!pll_ctrl) || WARN_ON(!clk_ctrl))
|
||||
return;
|
||||
|
||||
pll = kzalloc(sizeof(*pll), GFP_KERNEL);
|
||||
if (WARN_ON(!pll))
|
||||
return;
|
||||
|
||||
pll->clk_data.clk_num = num_clks;
|
||||
pll->clk_data.clks = kcalloc(num_clks, sizeof(*pll->clk_data.clks),
|
||||
GFP_KERNEL);
|
||||
if (WARN_ON(!pll->clk_data.clks))
|
||||
goto err_clk_data;
|
||||
|
||||
pll->clks = kcalloc(num_clks, sizeof(*pll->clks), GFP_KERNEL);
|
||||
if (WARN_ON(!pll->clks))
|
||||
goto err_clks;
|
||||
|
||||
pll->pll_base = of_iomap(node, 0);
|
||||
if (WARN_ON(!pll->pll_base))
|
||||
goto err_pll_iomap;
|
||||
|
||||
pll->pwr_base = of_iomap(node, 1);
|
||||
if (WARN_ON(!pll->pwr_base))
|
||||
goto err_pwr_iomap;
|
||||
|
||||
/* some PLLs require gating control at the top ASIU level */
|
||||
if (pll_ctrl->flags & IPROC_CLK_PLL_ASIU) {
|
||||
pll->asiu_base = of_iomap(node, 2);
|
||||
if (WARN_ON(!pll->asiu_base))
|
||||
goto err_asiu_iomap;
|
||||
}
|
||||
|
||||
/* initialize and register the PLL itself */
|
||||
pll->ctrl = pll_ctrl;
|
||||
|
||||
iclk = &pll->clks[0];
|
||||
iclk->pll = pll;
|
||||
iclk->name = node->name;
|
||||
|
||||
init.name = node->name;
|
||||
init.ops = &iproc_pll_ops;
|
||||
init.flags = 0;
|
||||
parent_name = of_clk_get_parent_name(node, 0);
|
||||
init.parent_names = (parent_name ? &parent_name : NULL);
|
||||
init.num_parents = (parent_name ? 1 : 0);
|
||||
iclk->hw.init = &init;
|
||||
|
||||
if (vco) {
|
||||
pll->num_vco_entries = num_vco_entries;
|
||||
pll->vco_param = vco;
|
||||
}
|
||||
|
||||
iproc_pll_sw_cfg(pll);
|
||||
|
||||
clk = clk_register(NULL, &iclk->hw);
|
||||
if (WARN_ON(IS_ERR(clk)))
|
||||
goto err_pll_register;
|
||||
|
||||
pll->clk_data.clks[0] = clk;
|
||||
|
||||
/* now initialize and register all leaf clocks */
|
||||
for (i = 1; i < num_clks; i++) {
|
||||
const char *clk_name;
|
||||
|
||||
memset(&init, 0, sizeof(init));
|
||||
parent_name = node->name;
|
||||
|
||||
clk_name = kzalloc(IPROC_CLK_NAME_LEN, GFP_KERNEL);
|
||||
if (WARN_ON(!clk_name))
|
||||
goto err_clk_register;
|
||||
|
||||
ret = of_property_read_string_index(node, "clock-output-names",
|
||||
i, &clk_name);
|
||||
if (WARN_ON(ret))
|
||||
goto err_clk_register;
|
||||
|
||||
iclk = &pll->clks[i];
|
||||
iclk->name = clk_name;
|
||||
iclk->pll = pll;
|
||||
iclk->ctrl = &clk_ctrl[i];
|
||||
|
||||
init.name = clk_name;
|
||||
init.ops = &iproc_clk_ops;
|
||||
init.flags = 0;
|
||||
init.parent_names = (parent_name ? &parent_name : NULL);
|
||||
init.num_parents = (parent_name ? 1 : 0);
|
||||
iclk->hw.init = &init;
|
||||
|
||||
clk = clk_register(NULL, &iclk->hw);
|
||||
if (WARN_ON(IS_ERR(clk)))
|
||||
goto err_clk_register;
|
||||
|
||||
pll->clk_data.clks[i] = clk;
|
||||
}
|
||||
|
||||
ret = of_clk_add_provider(node, of_clk_src_onecell_get, &pll->clk_data);
|
||||
if (WARN_ON(ret))
|
||||
goto err_clk_register;
|
||||
|
||||
return;
|
||||
|
||||
err_clk_register:
|
||||
for (i = 0; i < num_clks; i++) {
|
||||
kfree(pll->clks[i].name);
|
||||
clk_unregister(pll->clk_data.clks[i]);
|
||||
}
|
||||
|
||||
err_pll_register:
|
||||
if (pll->asiu_base)
|
||||
iounmap(pll->asiu_base);
|
||||
|
||||
err_asiu_iomap:
|
||||
iounmap(pll->pwr_base);
|
||||
|
||||
err_pwr_iomap:
|
||||
iounmap(pll->pll_base);
|
||||
|
||||
err_pll_iomap:
|
||||
kfree(pll->clks);
|
||||
|
||||
err_clks:
|
||||
kfree(pll->clk_data.clks);
|
||||
|
||||
err_clk_data:
|
||||
kfree(pll);
|
||||
}
|
||||
|
|
@ -0,0 +1,178 @@
|
|||
/*
|
||||
* Copyright (C) 2014 Broadcom Corporation
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License as
|
||||
* published by the Free Software Foundation version 2.
|
||||
*
|
||||
* This program is distributed "as is" WITHOUT ANY WARRANTY of any
|
||||
* kind, whether express or implied; without even the implied warranty
|
||||
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#ifndef _CLK_IPROC_H
|
||||
#define _CLK_IPROC_H
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/clk-provider.h>
|
||||
|
||||
#define IPROC_CLK_NAME_LEN 25
|
||||
#define IPROC_CLK_INVALID_OFFSET 0xffffffff
|
||||
#define bit_mask(width) ((1 << (width)) - 1)
|
||||
|
||||
/* clocks that should not be disabled at runtime */
|
||||
#define IPROC_CLK_AON BIT(0)
|
||||
|
||||
/* PLL that requires gating through ASIU */
|
||||
#define IPROC_CLK_PLL_ASIU BIT(1)
|
||||
|
||||
/* PLL that has fractional part of the NDIV */
|
||||
#define IPROC_CLK_PLL_HAS_NDIV_FRAC BIT(2)
|
||||
|
||||
/*
|
||||
* Some of the iProc PLL/clocks may have an ASIC bug that requires read back
|
||||
* of the same register following the write to flush the write transaction into
|
||||
* the intended register
|
||||
*/
|
||||
#define IPROC_CLK_NEEDS_READ_BACK BIT(3)
|
||||
|
||||
/*
|
||||
* Some PLLs require the PLL SW override bit to be set before changes can be
|
||||
* applied to the PLL
|
||||
*/
|
||||
#define IPROC_CLK_PLL_NEEDS_SW_CFG BIT(4)
|
||||
|
||||
/*
|
||||
* Parameters for VCO frequency configuration
|
||||
*
|
||||
* VCO frequency =
|
||||
* ((ndiv_int + ndiv_frac / 2^20) * (ref freqeuncy / pdiv)
|
||||
*/
|
||||
struct iproc_pll_vco_param {
|
||||
unsigned long rate;
|
||||
unsigned int ndiv_int;
|
||||
unsigned int ndiv_frac;
|
||||
unsigned int pdiv;
|
||||
};
|
||||
|
||||
struct iproc_clk_reg_op {
|
||||
unsigned int offset;
|
||||
unsigned int shift;
|
||||
unsigned int width;
|
||||
};
|
||||
|
||||
/*
|
||||
* Clock gating control at the top ASIU level
|
||||
*/
|
||||
struct iproc_asiu_gate {
|
||||
unsigned int offset;
|
||||
unsigned int en_shift;
|
||||
};
|
||||
|
||||
/*
|
||||
* Control of powering on/off of a PLL
|
||||
*
|
||||
* Before powering off a PLL, input isolation (ISO) needs to be enabled
|
||||
*/
|
||||
struct iproc_pll_aon_pwr_ctrl {
|
||||
unsigned int offset;
|
||||
unsigned int pwr_width;
|
||||
unsigned int pwr_shift;
|
||||
unsigned int iso_shift;
|
||||
};
|
||||
|
||||
/*
|
||||
* Control of the PLL reset, with Ki, Kp, and Ka parameters
|
||||
*/
|
||||
struct iproc_pll_reset_ctrl {
|
||||
unsigned int offset;
|
||||
unsigned int reset_shift;
|
||||
unsigned int p_reset_shift;
|
||||
unsigned int ki_shift;
|
||||
unsigned int ki_width;
|
||||
unsigned int kp_shift;
|
||||
unsigned int kp_width;
|
||||
unsigned int ka_shift;
|
||||
unsigned int ka_width;
|
||||
};
|
||||
|
||||
/*
|
||||
* To enable SW control of the PLL
|
||||
*/
|
||||
struct iproc_pll_sw_ctrl {
|
||||
unsigned int offset;
|
||||
unsigned int shift;
|
||||
};
|
||||
|
||||
struct iproc_pll_vco_ctrl {
|
||||
unsigned int u_offset;
|
||||
unsigned int l_offset;
|
||||
};
|
||||
|
||||
/*
|
||||
* Main PLL control parameters
|
||||
*/
|
||||
struct iproc_pll_ctrl {
|
||||
unsigned long flags;
|
||||
struct iproc_pll_aon_pwr_ctrl aon;
|
||||
struct iproc_asiu_gate asiu;
|
||||
struct iproc_pll_reset_ctrl reset;
|
||||
struct iproc_pll_sw_ctrl sw_ctrl;
|
||||
struct iproc_clk_reg_op ndiv_int;
|
||||
struct iproc_clk_reg_op ndiv_frac;
|
||||
struct iproc_clk_reg_op pdiv;
|
||||
struct iproc_pll_vco_ctrl vco_ctrl;
|
||||
struct iproc_clk_reg_op status;
|
||||
};
|
||||
|
||||
/*
|
||||
* Controls enabling/disabling a PLL derived clock
|
||||
*/
|
||||
struct iproc_clk_enable_ctrl {
|
||||
unsigned int offset;
|
||||
unsigned int enable_shift;
|
||||
unsigned int hold_shift;
|
||||
unsigned int bypass_shift;
|
||||
};
|
||||
|
||||
/*
|
||||
* Main clock control parameters for clocks derived from the PLLs
|
||||
*/
|
||||
struct iproc_clk_ctrl {
|
||||
unsigned int channel;
|
||||
unsigned long flags;
|
||||
struct iproc_clk_enable_ctrl enable;
|
||||
struct iproc_clk_reg_op mdiv;
|
||||
};
|
||||
|
||||
/*
|
||||
* Divisor of the ASIU clocks
|
||||
*/
|
||||
struct iproc_asiu_div {
|
||||
unsigned int offset;
|
||||
unsigned int en_shift;
|
||||
unsigned int high_shift;
|
||||
unsigned int high_width;
|
||||
unsigned int low_shift;
|
||||
unsigned int low_width;
|
||||
};
|
||||
|
||||
void __init iproc_armpll_setup(struct device_node *node);
|
||||
void __init iproc_pll_clk_setup(struct device_node *node,
|
||||
const struct iproc_pll_ctrl *pll_ctrl,
|
||||
const struct iproc_pll_vco_param *vco,
|
||||
unsigned int num_vco_entries,
|
||||
const struct iproc_clk_ctrl *clk_ctrl,
|
||||
unsigned int num_clks);
|
||||
void __init iproc_asiu_setup(struct device_node *node,
|
||||
const struct iproc_asiu_div *div,
|
||||
const struct iproc_asiu_gate *gate,
|
||||
unsigned int num_clks);
|
||||
|
||||
#endif /* _CLK_IPROC_H */
|
||||
|
|
@ -21,8 +21,6 @@
|
|||
#define selector_clear_exists(sel) ((sel)->width = 0)
|
||||
#define trigger_clear_exists(trig) FLAG_CLEAR(trig, TRIG, EXISTS)
|
||||
|
||||
LIST_HEAD(ccu_list); /* The list of set up CCUs */
|
||||
|
||||
/* Validity checking */
|
||||
|
||||
static bool ccu_data_offsets_valid(struct ccu_data *ccu)
|
||||
|
|
@ -773,7 +771,6 @@ static void kona_ccu_teardown(struct ccu_data *ccu)
|
|||
|
||||
of_clk_del_provider(ccu->node); /* safe if never added */
|
||||
ccu_clks_teardown(ccu);
|
||||
list_del(&ccu->links);
|
||||
of_node_put(ccu->node);
|
||||
ccu->node = NULL;
|
||||
iounmap(ccu->base);
|
||||
|
|
@ -847,7 +844,6 @@ void __init kona_dt_ccu_setup(struct ccu_data *ccu,
|
|||
goto out_err;
|
||||
}
|
||||
ccu->node = of_node_get(node);
|
||||
list_add_tail(&ccu->links, &ccu_list);
|
||||
|
||||
/*
|
||||
* Set up each defined kona clock and save the result in
|
||||
|
|
|
|||
|
|
@ -1240,7 +1240,7 @@ static bool __kona_clk_init(struct kona_clk *bcm_clk)
|
|||
default:
|
||||
BUG();
|
||||
}
|
||||
return -EINVAL;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Set a CCU and all its clocks into their desired initial state */
|
||||
|
|
|
|||
|
|
@ -480,7 +480,6 @@ struct ccu_data {
|
|||
spinlock_t lock; /* serialization lock */
|
||||
bool write_enabled; /* write access is currently enabled */
|
||||
struct ccu_policy policy;
|
||||
struct list_head links; /* for ccu_list */
|
||||
struct device_node *node;
|
||||
struct clk_onecell_data clk_data;
|
||||
const char *name;
|
||||
|
|
@ -492,7 +491,6 @@ struct ccu_data {
|
|||
#define KONA_CCU_COMMON(_prefix, _name, _ccuname) \
|
||||
.name = #_name "_ccu", \
|
||||
.lock = __SPIN_LOCK_UNLOCKED(_name ## _ccu_data.lock), \
|
||||
.links = LIST_HEAD_INIT(_name ## _ccu_data.links), \
|
||||
.clk_data = { \
|
||||
.clk_num = _prefix ## _ ## _ccuname ## _CCU_CLOCK_COUNT, \
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,14 +25,7 @@
|
|||
#include <asm/div64.h>
|
||||
|
||||
#include "berlin2-div.h"
|
||||
|
||||
struct berlin2_pll_map {
|
||||
const u8 vcodiv[16];
|
||||
u8 mult;
|
||||
u8 fbdiv_shift;
|
||||
u8 rfdiv_shift;
|
||||
u8 divsel_shift;
|
||||
};
|
||||
#include "berlin2-pll.h"
|
||||
|
||||
struct berlin2_pll {
|
||||
struct clk_hw hw;
|
||||
|
|
|
|||
|
|
@ -274,7 +274,7 @@ static void __init asm9260_acc_init(struct device_node *np)
|
|||
u32 accuracy = 0;
|
||||
|
||||
base = of_io_request_and_map(np, 0, np->name);
|
||||
if (!base)
|
||||
if (IS_ERR(base))
|
||||
panic("%s: unable to map resource", np->name);
|
||||
|
||||
/* register pll */
|
||||
|
|
|
|||
|
|
@ -556,7 +556,7 @@ static int axmclk_probe(struct platform_device *pdev)
|
|||
return PTR_ERR(regmap);
|
||||
|
||||
num_clks = ARRAY_SIZE(axmclk_clocks);
|
||||
pr_info("axmclk: supporting %u clocks\n", num_clks);
|
||||
pr_info("axmclk: supporting %zu clocks\n", num_clks);
|
||||
priv = devm_kzalloc(dev, sizeof(*priv) + sizeof(*priv->clks) * num_clks,
|
||||
GFP_KERNEL);
|
||||
if (!priv)
|
||||
|
|
|
|||
|
|
@ -94,7 +94,7 @@ static const char * const cdce706_source_name[] = {
|
|||
"clk_in0", "clk_in1",
|
||||
};
|
||||
|
||||
static const char *cdce706_clkin_name[] = {
|
||||
static const char * const cdce706_clkin_name[] = {
|
||||
"clk_in",
|
||||
};
|
||||
|
||||
|
|
@ -102,7 +102,7 @@ static const char * const cdce706_pll_name[] = {
|
|||
"pll1", "pll2", "pll3",
|
||||
};
|
||||
|
||||
static const char *cdce706_divider_parent_name[] = {
|
||||
static const char * const cdce706_divider_parent_name[] = {
|
||||
"clk_in", "pll1", "pll2", "pll2", "pll3",
|
||||
};
|
||||
|
||||
|
|
@ -666,6 +666,7 @@ static int cdce706_probe(struct i2c_client *client,
|
|||
|
||||
static int cdce706_remove(struct i2c_client *client)
|
||||
{
|
||||
of_clk_del_provider(client->dev.of_node);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,749 @@
|
|||
/*
|
||||
* Driver for TI Dual PLL CDCE925 clock synthesizer
|
||||
*
|
||||
* This driver always connects the Y1 to the input clock, Y2/Y3 to PLL1
|
||||
* and Y4/Y5 to PLL2. PLL frequency is set on a first-come-first-serve
|
||||
* basis. Clients can directly request any frequency that the chip can
|
||||
* deliver using the standard clk framework. In addition, the device can
|
||||
* be configured and activated via the devicetree.
|
||||
*
|
||||
* Copyright (C) 2014, Topic Embedded Products
|
||||
* Licenced under GPL
|
||||
*/
|
||||
#include <linux/clk-provider.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/regmap.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/gcd.h>
|
||||
|
||||
/* The chip has 2 PLLs which can be routed through dividers to 5 outputs.
|
||||
* Model this as 2 PLL clocks which are parents to the outputs.
|
||||
*/
|
||||
#define NUMBER_OF_PLLS 2
|
||||
#define NUMBER_OF_OUTPUTS 5
|
||||
|
||||
#define CDCE925_REG_GLOBAL1 0x01
|
||||
#define CDCE925_REG_Y1SPIPDIVH 0x02
|
||||
#define CDCE925_REG_PDIVL 0x03
|
||||
#define CDCE925_REG_XCSEL 0x05
|
||||
/* PLL parameters start at 0x10, steps of 0x10 */
|
||||
#define CDCE925_OFFSET_PLL 0x10
|
||||
/* Add CDCE925_OFFSET_PLL * (pll) to these registers before sending */
|
||||
#define CDCE925_PLL_MUX_OUTPUTS 0x14
|
||||
#define CDCE925_PLL_MULDIV 0x18
|
||||
|
||||
#define CDCE925_PLL_FREQUENCY_MIN 80000000ul
|
||||
#define CDCE925_PLL_FREQUENCY_MAX 230000000ul
|
||||
struct clk_cdce925_chip;
|
||||
|
||||
struct clk_cdce925_output {
|
||||
struct clk_hw hw;
|
||||
struct clk_cdce925_chip *chip;
|
||||
u8 index;
|
||||
u16 pdiv; /* 1..127 for Y2-Y5; 1..1023 for Y1 */
|
||||
};
|
||||
#define to_clk_cdce925_output(_hw) \
|
||||
container_of(_hw, struct clk_cdce925_output, hw)
|
||||
|
||||
struct clk_cdce925_pll {
|
||||
struct clk_hw hw;
|
||||
struct clk_cdce925_chip *chip;
|
||||
u8 index;
|
||||
u16 m; /* 1..511 */
|
||||
u16 n; /* 1..4095 */
|
||||
};
|
||||
#define to_clk_cdce925_pll(_hw) container_of(_hw, struct clk_cdce925_pll, hw)
|
||||
|
||||
struct clk_cdce925_chip {
|
||||
struct regmap *regmap;
|
||||
struct i2c_client *i2c_client;
|
||||
struct clk_cdce925_pll pll[NUMBER_OF_PLLS];
|
||||
struct clk_cdce925_output clk[NUMBER_OF_OUTPUTS];
|
||||
struct clk *dt_clk[NUMBER_OF_OUTPUTS];
|
||||
struct clk_onecell_data onecell;
|
||||
};
|
||||
|
||||
/* ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** */
|
||||
|
||||
static unsigned long cdce925_pll_calculate_rate(unsigned long parent_rate,
|
||||
u16 n, u16 m)
|
||||
{
|
||||
if ((!m || !n) || (m == n))
|
||||
return parent_rate; /* In bypass mode runs at same frequency */
|
||||
return mult_frac(parent_rate, (unsigned long)n, (unsigned long)m);
|
||||
}
|
||||
|
||||
static unsigned long cdce925_pll_recalc_rate(struct clk_hw *hw,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
/* Output frequency of PLL is Fout = (Fin/Pdiv)*(N/M) */
|
||||
struct clk_cdce925_pll *data = to_clk_cdce925_pll(hw);
|
||||
|
||||
return cdce925_pll_calculate_rate(parent_rate, data->n, data->m);
|
||||
}
|
||||
|
||||
static void cdce925_pll_find_rate(unsigned long rate,
|
||||
unsigned long parent_rate, u16 *n, u16 *m)
|
||||
{
|
||||
unsigned long un;
|
||||
unsigned long um;
|
||||
unsigned long g;
|
||||
|
||||
if (rate <= parent_rate) {
|
||||
/* Can always deliver parent_rate in bypass mode */
|
||||
rate = parent_rate;
|
||||
*n = 0;
|
||||
*m = 0;
|
||||
} else {
|
||||
/* In PLL mode, need to apply min/max range */
|
||||
if (rate < CDCE925_PLL_FREQUENCY_MIN)
|
||||
rate = CDCE925_PLL_FREQUENCY_MIN;
|
||||
else if (rate > CDCE925_PLL_FREQUENCY_MAX)
|
||||
rate = CDCE925_PLL_FREQUENCY_MAX;
|
||||
|
||||
g = gcd(rate, parent_rate);
|
||||
um = parent_rate / g;
|
||||
un = rate / g;
|
||||
/* When outside hw range, reduce to fit (rounding errors) */
|
||||
while ((un > 4095) || (um > 511)) {
|
||||
un >>= 1;
|
||||
um >>= 1;
|
||||
}
|
||||
if (un == 0)
|
||||
un = 1;
|
||||
if (um == 0)
|
||||
um = 1;
|
||||
|
||||
*n = un;
|
||||
*m = um;
|
||||
}
|
||||
}
|
||||
|
||||
static long cdce925_pll_round_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long *parent_rate)
|
||||
{
|
||||
u16 n, m;
|
||||
|
||||
cdce925_pll_find_rate(rate, *parent_rate, &n, &m);
|
||||
return (long)cdce925_pll_calculate_rate(*parent_rate, n, m);
|
||||
}
|
||||
|
||||
static int cdce925_pll_set_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct clk_cdce925_pll *data = to_clk_cdce925_pll(hw);
|
||||
|
||||
if (!rate || (rate == parent_rate)) {
|
||||
data->m = 0; /* Bypass mode */
|
||||
data->n = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((rate < CDCE925_PLL_FREQUENCY_MIN) ||
|
||||
(rate > CDCE925_PLL_FREQUENCY_MAX)) {
|
||||
pr_debug("%s: rate %lu outside PLL range.\n", __func__, rate);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (rate < parent_rate) {
|
||||
pr_debug("%s: rate %lu less than parent rate %lu.\n", __func__,
|
||||
rate, parent_rate);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
cdce925_pll_find_rate(rate, parent_rate, &data->n, &data->m);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* calculate p = max(0, 4 - int(log2 (n/m))) */
|
||||
static u8 cdce925_pll_calc_p(u16 n, u16 m)
|
||||
{
|
||||
u8 p;
|
||||
u16 r = n / m;
|
||||
|
||||
if (r >= 16)
|
||||
return 0;
|
||||
p = 4;
|
||||
while (r > 1) {
|
||||
r >>= 1;
|
||||
--p;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
/* Returns VCO range bits for VCO1_0_RANGE */
|
||||
static u8 cdce925_pll_calc_range_bits(struct clk_hw *hw, u16 n, u16 m)
|
||||
{
|
||||
struct clk *parent = clk_get_parent(hw->clk);
|
||||
unsigned long rate = clk_get_rate(parent);
|
||||
|
||||
rate = mult_frac(rate, (unsigned long)n, (unsigned long)m);
|
||||
if (rate >= 175000000)
|
||||
return 0x3;
|
||||
if (rate >= 150000000)
|
||||
return 0x02;
|
||||
if (rate >= 125000000)
|
||||
return 0x01;
|
||||
return 0x00;
|
||||
}
|
||||
|
||||
/* I2C clock, hence everything must happen in (un)prepare because this
|
||||
* may sleep */
|
||||
static int cdce925_pll_prepare(struct clk_hw *hw)
|
||||
{
|
||||
struct clk_cdce925_pll *data = to_clk_cdce925_pll(hw);
|
||||
u16 n = data->n;
|
||||
u16 m = data->m;
|
||||
u16 r;
|
||||
u8 q;
|
||||
u8 p;
|
||||
u16 nn;
|
||||
u8 pll[4]; /* Bits are spread out over 4 byte registers */
|
||||
u8 reg_ofs = data->index * CDCE925_OFFSET_PLL;
|
||||
unsigned i;
|
||||
|
||||
if ((!m || !n) || (m == n)) {
|
||||
/* Set PLL mux to bypass mode, leave the rest as is */
|
||||
regmap_update_bits(data->chip->regmap,
|
||||
reg_ofs + CDCE925_PLL_MUX_OUTPUTS, 0x80, 0x80);
|
||||
} else {
|
||||
/* According to data sheet: */
|
||||
/* p = max(0, 4 - int(log2 (n/m))) */
|
||||
p = cdce925_pll_calc_p(n, m);
|
||||
/* nn = n * 2^p */
|
||||
nn = n * BIT(p);
|
||||
/* q = int(nn/m) */
|
||||
q = nn / m;
|
||||
if ((q < 16) || (1 > 64)) {
|
||||
pr_debug("%s invalid q=%d\n", __func__, q);
|
||||
return -EINVAL;
|
||||
}
|
||||
r = nn - (m*q);
|
||||
if (r > 511) {
|
||||
pr_debug("%s invalid r=%d\n", __func__, r);
|
||||
return -EINVAL;
|
||||
}
|
||||
pr_debug("%s n=%d m=%d p=%d q=%d r=%d\n", __func__,
|
||||
n, m, p, q, r);
|
||||
/* encode into register bits */
|
||||
pll[0] = n >> 4;
|
||||
pll[1] = ((n & 0x0F) << 4) | ((r >> 5) & 0x0F);
|
||||
pll[2] = ((r & 0x1F) << 3) | ((q >> 3) & 0x07);
|
||||
pll[3] = ((q & 0x07) << 5) | (p << 2) |
|
||||
cdce925_pll_calc_range_bits(hw, n, m);
|
||||
/* Write to registers */
|
||||
for (i = 0; i < ARRAY_SIZE(pll); ++i)
|
||||
regmap_write(data->chip->regmap,
|
||||
reg_ofs + CDCE925_PLL_MULDIV + i, pll[i]);
|
||||
/* Enable PLL */
|
||||
regmap_update_bits(data->chip->regmap,
|
||||
reg_ofs + CDCE925_PLL_MUX_OUTPUTS, 0x80, 0x00);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void cdce925_pll_unprepare(struct clk_hw *hw)
|
||||
{
|
||||
struct clk_cdce925_pll *data = to_clk_cdce925_pll(hw);
|
||||
u8 reg_ofs = data->index * CDCE925_OFFSET_PLL;
|
||||
|
||||
regmap_update_bits(data->chip->regmap,
|
||||
reg_ofs + CDCE925_PLL_MUX_OUTPUTS, 0x80, 0x80);
|
||||
}
|
||||
|
||||
static const struct clk_ops cdce925_pll_ops = {
|
||||
.prepare = cdce925_pll_prepare,
|
||||
.unprepare = cdce925_pll_unprepare,
|
||||
.recalc_rate = cdce925_pll_recalc_rate,
|
||||
.round_rate = cdce925_pll_round_rate,
|
||||
.set_rate = cdce925_pll_set_rate,
|
||||
};
|
||||
|
||||
|
||||
static void cdce925_clk_set_pdiv(struct clk_cdce925_output *data, u16 pdiv)
|
||||
{
|
||||
switch (data->index) {
|
||||
case 0:
|
||||
regmap_update_bits(data->chip->regmap,
|
||||
CDCE925_REG_Y1SPIPDIVH,
|
||||
0x03, (pdiv >> 8) & 0x03);
|
||||
regmap_write(data->chip->regmap, 0x03, pdiv & 0xFF);
|
||||
break;
|
||||
case 1:
|
||||
regmap_update_bits(data->chip->regmap, 0x16, 0x7F, pdiv);
|
||||
break;
|
||||
case 2:
|
||||
regmap_update_bits(data->chip->regmap, 0x17, 0x7F, pdiv);
|
||||
break;
|
||||
case 3:
|
||||
regmap_update_bits(data->chip->regmap, 0x26, 0x7F, pdiv);
|
||||
break;
|
||||
case 4:
|
||||
regmap_update_bits(data->chip->regmap, 0x27, 0x7F, pdiv);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void cdce925_clk_activate(struct clk_cdce925_output *data)
|
||||
{
|
||||
switch (data->index) {
|
||||
case 0:
|
||||
regmap_update_bits(data->chip->regmap,
|
||||
CDCE925_REG_Y1SPIPDIVH, 0x0c, 0x0c);
|
||||
break;
|
||||
case 1:
|
||||
case 2:
|
||||
regmap_update_bits(data->chip->regmap, 0x14, 0x03, 0x03);
|
||||
break;
|
||||
case 3:
|
||||
case 4:
|
||||
regmap_update_bits(data->chip->regmap, 0x24, 0x03, 0x03);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static int cdce925_clk_prepare(struct clk_hw *hw)
|
||||
{
|
||||
struct clk_cdce925_output *data = to_clk_cdce925_output(hw);
|
||||
|
||||
cdce925_clk_set_pdiv(data, data->pdiv);
|
||||
cdce925_clk_activate(data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void cdce925_clk_unprepare(struct clk_hw *hw)
|
||||
{
|
||||
struct clk_cdce925_output *data = to_clk_cdce925_output(hw);
|
||||
|
||||
/* Disable clock by setting divider to "0" */
|
||||
cdce925_clk_set_pdiv(data, 0);
|
||||
}
|
||||
|
||||
static unsigned long cdce925_clk_recalc_rate(struct clk_hw *hw,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct clk_cdce925_output *data = to_clk_cdce925_output(hw);
|
||||
|
||||
if (data->pdiv)
|
||||
return parent_rate / data->pdiv;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static u16 cdce925_calc_divider(unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
unsigned long divider;
|
||||
|
||||
if (!rate)
|
||||
return 0;
|
||||
if (rate >= parent_rate)
|
||||
return 1;
|
||||
|
||||
divider = DIV_ROUND_CLOSEST(parent_rate, rate);
|
||||
if (divider > 0x7F)
|
||||
divider = 0x7F;
|
||||
|
||||
return (u16)divider;
|
||||
}
|
||||
|
||||
static unsigned long cdce925_clk_best_parent_rate(
|
||||
struct clk_hw *hw, unsigned long rate)
|
||||
{
|
||||
struct clk *pll = clk_get_parent(hw->clk);
|
||||
struct clk *root = clk_get_parent(pll);
|
||||
unsigned long root_rate = clk_get_rate(root);
|
||||
unsigned long best_rate_error = rate;
|
||||
u16 pdiv_min;
|
||||
u16 pdiv_max;
|
||||
u16 pdiv_best;
|
||||
u16 pdiv_now;
|
||||
|
||||
if (root_rate % rate == 0)
|
||||
return root_rate; /* Don't need the PLL, use bypass */
|
||||
|
||||
pdiv_min = (u16)max(1ul, DIV_ROUND_UP(CDCE925_PLL_FREQUENCY_MIN, rate));
|
||||
pdiv_max = (u16)min(127ul, CDCE925_PLL_FREQUENCY_MAX / rate);
|
||||
|
||||
if (pdiv_min > pdiv_max)
|
||||
return 0; /* No can do? */
|
||||
|
||||
pdiv_best = pdiv_min;
|
||||
for (pdiv_now = pdiv_min; pdiv_now < pdiv_max; ++pdiv_now) {
|
||||
unsigned long target_rate = rate * pdiv_now;
|
||||
long pll_rate = clk_round_rate(pll, target_rate);
|
||||
unsigned long actual_rate;
|
||||
unsigned long rate_error;
|
||||
|
||||
if (pll_rate <= 0)
|
||||
continue;
|
||||
actual_rate = pll_rate / pdiv_now;
|
||||
rate_error = abs((long)actual_rate - (long)rate);
|
||||
if (rate_error < best_rate_error) {
|
||||
pdiv_best = pdiv_now;
|
||||
best_rate_error = rate_error;
|
||||
}
|
||||
/* TODO: Consider PLL frequency based on smaller n/m values
|
||||
* and pick the better one if the error is equal */
|
||||
}
|
||||
|
||||
return rate * pdiv_best;
|
||||
}
|
||||
|
||||
static long cdce925_clk_round_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long *parent_rate)
|
||||
{
|
||||
unsigned long l_parent_rate = *parent_rate;
|
||||
u16 divider = cdce925_calc_divider(rate, l_parent_rate);
|
||||
|
||||
if (l_parent_rate / divider != rate) {
|
||||
l_parent_rate = cdce925_clk_best_parent_rate(hw, rate);
|
||||
divider = cdce925_calc_divider(rate, l_parent_rate);
|
||||
*parent_rate = l_parent_rate;
|
||||
}
|
||||
|
||||
if (divider)
|
||||
return (long)(l_parent_rate / divider);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cdce925_clk_set_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct clk_cdce925_output *data = to_clk_cdce925_output(hw);
|
||||
|
||||
data->pdiv = cdce925_calc_divider(rate, parent_rate);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct clk_ops cdce925_clk_ops = {
|
||||
.prepare = cdce925_clk_prepare,
|
||||
.unprepare = cdce925_clk_unprepare,
|
||||
.recalc_rate = cdce925_clk_recalc_rate,
|
||||
.round_rate = cdce925_clk_round_rate,
|
||||
.set_rate = cdce925_clk_set_rate,
|
||||
};
|
||||
|
||||
|
||||
static u16 cdce925_y1_calc_divider(unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
unsigned long divider;
|
||||
|
||||
if (!rate)
|
||||
return 0;
|
||||
if (rate >= parent_rate)
|
||||
return 1;
|
||||
|
||||
divider = DIV_ROUND_CLOSEST(parent_rate, rate);
|
||||
if (divider > 0x3FF) /* Y1 has 10-bit divider */
|
||||
divider = 0x3FF;
|
||||
|
||||
return (u16)divider;
|
||||
}
|
||||
|
||||
static long cdce925_clk_y1_round_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long *parent_rate)
|
||||
{
|
||||
unsigned long l_parent_rate = *parent_rate;
|
||||
u16 divider = cdce925_y1_calc_divider(rate, l_parent_rate);
|
||||
|
||||
if (divider)
|
||||
return (long)(l_parent_rate / divider);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cdce925_clk_y1_set_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct clk_cdce925_output *data = to_clk_cdce925_output(hw);
|
||||
|
||||
data->pdiv = cdce925_y1_calc_divider(rate, parent_rate);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct clk_ops cdce925_clk_y1_ops = {
|
||||
.prepare = cdce925_clk_prepare,
|
||||
.unprepare = cdce925_clk_unprepare,
|
||||
.recalc_rate = cdce925_clk_recalc_rate,
|
||||
.round_rate = cdce925_clk_y1_round_rate,
|
||||
.set_rate = cdce925_clk_y1_set_rate,
|
||||
};
|
||||
|
||||
|
||||
static struct regmap_config cdce925_regmap_config = {
|
||||
.name = "configuration0",
|
||||
.reg_bits = 8,
|
||||
.val_bits = 8,
|
||||
.cache_type = REGCACHE_RBTREE,
|
||||
.max_register = 0x2F,
|
||||
};
|
||||
|
||||
#define CDCE925_I2C_COMMAND_BLOCK_TRANSFER 0x00
|
||||
#define CDCE925_I2C_COMMAND_BYTE_TRANSFER 0x80
|
||||
|
||||
static int cdce925_regmap_i2c_write(
|
||||
void *context, const void *data, size_t count)
|
||||
{
|
||||
struct device *dev = context;
|
||||
struct i2c_client *i2c = to_i2c_client(dev);
|
||||
int ret;
|
||||
u8 reg_data[2];
|
||||
|
||||
if (count != 2)
|
||||
return -ENOTSUPP;
|
||||
|
||||
/* First byte is command code */
|
||||
reg_data[0] = CDCE925_I2C_COMMAND_BYTE_TRANSFER | ((u8 *)data)[0];
|
||||
reg_data[1] = ((u8 *)data)[1];
|
||||
|
||||
dev_dbg(&i2c->dev, "%s(%zu) %#x %#x\n", __func__, count,
|
||||
reg_data[0], reg_data[1]);
|
||||
|
||||
ret = i2c_master_send(i2c, reg_data, count);
|
||||
if (likely(ret == count))
|
||||
return 0;
|
||||
else if (ret < 0)
|
||||
return ret;
|
||||
else
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
static int cdce925_regmap_i2c_read(void *context,
|
||||
const void *reg, size_t reg_size, void *val, size_t val_size)
|
||||
{
|
||||
struct device *dev = context;
|
||||
struct i2c_client *i2c = to_i2c_client(dev);
|
||||
struct i2c_msg xfer[2];
|
||||
int ret;
|
||||
u8 reg_data[2];
|
||||
|
||||
if (reg_size != 1)
|
||||
return -ENOTSUPP;
|
||||
|
||||
xfer[0].addr = i2c->addr;
|
||||
xfer[0].flags = 0;
|
||||
xfer[0].buf = reg_data;
|
||||
if (val_size == 1) {
|
||||
reg_data[0] =
|
||||
CDCE925_I2C_COMMAND_BYTE_TRANSFER | ((u8 *)reg)[0];
|
||||
xfer[0].len = 1;
|
||||
} else {
|
||||
reg_data[0] =
|
||||
CDCE925_I2C_COMMAND_BLOCK_TRANSFER | ((u8 *)reg)[0];
|
||||
reg_data[1] = val_size;
|
||||
xfer[0].len = 2;
|
||||
}
|
||||
|
||||
xfer[1].addr = i2c->addr;
|
||||
xfer[1].flags = I2C_M_RD;
|
||||
xfer[1].len = val_size;
|
||||
xfer[1].buf = val;
|
||||
|
||||
ret = i2c_transfer(i2c->adapter, xfer, 2);
|
||||
if (likely(ret == 2)) {
|
||||
dev_dbg(&i2c->dev, "%s(%zu, %zu) %#x %#x\n", __func__,
|
||||
reg_size, val_size, reg_data[0], *((u8 *)val));
|
||||
return 0;
|
||||
} else if (ret < 0)
|
||||
return ret;
|
||||
else
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
/* The CDCE925 uses a funky way to read/write registers. Bulk mode is
|
||||
* just weird, so just use the single byte mode exclusively. */
|
||||
static struct regmap_bus regmap_cdce925_bus = {
|
||||
.write = cdce925_regmap_i2c_write,
|
||||
.read = cdce925_regmap_i2c_read,
|
||||
};
|
||||
|
||||
static int cdce925_probe(struct i2c_client *client,
|
||||
const struct i2c_device_id *id)
|
||||
{
|
||||
struct clk_cdce925_chip *data;
|
||||
struct device_node *node = client->dev.of_node;
|
||||
const char *parent_name;
|
||||
const char *pll_clk_name[NUMBER_OF_PLLS] = {NULL,};
|
||||
struct clk_init_data init;
|
||||
struct clk *clk;
|
||||
u32 value;
|
||||
int i;
|
||||
int err;
|
||||
struct device_node *np_output;
|
||||
char child_name[6];
|
||||
|
||||
dev_dbg(&client->dev, "%s\n", __func__);
|
||||
data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
|
||||
if (!data)
|
||||
return -ENOMEM;
|
||||
|
||||
data->i2c_client = client;
|
||||
data->regmap = devm_regmap_init(&client->dev, ®map_cdce925_bus,
|
||||
&client->dev, &cdce925_regmap_config);
|
||||
if (IS_ERR(data->regmap)) {
|
||||
dev_err(&client->dev, "failed to allocate register map\n");
|
||||
return PTR_ERR(data->regmap);
|
||||
}
|
||||
i2c_set_clientdata(client, data);
|
||||
|
||||
parent_name = of_clk_get_parent_name(node, 0);
|
||||
if (!parent_name) {
|
||||
dev_err(&client->dev, "missing parent clock\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
dev_dbg(&client->dev, "parent is: %s\n", parent_name);
|
||||
|
||||
if (of_property_read_u32(node, "xtal-load-pf", &value) == 0)
|
||||
regmap_write(data->regmap,
|
||||
CDCE925_REG_XCSEL, (value << 3) & 0xF8);
|
||||
/* PWDN bit */
|
||||
regmap_update_bits(data->regmap, CDCE925_REG_GLOBAL1, BIT(4), 0);
|
||||
|
||||
/* Set input source for Y1 to be the XTAL */
|
||||
regmap_update_bits(data->regmap, 0x02, BIT(7), 0);
|
||||
|
||||
init.ops = &cdce925_pll_ops;
|
||||
init.flags = 0;
|
||||
init.parent_names = &parent_name;
|
||||
init.num_parents = parent_name ? 1 : 0;
|
||||
|
||||
/* Register PLL clocks */
|
||||
for (i = 0; i < NUMBER_OF_PLLS; ++i) {
|
||||
pll_clk_name[i] = kasprintf(GFP_KERNEL, "%s.pll%d",
|
||||
client->dev.of_node->name, i);
|
||||
init.name = pll_clk_name[i];
|
||||
data->pll[i].chip = data;
|
||||
data->pll[i].hw.init = &init;
|
||||
data->pll[i].index = i;
|
||||
clk = devm_clk_register(&client->dev, &data->pll[i].hw);
|
||||
if (IS_ERR(clk)) {
|
||||
dev_err(&client->dev, "Failed register PLL %d\n", i);
|
||||
err = PTR_ERR(clk);
|
||||
goto error;
|
||||
}
|
||||
sprintf(child_name, "PLL%d", i+1);
|
||||
np_output = of_get_child_by_name(node, child_name);
|
||||
if (!np_output)
|
||||
continue;
|
||||
if (!of_property_read_u32(np_output,
|
||||
"clock-frequency", &value)) {
|
||||
err = clk_set_rate(clk, value);
|
||||
if (err)
|
||||
dev_err(&client->dev,
|
||||
"unable to set PLL frequency %ud\n",
|
||||
value);
|
||||
}
|
||||
if (!of_property_read_u32(np_output,
|
||||
"spread-spectrum", &value)) {
|
||||
u8 flag = of_property_read_bool(np_output,
|
||||
"spread-spectrum-center") ? 0x80 : 0x00;
|
||||
regmap_update_bits(data->regmap,
|
||||
0x16 + (i*CDCE925_OFFSET_PLL),
|
||||
0x80, flag);
|
||||
regmap_update_bits(data->regmap,
|
||||
0x12 + (i*CDCE925_OFFSET_PLL),
|
||||
0x07, value & 0x07);
|
||||
}
|
||||
}
|
||||
|
||||
/* Register output clock Y1 */
|
||||
init.ops = &cdce925_clk_y1_ops;
|
||||
init.flags = 0;
|
||||
init.num_parents = 1;
|
||||
init.parent_names = &parent_name; /* Mux Y1 to input */
|
||||
init.name = kasprintf(GFP_KERNEL, "%s.Y1", client->dev.of_node->name);
|
||||
data->clk[0].chip = data;
|
||||
data->clk[0].hw.init = &init;
|
||||
data->clk[0].index = 0;
|
||||
data->clk[0].pdiv = 1;
|
||||
clk = devm_clk_register(&client->dev, &data->clk[0].hw);
|
||||
kfree(init.name); /* clock framework made a copy of the name */
|
||||
if (IS_ERR(clk)) {
|
||||
dev_err(&client->dev, "clock registration Y1 failed\n");
|
||||
err = PTR_ERR(clk);
|
||||
goto error;
|
||||
}
|
||||
data->dt_clk[0] = clk;
|
||||
|
||||
/* Register output clocks Y2 .. Y5*/
|
||||
init.ops = &cdce925_clk_ops;
|
||||
init.flags = CLK_SET_RATE_PARENT;
|
||||
init.num_parents = 1;
|
||||
for (i = 1; i < NUMBER_OF_OUTPUTS; ++i) {
|
||||
init.name = kasprintf(GFP_KERNEL, "%s.Y%d",
|
||||
client->dev.of_node->name, i+1);
|
||||
data->clk[i].chip = data;
|
||||
data->clk[i].hw.init = &init;
|
||||
data->clk[i].index = i;
|
||||
data->clk[i].pdiv = 1;
|
||||
switch (i) {
|
||||
case 1:
|
||||
case 2:
|
||||
/* Mux Y2/3 to PLL1 */
|
||||
init.parent_names = &pll_clk_name[0];
|
||||
break;
|
||||
case 3:
|
||||
case 4:
|
||||
/* Mux Y4/5 to PLL2 */
|
||||
init.parent_names = &pll_clk_name[1];
|
||||
break;
|
||||
}
|
||||
clk = devm_clk_register(&client->dev, &data->clk[i].hw);
|
||||
kfree(init.name); /* clock framework made a copy of the name */
|
||||
if (IS_ERR(clk)) {
|
||||
dev_err(&client->dev, "clock registration failed\n");
|
||||
err = PTR_ERR(clk);
|
||||
goto error;
|
||||
}
|
||||
data->dt_clk[i] = clk;
|
||||
}
|
||||
|
||||
/* Register the output clocks */
|
||||
data->onecell.clk_num = NUMBER_OF_OUTPUTS;
|
||||
data->onecell.clks = data->dt_clk;
|
||||
err = of_clk_add_provider(client->dev.of_node, of_clk_src_onecell_get,
|
||||
&data->onecell);
|
||||
if (err)
|
||||
dev_err(&client->dev, "unable to add OF clock provider\n");
|
||||
|
||||
err = 0;
|
||||
|
||||
error:
|
||||
for (i = 0; i < NUMBER_OF_PLLS; ++i)
|
||||
/* clock framework made a copy of the name */
|
||||
kfree(pll_clk_name[i]);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static const struct i2c_device_id cdce925_id[] = {
|
||||
{ "cdce925", 0 },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(i2c, cdce925_id);
|
||||
|
||||
static const struct of_device_id clk_cdce925_of_match[] = {
|
||||
{ .compatible = "ti,cdce925" },
|
||||
{ },
|
||||
};
|
||||
MODULE_DEVICE_TABLE(of, clk_cdce925_of_match);
|
||||
|
||||
static struct i2c_driver cdce925_driver = {
|
||||
.driver = {
|
||||
.name = "cdce925",
|
||||
.of_match_table = of_match_ptr(clk_cdce925_of_match),
|
||||
},
|
||||
.probe = cdce925_probe,
|
||||
.id_table = cdce925_id,
|
||||
};
|
||||
module_i2c_driver(cdce925_driver);
|
||||
|
||||
MODULE_AUTHOR("Mike Looijmans <mike.looijmans@topic.nl>");
|
||||
MODULE_DESCRIPTION("cdce925 driver");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
|
@ -188,7 +188,7 @@ static void clk_composite_disable(struct clk_hw *hw)
|
|||
}
|
||||
|
||||
struct clk *clk_register_composite(struct device *dev, const char *name,
|
||||
const char **parent_names, int num_parents,
|
||||
const char * const *parent_names, int num_parents,
|
||||
struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
|
||||
struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
|
||||
struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
|
||||
|
|
@ -200,10 +200,8 @@ struct clk *clk_register_composite(struct device *dev, const char *name,
|
|||
struct clk_ops *clk_composite_ops;
|
||||
|
||||
composite = kzalloc(sizeof(*composite), GFP_KERNEL);
|
||||
if (!composite) {
|
||||
pr_err("%s: could not allocate composite clk\n", __func__);
|
||||
if (!composite)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
|
||||
init.name = name;
|
||||
init.flags = flags | CLK_IS_BASIC;
|
||||
|
|
|
|||
|
|
@ -106,8 +106,9 @@ static int __set_clk_rates(struct device_node *node, bool clk_supplier)
|
|||
|
||||
rc = clk_set_rate(clk, rate);
|
||||
if (rc < 0)
|
||||
pr_err("clk: couldn't set %s clock rate: %d\n",
|
||||
__clk_get_name(clk), rc);
|
||||
pr_err("clk: couldn't set %s clk rate to %d (%d), current rate: %ld\n",
|
||||
__clk_get_name(clk), rate, rc,
|
||||
clk_get_rate(clk));
|
||||
clk_put(clk);
|
||||
}
|
||||
index++;
|
||||
|
|
@ -124,7 +125,7 @@ static int __set_clk_rates(struct device_node *node, bool clk_supplier)
|
|||
* and sets any specified clock parents and rates. The @clk_supplier argument
|
||||
* should be set to true if @node may be also a clock supplier of any clock
|
||||
* listed in its 'assigned-clocks' or 'assigned-clock-parents' properties.
|
||||
* If @clk_supplier is false the function exits returnning 0 as soon as it
|
||||
* If @clk_supplier is false the function exits returning 0 as soon as it
|
||||
* determines the @node is also a supplier of any of the clocks.
|
||||
*/
|
||||
int of_clk_set_defaults(struct device_node *node, bool clk_supplier)
|
||||
|
|
|
|||
|
|
@ -430,11 +430,9 @@ static struct clk *_register_divider(struct device *dev, const char *name,
|
|||
}
|
||||
|
||||
/* allocate the divider */
|
||||
div = kzalloc(sizeof(struct clk_divider), GFP_KERNEL);
|
||||
if (!div) {
|
||||
pr_err("%s: could not allocate divider clk\n", __func__);
|
||||
div = kzalloc(sizeof(*div), GFP_KERNEL);
|
||||
if (!div)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
|
||||
init.name = name;
|
||||
init.ops = &clk_divider_ops;
|
||||
|
|
|
|||
|
|
@ -55,10 +55,16 @@ static long clk_factor_round_rate(struct clk_hw *hw, unsigned long rate,
|
|||
static int clk_factor_set_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
/*
|
||||
* We must report success but we can do so unconditionally because
|
||||
* clk_factor_round_rate returns values that ensure this call is a
|
||||
* nop.
|
||||
*/
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct clk_ops clk_fixed_factor_ops = {
|
||||
const struct clk_ops clk_fixed_factor_ops = {
|
||||
.round_rate = clk_factor_round_rate,
|
||||
.set_rate = clk_factor_set_rate,
|
||||
.recalc_rate = clk_factor_recalc_rate,
|
||||
|
|
@ -74,10 +80,8 @@ struct clk *clk_register_fixed_factor(struct device *dev, const char *name,
|
|||
struct clk *clk;
|
||||
|
||||
fix = kmalloc(sizeof(*fix), GFP_KERNEL);
|
||||
if (!fix) {
|
||||
pr_err("%s: could not allocate fixed factor clk\n", __func__);
|
||||
if (!fix)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
|
||||
/* struct clk_fixed_factor assignments */
|
||||
fix->mult = mult;
|
||||
|
|
|
|||
|
|
@ -65,11 +65,9 @@ struct clk *clk_register_fixed_rate_with_accuracy(struct device *dev,
|
|||
struct clk_init_data init;
|
||||
|
||||
/* allocate fixed-rate clock */
|
||||
fixed = kzalloc(sizeof(struct clk_fixed_rate), GFP_KERNEL);
|
||||
if (!fixed) {
|
||||
pr_err("%s: could not allocate fixed clk\n", __func__);
|
||||
fixed = kzalloc(sizeof(*fixed), GFP_KERNEL);
|
||||
if (!fixed)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
|
||||
init.name = name;
|
||||
init.ops = &clk_fixed_rate_ops;
|
||||
|
|
|
|||
|
|
@ -109,10 +109,8 @@ struct clk *clk_register_fractional_divider(struct device *dev,
|
|||
struct clk *clk;
|
||||
|
||||
fd = kzalloc(sizeof(*fd), GFP_KERNEL);
|
||||
if (!fd) {
|
||||
dev_err(dev, "could not allocate fractional divider clk\n");
|
||||
if (!fd)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
|
||||
init.name = name;
|
||||
init.ops = &clk_fractional_divider_ops;
|
||||
|
|
|
|||
|
|
@ -135,11 +135,9 @@ struct clk *clk_register_gate(struct device *dev, const char *name,
|
|||
}
|
||||
|
||||
/* allocate the gate */
|
||||
gate = kzalloc(sizeof(struct clk_gate), GFP_KERNEL);
|
||||
if (!gate) {
|
||||
pr_err("%s: could not allocate gated clk\n", __func__);
|
||||
gate = kzalloc(sizeof(*gate), GFP_KERNEL);
|
||||
if (!gate)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
|
||||
init.name = name;
|
||||
init.ops = &clk_gate_ops;
|
||||
|
|
|
|||
|
|
@ -189,7 +189,7 @@ static struct clk *of_clk_gpio_gate_delayed_register_get(
|
|||
/**
|
||||
* of_gpio_gate_clk_setup() - Setup function for gpio controlled clock
|
||||
*/
|
||||
void __init of_gpio_gate_clk_setup(struct device_node *node)
|
||||
static void __init of_gpio_gate_clk_setup(struct device_node *node)
|
||||
{
|
||||
struct clk_gpio_gate_delayed_register_data *data;
|
||||
|
||||
|
|
@ -203,6 +203,5 @@ void __init of_gpio_gate_clk_setup(struct device_node *node)
|
|||
|
||||
of_clk_add_provider(node, of_clk_gpio_gate_delayed_register_get, data);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(of_gpio_gate_clk_setup);
|
||||
CLK_OF_DECLARE(gpio_gate_clk, "gpio-gate-clock", of_gpio_gate_clk_setup);
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -80,9 +80,9 @@ static struct clk *__init clk_register_pll(struct device *dev,
|
|||
return clk;
|
||||
}
|
||||
|
||||
static const char const *cpu_parents[] = { "cpu_clk_div", "osc_33m_clk", };
|
||||
static const char const *ahb_parents[] = { "ahb_clk_div", "osc_33m_clk", };
|
||||
static const char const *dc_parents[] = { "dc_clk_div", "osc_33m_clk", };
|
||||
static const char * const cpu_parents[] = { "cpu_clk_div", "osc_33m_clk", };
|
||||
static const char * const ahb_parents[] = { "ahb_clk_div", "osc_33m_clk", };
|
||||
static const char * const dc_parents[] = { "dc_clk_div", "osc_33m_clk", };
|
||||
|
||||
void __init ls1x_clk_init(void)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -31,6 +31,8 @@
|
|||
#include <linux/of.h>
|
||||
#include <linux/export.h>
|
||||
|
||||
#include "clk-max-gen.h"
|
||||
|
||||
struct max_gen_clk {
|
||||
struct regmap *regmap;
|
||||
u32 mask;
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
#include <linux/of_address.h>
|
||||
#include <linux/clkdev.h>
|
||||
|
||||
void __init moxart_of_pll_clk_init(struct device_node *node)
|
||||
static void __init moxart_of_pll_clk_init(struct device_node *node)
|
||||
{
|
||||
static void __iomem *base;
|
||||
struct clk *clk, *ref_clk;
|
||||
|
|
@ -53,7 +53,7 @@ void __init moxart_of_pll_clk_init(struct device_node *node)
|
|||
CLK_OF_DECLARE(moxart_pll_clock, "moxa,moxart-pll-clock",
|
||||
moxart_of_pll_clk_init);
|
||||
|
||||
void __init moxart_of_apb_clk_init(struct device_node *node)
|
||||
static void __init moxart_of_apb_clk_init(struct device_node *node)
|
||||
{
|
||||
static void __iomem *base;
|
||||
struct clk *clk, *pll_clk;
|
||||
|
|
|
|||
|
|
@ -114,7 +114,8 @@ const struct clk_ops clk_mux_ro_ops = {
|
|||
EXPORT_SYMBOL_GPL(clk_mux_ro_ops);
|
||||
|
||||
struct clk *clk_register_mux_table(struct device *dev, const char *name,
|
||||
const char **parent_names, u8 num_parents, unsigned long flags,
|
||||
const char * const *parent_names, u8 num_parents,
|
||||
unsigned long flags,
|
||||
void __iomem *reg, u8 shift, u32 mask,
|
||||
u8 clk_mux_flags, u32 *table, spinlock_t *lock)
|
||||
{
|
||||
|
|
@ -166,7 +167,8 @@ struct clk *clk_register_mux_table(struct device *dev, const char *name,
|
|||
EXPORT_SYMBOL_GPL(clk_register_mux_table);
|
||||
|
||||
struct clk *clk_register_mux(struct device *dev, const char *name,
|
||||
const char **parent_names, u8 num_parents, unsigned long flags,
|
||||
const char * const *parent_names, u8 num_parents,
|
||||
unsigned long flags,
|
||||
void __iomem *reg, u8 shift, u8 width,
|
||||
u8 clk_mux_flags, spinlock_t *lock)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -552,7 +552,8 @@ static const struct clk_ops si5351_pll_ops = {
|
|||
* MSx_P2[19:0] = 128 * b - c * floor(128 * b/c) = (128*b) mod c
|
||||
* MSx_P3[19:0] = c
|
||||
*
|
||||
* MS[6,7] are integer (P1) divide only, P2 = 0, P3 = 0
|
||||
* MS[6,7] are integer (P1) divide only, P1 = divide value,
|
||||
* P2 and P3 are not applicable
|
||||
*
|
||||
* for 150MHz < fOUT <= 160MHz:
|
||||
*
|
||||
|
|
@ -606,9 +607,6 @@ static unsigned long si5351_msynth_recalc_rate(struct clk_hw *hw,
|
|||
if (!hwdata->params.valid)
|
||||
si5351_read_parameters(hwdata->drvdata, reg, &hwdata->params);
|
||||
|
||||
if (hwdata->params.p3 == 0)
|
||||
return parent_rate;
|
||||
|
||||
/*
|
||||
* multisync0-5: fOUT = (128 * P3 * fIN) / (P1*P3 + P2 + 512*P3)
|
||||
* multisync6-7: fOUT = fIN / P1
|
||||
|
|
@ -616,6 +614,8 @@ static unsigned long si5351_msynth_recalc_rate(struct clk_hw *hw,
|
|||
rate = parent_rate;
|
||||
if (hwdata->num > 5) {
|
||||
m = hwdata->params.p1;
|
||||
} else if (hwdata->params.p3 == 0) {
|
||||
return parent_rate;
|
||||
} else if ((si5351_reg_read(hwdata->drvdata, reg + 2) &
|
||||
SI5351_OUTPUT_CLK_DIVBY4) == SI5351_OUTPUT_CLK_DIVBY4) {
|
||||
m = 4;
|
||||
|
|
@ -679,6 +679,16 @@ static long si5351_msynth_round_rate(struct clk_hw *hw, unsigned long rate,
|
|||
c = 1;
|
||||
|
||||
*parent_rate = a * rate;
|
||||
} else if (hwdata->num >= 6) {
|
||||
/* determine the closest integer divider */
|
||||
a = DIV_ROUND_CLOSEST(*parent_rate, rate);
|
||||
if (a < SI5351_MULTISYNTH_A_MIN)
|
||||
a = SI5351_MULTISYNTH_A_MIN;
|
||||
if (a > SI5351_MULTISYNTH67_A_MAX)
|
||||
a = SI5351_MULTISYNTH67_A_MAX;
|
||||
|
||||
b = 0;
|
||||
c = 1;
|
||||
} else {
|
||||
unsigned long rfrac, denom;
|
||||
|
||||
|
|
@ -692,9 +702,7 @@ static long si5351_msynth_round_rate(struct clk_hw *hw, unsigned long rate,
|
|||
a = *parent_rate / rate;
|
||||
if (a < SI5351_MULTISYNTH_A_MIN)
|
||||
a = SI5351_MULTISYNTH_A_MIN;
|
||||
if (hwdata->num >= 6 && a > SI5351_MULTISYNTH67_A_MAX)
|
||||
a = SI5351_MULTISYNTH67_A_MAX;
|
||||
else if (a > SI5351_MULTISYNTH_A_MAX)
|
||||
if (a > SI5351_MULTISYNTH_A_MAX)
|
||||
a = SI5351_MULTISYNTH_A_MAX;
|
||||
|
||||
/* find best approximation for b/c = fVCO mod fOUT */
|
||||
|
|
@ -723,6 +731,10 @@ static long si5351_msynth_round_rate(struct clk_hw *hw, unsigned long rate,
|
|||
hwdata->params.p3 = 1;
|
||||
hwdata->params.p2 = 0;
|
||||
hwdata->params.p1 = 0;
|
||||
} else if (hwdata->num >= 6) {
|
||||
hwdata->params.p3 = 0;
|
||||
hwdata->params.p2 = 0;
|
||||
hwdata->params.p1 = a;
|
||||
} else {
|
||||
hwdata->params.p3 = c;
|
||||
hwdata->params.p2 = (128 * b) % c;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,380 @@
|
|||
/*
|
||||
* Author: Daniel Thompson <daniel.thompson@linaro.org>
|
||||
*
|
||||
* Inspired by clk-asm9260.c .
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with
|
||||
* this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <linux/clk-provider.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_address.h>
|
||||
|
||||
#define STM32F4_RCC_PLLCFGR 0x04
|
||||
#define STM32F4_RCC_CFGR 0x08
|
||||
#define STM32F4_RCC_AHB1ENR 0x30
|
||||
#define STM32F4_RCC_AHB2ENR 0x34
|
||||
#define STM32F4_RCC_AHB3ENR 0x38
|
||||
#define STM32F4_RCC_APB1ENR 0x40
|
||||
#define STM32F4_RCC_APB2ENR 0x44
|
||||
|
||||
struct stm32f4_gate_data {
|
||||
u8 offset;
|
||||
u8 bit_idx;
|
||||
const char *name;
|
||||
const char *parent_name;
|
||||
unsigned long flags;
|
||||
};
|
||||
|
||||
static const struct stm32f4_gate_data stm32f4_gates[] __initconst = {
|
||||
{ STM32F4_RCC_AHB1ENR, 0, "gpioa", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 1, "gpiob", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 2, "gpioc", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 3, "gpiod", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 4, "gpioe", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 5, "gpiof", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 6, "gpiog", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 7, "gpioh", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 8, "gpioi", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 9, "gpioj", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 10, "gpiok", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 12, "crc", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 18, "bkpsra", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 20, "ccmdatam", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 21, "dma1", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 22, "dma2", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 23, "dma2d", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 25, "ethmac", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 26, "ethmactx", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 27, "ethmacrx", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 28, "ethmacptp", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 29, "otghs", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB1ENR, 30, "otghsulpi", "ahb_div" },
|
||||
|
||||
{ STM32F4_RCC_AHB2ENR, 0, "dcmi", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB2ENR, 4, "cryp", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB2ENR, 5, "hash", "ahb_div" },
|
||||
{ STM32F4_RCC_AHB2ENR, 6, "rng", "pll48" },
|
||||
{ STM32F4_RCC_AHB2ENR, 7, "otgfs", "pll48" },
|
||||
|
||||
{ STM32F4_RCC_AHB3ENR, 0, "fmc", "ahb_div",
|
||||
CLK_IGNORE_UNUSED },
|
||||
|
||||
{ STM32F4_RCC_APB1ENR, 0, "tim2", "apb1_mul" },
|
||||
{ STM32F4_RCC_APB1ENR, 1, "tim3", "apb1_mul" },
|
||||
{ STM32F4_RCC_APB1ENR, 2, "tim4", "apb1_mul" },
|
||||
{ STM32F4_RCC_APB1ENR, 3, "tim5", "apb1_mul" },
|
||||
{ STM32F4_RCC_APB1ENR, 4, "tim6", "apb1_mul" },
|
||||
{ STM32F4_RCC_APB1ENR, 5, "tim7", "apb1_mul" },
|
||||
{ STM32F4_RCC_APB1ENR, 6, "tim12", "apb1_mul" },
|
||||
{ STM32F4_RCC_APB1ENR, 7, "tim13", "apb1_mul" },
|
||||
{ STM32F4_RCC_APB1ENR, 8, "tim14", "apb1_mul" },
|
||||
{ STM32F4_RCC_APB1ENR, 11, "wwdg", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 14, "spi2", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 15, "spi3", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 17, "uart2", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 18, "uart3", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 19, "uart4", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 20, "uart5", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 21, "i2c1", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 22, "i2c2", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 23, "i2c3", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 25, "can1", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 26, "can2", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 28, "pwr", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 29, "dac", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 30, "uart7", "apb1_div" },
|
||||
{ STM32F4_RCC_APB1ENR, 31, "uart8", "apb1_div" },
|
||||
|
||||
{ STM32F4_RCC_APB2ENR, 0, "tim1", "apb2_mul" },
|
||||
{ STM32F4_RCC_APB2ENR, 1, "tim8", "apb2_mul" },
|
||||
{ STM32F4_RCC_APB2ENR, 4, "usart1", "apb2_div" },
|
||||
{ STM32F4_RCC_APB2ENR, 5, "usart6", "apb2_div" },
|
||||
{ STM32F4_RCC_APB2ENR, 8, "adc1", "apb2_div" },
|
||||
{ STM32F4_RCC_APB2ENR, 9, "adc2", "apb2_div" },
|
||||
{ STM32F4_RCC_APB2ENR, 10, "adc3", "apb2_div" },
|
||||
{ STM32F4_RCC_APB2ENR, 11, "sdio", "pll48" },
|
||||
{ STM32F4_RCC_APB2ENR, 12, "spi1", "apb2_div" },
|
||||
{ STM32F4_RCC_APB2ENR, 13, "spi4", "apb2_div" },
|
||||
{ STM32F4_RCC_APB2ENR, 14, "syscfg", "apb2_div" },
|
||||
{ STM32F4_RCC_APB2ENR, 16, "tim9", "apb2_mul" },
|
||||
{ STM32F4_RCC_APB2ENR, 17, "tim10", "apb2_mul" },
|
||||
{ STM32F4_RCC_APB2ENR, 18, "tim11", "apb2_mul" },
|
||||
{ STM32F4_RCC_APB2ENR, 20, "spi5", "apb2_div" },
|
||||
{ STM32F4_RCC_APB2ENR, 21, "spi6", "apb2_div" },
|
||||
{ STM32F4_RCC_APB2ENR, 22, "sai1", "apb2_div" },
|
||||
{ STM32F4_RCC_APB2ENR, 26, "ltdc", "apb2_div" },
|
||||
};
|
||||
|
||||
/*
|
||||
* MAX_CLKS is the maximum value in the enumeration below plus the combined
|
||||
* hweight of stm32f42xx_gate_map (plus one).
|
||||
*/
|
||||
#define MAX_CLKS 74
|
||||
|
||||
enum { SYSTICK, FCLK };
|
||||
|
||||
/*
|
||||
* This bitmask tells us which bit offsets (0..192) on STM32F4[23]xxx
|
||||
* have gate bits associated with them. Its combined hweight is 71.
|
||||
*/
|
||||
static const u64 stm32f42xx_gate_map[] = { 0x000000f17ef417ffull,
|
||||
0x0000000000000001ull,
|
||||
0x04777f33f6fec9ffull };
|
||||
|
||||
static struct clk *clks[MAX_CLKS];
|
||||
static DEFINE_SPINLOCK(stm32f4_clk_lock);
|
||||
static void __iomem *base;
|
||||
|
||||
/*
|
||||
* "Multiplier" device for APBx clocks.
|
||||
*
|
||||
* The APBx dividers are power-of-two dividers and, if *not* running in 1:1
|
||||
* mode, they also tap out the one of the low order state bits to run the
|
||||
* timers. ST datasheets represent this feature as a (conditional) clock
|
||||
* multiplier.
|
||||
*/
|
||||
struct clk_apb_mul {
|
||||
struct clk_hw hw;
|
||||
u8 bit_idx;
|
||||
};
|
||||
|
||||
#define to_clk_apb_mul(_hw) container_of(_hw, struct clk_apb_mul, hw)
|
||||
|
||||
static unsigned long clk_apb_mul_recalc_rate(struct clk_hw *hw,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct clk_apb_mul *am = to_clk_apb_mul(hw);
|
||||
|
||||
if (readl(base + STM32F4_RCC_CFGR) & BIT(am->bit_idx))
|
||||
return parent_rate * 2;
|
||||
|
||||
return parent_rate;
|
||||
}
|
||||
|
||||
static long clk_apb_mul_round_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long *prate)
|
||||
{
|
||||
struct clk_apb_mul *am = to_clk_apb_mul(hw);
|
||||
unsigned long mult = 1;
|
||||
|
||||
if (readl(base + STM32F4_RCC_CFGR) & BIT(am->bit_idx))
|
||||
mult = 2;
|
||||
|
||||
if (__clk_get_flags(hw->clk) & CLK_SET_RATE_PARENT) {
|
||||
unsigned long best_parent = rate / mult;
|
||||
|
||||
*prate =
|
||||
__clk_round_rate(__clk_get_parent(hw->clk), best_parent);
|
||||
}
|
||||
|
||||
return *prate * mult;
|
||||
}
|
||||
|
||||
static int clk_apb_mul_set_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
/*
|
||||
* We must report success but we can do so unconditionally because
|
||||
* clk_apb_mul_round_rate returns values that ensure this call is a
|
||||
* nop.
|
||||
*/
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct clk_ops clk_apb_mul_factor_ops = {
|
||||
.round_rate = clk_apb_mul_round_rate,
|
||||
.set_rate = clk_apb_mul_set_rate,
|
||||
.recalc_rate = clk_apb_mul_recalc_rate,
|
||||
};
|
||||
|
||||
static struct clk *clk_register_apb_mul(struct device *dev, const char *name,
|
||||
const char *parent_name,
|
||||
unsigned long flags, u8 bit_idx)
|
||||
{
|
||||
struct clk_apb_mul *am;
|
||||
struct clk_init_data init;
|
||||
struct clk *clk;
|
||||
|
||||
am = kzalloc(sizeof(*am), GFP_KERNEL);
|
||||
if (!am)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
am->bit_idx = bit_idx;
|
||||
am->hw.init = &init;
|
||||
|
||||
init.name = name;
|
||||
init.ops = &clk_apb_mul_factor_ops;
|
||||
init.flags = flags;
|
||||
init.parent_names = &parent_name;
|
||||
init.num_parents = 1;
|
||||
|
||||
clk = clk_register(dev, &am->hw);
|
||||
|
||||
if (IS_ERR(clk))
|
||||
kfree(am);
|
||||
|
||||
return clk;
|
||||
}
|
||||
|
||||
/*
|
||||
* Decode current PLL state and (statically) model the state we inherit from
|
||||
* the bootloader.
|
||||
*/
|
||||
static void stm32f4_rcc_register_pll(const char *hse_clk, const char *hsi_clk)
|
||||
{
|
||||
unsigned long pllcfgr = readl(base + STM32F4_RCC_PLLCFGR);
|
||||
|
||||
unsigned long pllm = pllcfgr & 0x3f;
|
||||
unsigned long plln = (pllcfgr >> 6) & 0x1ff;
|
||||
unsigned long pllp = BIT(((pllcfgr >> 16) & 3) + 1);
|
||||
const char *pllsrc = pllcfgr & BIT(22) ? hse_clk : hsi_clk;
|
||||
unsigned long pllq = (pllcfgr >> 24) & 0xf;
|
||||
|
||||
clk_register_fixed_factor(NULL, "vco", pllsrc, 0, plln, pllm);
|
||||
clk_register_fixed_factor(NULL, "pll", "vco", 0, 1, pllp);
|
||||
clk_register_fixed_factor(NULL, "pll48", "vco", 0, 1, pllq);
|
||||
}
|
||||
|
||||
/*
|
||||
* Converts the primary and secondary indices (as they appear in DT) to an
|
||||
* offset into our struct clock array.
|
||||
*/
|
||||
static int stm32f4_rcc_lookup_clk_idx(u8 primary, u8 secondary)
|
||||
{
|
||||
u64 table[ARRAY_SIZE(stm32f42xx_gate_map)];
|
||||
|
||||
if (primary == 1) {
|
||||
if (WARN_ON(secondary > FCLK))
|
||||
return -EINVAL;
|
||||
return secondary;
|
||||
}
|
||||
|
||||
memcpy(table, stm32f42xx_gate_map, sizeof(table));
|
||||
|
||||
/* only bits set in table can be used as indices */
|
||||
if (WARN_ON(secondary > 8 * sizeof(table) ||
|
||||
0 == (table[BIT_ULL_WORD(secondary)] &
|
||||
BIT_ULL_MASK(secondary))))
|
||||
return -EINVAL;
|
||||
|
||||
/* mask out bits above our current index */
|
||||
table[BIT_ULL_WORD(secondary)] &=
|
||||
GENMASK_ULL(secondary % BITS_PER_LONG_LONG, 0);
|
||||
|
||||
return FCLK + hweight64(table[0]) +
|
||||
(BIT_ULL_WORD(secondary) >= 1 ? hweight64(table[1]) : 0) +
|
||||
(BIT_ULL_WORD(secondary) >= 2 ? hweight64(table[2]) : 0);
|
||||
}
|
||||
|
||||
static struct clk *
|
||||
stm32f4_rcc_lookup_clk(struct of_phandle_args *clkspec, void *data)
|
||||
{
|
||||
int i = stm32f4_rcc_lookup_clk_idx(clkspec->args[0], clkspec->args[1]);
|
||||
|
||||
if (i < 0)
|
||||
return ERR_PTR(-EINVAL);
|
||||
|
||||
return clks[i];
|
||||
}
|
||||
|
||||
static const char *sys_parents[] __initdata = { "hsi", NULL, "pll" };
|
||||
|
||||
static const struct clk_div_table ahb_div_table[] = {
|
||||
{ 0x0, 1 }, { 0x1, 1 }, { 0x2, 1 }, { 0x3, 1 },
|
||||
{ 0x4, 1 }, { 0x5, 1 }, { 0x6, 1 }, { 0x7, 1 },
|
||||
{ 0x8, 2 }, { 0x9, 4 }, { 0xa, 8 }, { 0xb, 16 },
|
||||
{ 0xc, 64 }, { 0xd, 128 }, { 0xe, 256 }, { 0xf, 512 },
|
||||
{ 0 },
|
||||
};
|
||||
|
||||
static const struct clk_div_table apb_div_table[] = {
|
||||
{ 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
|
||||
{ 4, 2 }, { 5, 4 }, { 6, 8 }, { 7, 16 },
|
||||
{ 0 },
|
||||
};
|
||||
|
||||
static void __init stm32f4_rcc_init(struct device_node *np)
|
||||
{
|
||||
const char *hse_clk;
|
||||
int n;
|
||||
|
||||
base = of_iomap(np, 0);
|
||||
if (!base) {
|
||||
pr_err("%s: unable to map resource", np->name);
|
||||
return;
|
||||
}
|
||||
|
||||
hse_clk = of_clk_get_parent_name(np, 0);
|
||||
|
||||
clk_register_fixed_rate_with_accuracy(NULL, "hsi", NULL, 0,
|
||||
16000000, 160000);
|
||||
stm32f4_rcc_register_pll(hse_clk, "hsi");
|
||||
|
||||
sys_parents[1] = hse_clk;
|
||||
clk_register_mux_table(
|
||||
NULL, "sys", sys_parents, ARRAY_SIZE(sys_parents), 0,
|
||||
base + STM32F4_RCC_CFGR, 0, 3, 0, NULL, &stm32f4_clk_lock);
|
||||
|
||||
clk_register_divider_table(NULL, "ahb_div", "sys",
|
||||
CLK_SET_RATE_PARENT, base + STM32F4_RCC_CFGR,
|
||||
4, 4, 0, ahb_div_table, &stm32f4_clk_lock);
|
||||
|
||||
clk_register_divider_table(NULL, "apb1_div", "ahb_div",
|
||||
CLK_SET_RATE_PARENT, base + STM32F4_RCC_CFGR,
|
||||
10, 3, 0, apb_div_table, &stm32f4_clk_lock);
|
||||
clk_register_apb_mul(NULL, "apb1_mul", "apb1_div",
|
||||
CLK_SET_RATE_PARENT, 12);
|
||||
|
||||
clk_register_divider_table(NULL, "apb2_div", "ahb_div",
|
||||
CLK_SET_RATE_PARENT, base + STM32F4_RCC_CFGR,
|
||||
13, 3, 0, apb_div_table, &stm32f4_clk_lock);
|
||||
clk_register_apb_mul(NULL, "apb2_mul", "apb2_div",
|
||||
CLK_SET_RATE_PARENT, 15);
|
||||
|
||||
clks[SYSTICK] = clk_register_fixed_factor(NULL, "systick", "ahb_div",
|
||||
0, 1, 8);
|
||||
clks[FCLK] = clk_register_fixed_factor(NULL, "fclk", "ahb_div",
|
||||
0, 1, 1);
|
||||
|
||||
for (n = 0; n < ARRAY_SIZE(stm32f4_gates); n++) {
|
||||
const struct stm32f4_gate_data *gd = &stm32f4_gates[n];
|
||||
unsigned int secondary =
|
||||
8 * (gd->offset - STM32F4_RCC_AHB1ENR) + gd->bit_idx;
|
||||
int idx = stm32f4_rcc_lookup_clk_idx(0, secondary);
|
||||
|
||||
if (idx < 0)
|
||||
goto fail;
|
||||
|
||||
clks[idx] = clk_register_gate(
|
||||
NULL, gd->name, gd->parent_name, gd->flags,
|
||||
base + gd->offset, gd->bit_idx, 0, &stm32f4_clk_lock);
|
||||
|
||||
if (IS_ERR(clks[n])) {
|
||||
pr_err("%s: Unable to register leaf clock %s\n",
|
||||
np->full_name, gd->name);
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
of_clk_add_provider(np, stm32f4_rcc_lookup_clk, NULL);
|
||||
return;
|
||||
fail:
|
||||
iounmap(base);
|
||||
}
|
||||
CLK_OF_DECLARE(stm32f4_rcc, "st,stm32f42xx-rcc", stm32f4_rcc_init);
|
||||
|
|
@ -12,6 +12,7 @@
|
|||
#include <linux/clk-provider.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/platform_data/clk-u300.h>
|
||||
|
||||
/* APP side SYSCON registers */
|
||||
/* CLK Control Register 16bit (R/W) */
|
||||
|
|
|
|||
|
|
@ -42,12 +42,12 @@
|
|||
|
||||
static DEFINE_SPINLOCK(clk_lock);
|
||||
|
||||
static inline u32 xgene_clk_read(void *csr)
|
||||
static inline u32 xgene_clk_read(void __iomem *csr)
|
||||
{
|
||||
return readl_relaxed(csr);
|
||||
}
|
||||
|
||||
static inline void xgene_clk_write(u32 data, void *csr)
|
||||
static inline void xgene_clk_write(u32 data, void __iomem *csr)
|
||||
{
|
||||
return writel_relaxed(data, csr);
|
||||
}
|
||||
|
|
@ -119,7 +119,7 @@ static unsigned long xgene_clk_pll_recalc_rate(struct clk_hw *hw,
|
|||
return fvco / nout;
|
||||
}
|
||||
|
||||
const struct clk_ops xgene_clk_pll_ops = {
|
||||
static const struct clk_ops xgene_clk_pll_ops = {
|
||||
.is_enabled = xgene_clk_pll_is_enabled,
|
||||
.recalc_rate = xgene_clk_pll_recalc_rate,
|
||||
};
|
||||
|
|
@ -167,7 +167,7 @@ static void xgene_pllclk_init(struct device_node *np, enum xgene_pll_type pll_ty
|
|||
{
|
||||
const char *clk_name = np->full_name;
|
||||
struct clk *clk;
|
||||
void *reg;
|
||||
void __iomem *reg;
|
||||
|
||||
reg = of_iomap(np, 0);
|
||||
if (reg == NULL) {
|
||||
|
|
@ -222,20 +222,22 @@ static int xgene_clk_enable(struct clk_hw *hw)
|
|||
struct xgene_clk *pclk = to_xgene_clk(hw);
|
||||
unsigned long flags = 0;
|
||||
u32 data;
|
||||
phys_addr_t reg;
|
||||
|
||||
if (pclk->lock)
|
||||
spin_lock_irqsave(pclk->lock, flags);
|
||||
|
||||
if (pclk->param.csr_reg != NULL) {
|
||||
pr_debug("%s clock enabled\n", pclk->name);
|
||||
reg = __pa(pclk->param.csr_reg);
|
||||
/* First enable the clock */
|
||||
data = xgene_clk_read(pclk->param.csr_reg +
|
||||
pclk->param.reg_clk_offset);
|
||||
data |= pclk->param.reg_clk_mask;
|
||||
xgene_clk_write(data, pclk->param.csr_reg +
|
||||
pclk->param.reg_clk_offset);
|
||||
pr_debug("%s clock PADDR base 0x%016LX clk offset 0x%08X mask 0x%08X value 0x%08X\n",
|
||||
pclk->name, __pa(pclk->param.csr_reg),
|
||||
pr_debug("%s clock PADDR base %pa clk offset 0x%08X mask 0x%08X value 0x%08X\n",
|
||||
pclk->name, ®,
|
||||
pclk->param.reg_clk_offset, pclk->param.reg_clk_mask,
|
||||
data);
|
||||
|
||||
|
|
@ -245,8 +247,8 @@ static int xgene_clk_enable(struct clk_hw *hw)
|
|||
data &= ~pclk->param.reg_csr_mask;
|
||||
xgene_clk_write(data, pclk->param.csr_reg +
|
||||
pclk->param.reg_csr_offset);
|
||||
pr_debug("%s CSR RESET PADDR base 0x%016LX csr offset 0x%08X mask 0x%08X value 0x%08X\n",
|
||||
pclk->name, __pa(pclk->param.csr_reg),
|
||||
pr_debug("%s CSR RESET PADDR base %pa csr offset 0x%08X mask 0x%08X value 0x%08X\n",
|
||||
pclk->name, ®,
|
||||
pclk->param.reg_csr_offset, pclk->param.reg_csr_mask,
|
||||
data);
|
||||
}
|
||||
|
|
@ -386,7 +388,7 @@ static long xgene_clk_round_rate(struct clk_hw *hw, unsigned long rate,
|
|||
return parent_rate / divider;
|
||||
}
|
||||
|
||||
const struct clk_ops xgene_clk_ops = {
|
||||
static const struct clk_ops xgene_clk_ops = {
|
||||
.enable = xgene_clk_enable,
|
||||
.disable = xgene_clk_disable,
|
||||
.is_enabled = xgene_clk_is_enabled,
|
||||
|
|
@ -456,7 +458,7 @@ static void __init xgene_devclk_init(struct device_node *np)
|
|||
parameters.csr_reg = NULL;
|
||||
parameters.divider_reg = NULL;
|
||||
for (i = 0; i < 2; i++) {
|
||||
void *map_res;
|
||||
void __iomem *map_res;
|
||||
rc = of_address_to_resource(np, i, &res);
|
||||
if (rc != 0) {
|
||||
if (i == 0) {
|
||||
|
|
|
|||
1694
drivers/clk/clk.c
1694
drivers/clk/clk.c
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,6 @@
|
|||
config COMMON_CLK_HI6220
|
||||
bool "Hi6220 Clock Driver"
|
||||
depends on ARCH_HISI || COMPILE_TEST
|
||||
default ARCH_HISI
|
||||
help
|
||||
Build the Hisilicon Hi6220 clock driver based on the common clock framework.
|
||||
|
|
@ -2,8 +2,9 @@
|
|||
# Hisilicon Clock specific Makefile
|
||||
#
|
||||
|
||||
obj-y += clk.o clkgate-separated.o
|
||||
obj-y += clk.o clkgate-separated.o clkdivider-hi6220.o
|
||||
|
||||
obj-$(CONFIG_ARCH_HI3xxx) += clk-hi3620.o
|
||||
obj-$(CONFIG_ARCH_HIP04) += clk-hip04.o
|
||||
obj-$(CONFIG_ARCH_HIX5HD2) += clk-hix5hd2.o
|
||||
obj-$(CONFIG_COMMON_CLK_HI6220) += clk-hi6220.o
|
||||
|
|
|
|||
|
|
@ -38,44 +38,44 @@
|
|||
#include "clk.h"
|
||||
|
||||
/* clock parent list */
|
||||
static const char *timer0_mux_p[] __initdata = { "osc32k", "timerclk01", };
|
||||
static const char *timer1_mux_p[] __initdata = { "osc32k", "timerclk01", };
|
||||
static const char *timer2_mux_p[] __initdata = { "osc32k", "timerclk23", };
|
||||
static const char *timer3_mux_p[] __initdata = { "osc32k", "timerclk23", };
|
||||
static const char *timer4_mux_p[] __initdata = { "osc32k", "timerclk45", };
|
||||
static const char *timer5_mux_p[] __initdata = { "osc32k", "timerclk45", };
|
||||
static const char *timer6_mux_p[] __initdata = { "osc32k", "timerclk67", };
|
||||
static const char *timer7_mux_p[] __initdata = { "osc32k", "timerclk67", };
|
||||
static const char *timer8_mux_p[] __initdata = { "osc32k", "timerclk89", };
|
||||
static const char *timer9_mux_p[] __initdata = { "osc32k", "timerclk89", };
|
||||
static const char *uart0_mux_p[] __initdata = { "osc26m", "pclk", };
|
||||
static const char *uart1_mux_p[] __initdata = { "osc26m", "pclk", };
|
||||
static const char *uart2_mux_p[] __initdata = { "osc26m", "pclk", };
|
||||
static const char *uart3_mux_p[] __initdata = { "osc26m", "pclk", };
|
||||
static const char *uart4_mux_p[] __initdata = { "osc26m", "pclk", };
|
||||
static const char *spi0_mux_p[] __initdata = { "osc26m", "rclk_cfgaxi", };
|
||||
static const char *spi1_mux_p[] __initdata = { "osc26m", "rclk_cfgaxi", };
|
||||
static const char *spi2_mux_p[] __initdata = { "osc26m", "rclk_cfgaxi", };
|
||||
static const char *const timer0_mux_p[] __initconst = { "osc32k", "timerclk01", };
|
||||
static const char *const timer1_mux_p[] __initconst = { "osc32k", "timerclk01", };
|
||||
static const char *const timer2_mux_p[] __initconst = { "osc32k", "timerclk23", };
|
||||
static const char *const timer3_mux_p[] __initconst = { "osc32k", "timerclk23", };
|
||||
static const char *const timer4_mux_p[] __initconst = { "osc32k", "timerclk45", };
|
||||
static const char *const timer5_mux_p[] __initconst = { "osc32k", "timerclk45", };
|
||||
static const char *const timer6_mux_p[] __initconst = { "osc32k", "timerclk67", };
|
||||
static const char *const timer7_mux_p[] __initconst = { "osc32k", "timerclk67", };
|
||||
static const char *const timer8_mux_p[] __initconst = { "osc32k", "timerclk89", };
|
||||
static const char *const timer9_mux_p[] __initconst = { "osc32k", "timerclk89", };
|
||||
static const char *const uart0_mux_p[] __initconst = { "osc26m", "pclk", };
|
||||
static const char *const uart1_mux_p[] __initconst = { "osc26m", "pclk", };
|
||||
static const char *const uart2_mux_p[] __initconst = { "osc26m", "pclk", };
|
||||
static const char *const uart3_mux_p[] __initconst = { "osc26m", "pclk", };
|
||||
static const char *const uart4_mux_p[] __initconst = { "osc26m", "pclk", };
|
||||
static const char *const spi0_mux_p[] __initconst = { "osc26m", "rclk_cfgaxi", };
|
||||
static const char *const spi1_mux_p[] __initconst = { "osc26m", "rclk_cfgaxi", };
|
||||
static const char *const spi2_mux_p[] __initconst = { "osc26m", "rclk_cfgaxi", };
|
||||
/* share axi parent */
|
||||
static const char *saxi_mux_p[] __initdata = { "armpll3", "armpll2", };
|
||||
static const char *pwm0_mux_p[] __initdata = { "osc32k", "osc26m", };
|
||||
static const char *pwm1_mux_p[] __initdata = { "osc32k", "osc26m", };
|
||||
static const char *sd_mux_p[] __initdata = { "armpll2", "armpll3", };
|
||||
static const char *mmc1_mux_p[] __initdata = { "armpll2", "armpll3", };
|
||||
static const char *mmc1_mux2_p[] __initdata = { "osc26m", "mmc1_div", };
|
||||
static const char *g2d_mux_p[] __initdata = { "armpll2", "armpll3", };
|
||||
static const char *venc_mux_p[] __initdata = { "armpll2", "armpll3", };
|
||||
static const char *vdec_mux_p[] __initdata = { "armpll2", "armpll3", };
|
||||
static const char *vpp_mux_p[] __initdata = { "armpll2", "armpll3", };
|
||||
static const char *edc0_mux_p[] __initdata = { "armpll2", "armpll3", };
|
||||
static const char *ldi0_mux_p[] __initdata = { "armpll2", "armpll4",
|
||||
static const char *const saxi_mux_p[] __initconst = { "armpll3", "armpll2", };
|
||||
static const char *const pwm0_mux_p[] __initconst = { "osc32k", "osc26m", };
|
||||
static const char *const pwm1_mux_p[] __initconst = { "osc32k", "osc26m", };
|
||||
static const char *const sd_mux_p[] __initconst = { "armpll2", "armpll3", };
|
||||
static const char *const mmc1_mux_p[] __initconst = { "armpll2", "armpll3", };
|
||||
static const char *const mmc1_mux2_p[] __initconst = { "osc26m", "mmc1_div", };
|
||||
static const char *const g2d_mux_p[] __initconst = { "armpll2", "armpll3", };
|
||||
static const char *const venc_mux_p[] __initconst = { "armpll2", "armpll3", };
|
||||
static const char *const vdec_mux_p[] __initconst = { "armpll2", "armpll3", };
|
||||
static const char *const vpp_mux_p[] __initconst = { "armpll2", "armpll3", };
|
||||
static const char *const edc0_mux_p[] __initconst = { "armpll2", "armpll3", };
|
||||
static const char *const ldi0_mux_p[] __initconst = { "armpll2", "armpll4",
|
||||
"armpll3", "armpll5", };
|
||||
static const char *edc1_mux_p[] __initdata = { "armpll2", "armpll3", };
|
||||
static const char *ldi1_mux_p[] __initdata = { "armpll2", "armpll4",
|
||||
static const char *const edc1_mux_p[] __initconst = { "armpll2", "armpll3", };
|
||||
static const char *const ldi1_mux_p[] __initconst = { "armpll2", "armpll4",
|
||||
"armpll3", "armpll5", };
|
||||
static const char *rclk_hsic_p[] __initdata = { "armpll3", "armpll2", };
|
||||
static const char *mmc2_mux_p[] __initdata = { "armpll2", "armpll3", };
|
||||
static const char *mmc3_mux_p[] __initdata = { "armpll2", "armpll3", };
|
||||
static const char *const rclk_hsic_p[] __initconst = { "armpll3", "armpll2", };
|
||||
static const char *const mmc2_mux_p[] __initconst = { "armpll2", "armpll3", };
|
||||
static const char *const mmc3_mux_p[] __initconst = { "armpll2", "armpll3", };
|
||||
|
||||
|
||||
/* fixed rate clocks */
|
||||
|
|
|
|||
|
|
@ -0,0 +1,284 @@
|
|||
/*
|
||||
* Hisilicon Hi6220 clock driver
|
||||
*
|
||||
* Copyright (c) 2015 Hisilicon Limited.
|
||||
*
|
||||
* Author: Bintian Wang <bintian.wang@huawei.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/clk-provider.h>
|
||||
#include <linux/clkdev.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_address.h>
|
||||
#include <linux/of_device.h>
|
||||
#include <linux/slab.h>
|
||||
|
||||
#include <dt-bindings/clock/hi6220-clock.h>
|
||||
|
||||
#include "clk.h"
|
||||
|
||||
|
||||
/* clocks in AO (always on) controller */
|
||||
static struct hisi_fixed_rate_clock hi6220_fixed_rate_clks[] __initdata = {
|
||||
{ HI6220_REF32K, "ref32k", NULL, CLK_IS_ROOT, 32764, },
|
||||
{ HI6220_CLK_TCXO, "clk_tcxo", NULL, CLK_IS_ROOT, 19200000, },
|
||||
{ HI6220_MMC1_PAD, "mmc1_pad", NULL, CLK_IS_ROOT, 100000000, },
|
||||
{ HI6220_MMC2_PAD, "mmc2_pad", NULL, CLK_IS_ROOT, 100000000, },
|
||||
{ HI6220_MMC0_PAD, "mmc0_pad", NULL, CLK_IS_ROOT, 200000000, },
|
||||
{ HI6220_PLL_BBP, "bbppll0", NULL, CLK_IS_ROOT, 245760000, },
|
||||
{ HI6220_PLL_GPU, "gpupll", NULL, CLK_IS_ROOT, 1000000000,},
|
||||
{ HI6220_PLL1_DDR, "ddrpll1", NULL, CLK_IS_ROOT, 1066000000,},
|
||||
{ HI6220_PLL_SYS, "syspll", NULL, CLK_IS_ROOT, 1200000000,},
|
||||
{ HI6220_PLL_SYS_MEDIA, "media_syspll", NULL, CLK_IS_ROOT, 1200000000,},
|
||||
{ HI6220_DDR_SRC, "ddr_sel_src", NULL, CLK_IS_ROOT, 1200000000,},
|
||||
{ HI6220_PLL_MEDIA, "media_pll", NULL, CLK_IS_ROOT, 1440000000,},
|
||||
{ HI6220_PLL_DDR, "ddrpll0", NULL, CLK_IS_ROOT, 1600000000,},
|
||||
};
|
||||
|
||||
static struct hisi_fixed_factor_clock hi6220_fixed_factor_clks[] __initdata = {
|
||||
{ HI6220_300M, "clk_300m", "syspll", 1, 4, 0, },
|
||||
{ HI6220_150M, "clk_150m", "clk_300m", 1, 2, 0, },
|
||||
{ HI6220_PICOPHY_SRC, "picophy_src", "clk_150m", 1, 4, 0, },
|
||||
{ HI6220_MMC0_SRC_SEL, "mmc0srcsel", "mmc0_sel", 1, 8, 0, },
|
||||
{ HI6220_MMC1_SRC_SEL, "mmc1srcsel", "mmc1_sel", 1, 8, 0, },
|
||||
{ HI6220_MMC2_SRC_SEL, "mmc2srcsel", "mmc2_sel", 1, 8, 0, },
|
||||
{ HI6220_VPU_CODEC, "vpucodec", "codec_jpeg_aclk", 1, 2, 0, },
|
||||
{ HI6220_MMC0_SMP, "mmc0_sample", "mmc0_sel", 1, 8, 0, },
|
||||
{ HI6220_MMC1_SMP, "mmc1_sample", "mmc1_sel", 1, 8, 0, },
|
||||
{ HI6220_MMC2_SMP, "mmc2_sample", "mmc2_sel", 1, 8, 0, },
|
||||
};
|
||||
|
||||
static struct hisi_gate_clock hi6220_separated_gate_clks_ao[] __initdata = {
|
||||
{ HI6220_WDT0_PCLK, "wdt0_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x630, 12, 0, },
|
||||
{ HI6220_WDT1_PCLK, "wdt1_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x630, 13, 0, },
|
||||
{ HI6220_WDT2_PCLK, "wdt2_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x630, 14, 0, },
|
||||
{ HI6220_TIMER0_PCLK, "timer0_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x630, 15, 0, },
|
||||
{ HI6220_TIMER1_PCLK, "timer1_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x630, 16, 0, },
|
||||
{ HI6220_TIMER2_PCLK, "timer2_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x630, 17, 0, },
|
||||
{ HI6220_TIMER3_PCLK, "timer3_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x630, 18, 0, },
|
||||
{ HI6220_TIMER4_PCLK, "timer4_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x630, 19, 0, },
|
||||
{ HI6220_TIMER5_PCLK, "timer5_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x630, 20, 0, },
|
||||
{ HI6220_TIMER6_PCLK, "timer6_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x630, 21, 0, },
|
||||
{ HI6220_TIMER7_PCLK, "timer7_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x630, 22, 0, },
|
||||
{ HI6220_TIMER8_PCLK, "timer8_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x630, 23, 0, },
|
||||
{ HI6220_UART0_PCLK, "uart0_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x630, 24, 0, },
|
||||
};
|
||||
|
||||
static void __init hi6220_clk_ao_init(struct device_node *np)
|
||||
{
|
||||
struct hisi_clock_data *clk_data_ao;
|
||||
|
||||
clk_data_ao = hisi_clk_init(np, HI6220_AO_NR_CLKS);
|
||||
if (!clk_data_ao)
|
||||
return;
|
||||
|
||||
hisi_clk_register_fixed_rate(hi6220_fixed_rate_clks,
|
||||
ARRAY_SIZE(hi6220_fixed_rate_clks), clk_data_ao);
|
||||
|
||||
hisi_clk_register_fixed_factor(hi6220_fixed_factor_clks,
|
||||
ARRAY_SIZE(hi6220_fixed_factor_clks), clk_data_ao);
|
||||
|
||||
hisi_clk_register_gate_sep(hi6220_separated_gate_clks_ao,
|
||||
ARRAY_SIZE(hi6220_separated_gate_clks_ao), clk_data_ao);
|
||||
}
|
||||
CLK_OF_DECLARE(hi6220_clk_ao, "hisilicon,hi6220-aoctrl", hi6220_clk_ao_init);
|
||||
|
||||
|
||||
/* clocks in sysctrl */
|
||||
static const char *mmc0_mux0_p[] __initdata = { "pll_ddr_gate", "syspll", };
|
||||
static const char *mmc0_mux1_p[] __initdata = { "mmc0_mux0", "pll_media_gate", };
|
||||
static const char *mmc0_src_p[] __initdata = { "mmc0srcsel", "mmc0_div", };
|
||||
static const char *mmc1_mux0_p[] __initdata = { "pll_ddr_gate", "syspll", };
|
||||
static const char *mmc1_mux1_p[] __initdata = { "mmc1_mux0", "pll_media_gate", };
|
||||
static const char *mmc1_src_p[] __initdata = { "mmc1srcsel", "mmc1_div", };
|
||||
static const char *mmc2_mux0_p[] __initdata = { "pll_ddr_gate", "syspll", };
|
||||
static const char *mmc2_mux1_p[] __initdata = { "mmc2_mux0", "pll_media_gate", };
|
||||
static const char *mmc2_src_p[] __initdata = { "mmc2srcsel", "mmc2_div", };
|
||||
static const char *mmc0_sample_in[] __initdata = { "mmc0_sample", "mmc0_pad", };
|
||||
static const char *mmc1_sample_in[] __initdata = { "mmc1_sample", "mmc1_pad", };
|
||||
static const char *mmc2_sample_in[] __initdata = { "mmc2_sample", "mmc2_pad", };
|
||||
static const char *uart1_src[] __initdata = { "clk_tcxo", "clk_150m", };
|
||||
static const char *uart2_src[] __initdata = { "clk_tcxo", "clk_150m", };
|
||||
static const char *uart3_src[] __initdata = { "clk_tcxo", "clk_150m", };
|
||||
static const char *uart4_src[] __initdata = { "clk_tcxo", "clk_150m", };
|
||||
static const char *hifi_src[] __initdata = { "syspll", "pll_media_gate", };
|
||||
|
||||
static struct hisi_gate_clock hi6220_separated_gate_clks_sys[] __initdata = {
|
||||
{ HI6220_MMC0_CLK, "mmc0_clk", "mmc0_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x200, 0, 0, },
|
||||
{ HI6220_MMC0_CIUCLK, "mmc0_ciuclk", "mmc0_smp_in", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x200, 0, 0, },
|
||||
{ HI6220_MMC1_CLK, "mmc1_clk", "mmc1_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x200, 1, 0, },
|
||||
{ HI6220_MMC1_CIUCLK, "mmc1_ciuclk", "mmc1_smp_in", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x200, 1, 0, },
|
||||
{ HI6220_MMC2_CLK, "mmc2_clk", "mmc2_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x200, 2, 0, },
|
||||
{ HI6220_MMC2_CIUCLK, "mmc2_ciuclk", "mmc2_smp_in", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x200, 2, 0, },
|
||||
{ HI6220_USBOTG_HCLK, "usbotg_hclk", "clk_bus", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x200, 4, 0, },
|
||||
{ HI6220_CLK_PICOPHY, "clk_picophy", "cs_dapb", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x200, 5, 0, },
|
||||
{ HI6220_HIFI, "hifi_clk", "hifi_div", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x210, 0, 0, },
|
||||
{ HI6220_DACODEC_PCLK, "dacodec_pclk", "clk_bus", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x210, 5, 0, },
|
||||
{ HI6220_EDMAC_ACLK, "edmac_aclk", "clk_bus", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x220, 2, 0, },
|
||||
{ HI6220_CS_ATB, "cs_atb", "cs_atb_div", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x230, 0, 0, },
|
||||
{ HI6220_I2C0_CLK, "i2c0_clk", "clk_150m", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x230, 1, 0, },
|
||||
{ HI6220_I2C1_CLK, "i2c1_clk", "clk_150m", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x230, 2, 0, },
|
||||
{ HI6220_I2C2_CLK, "i2c2_clk", "clk_150m", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x230, 3, 0, },
|
||||
{ HI6220_I2C3_CLK, "i2c3_clk", "clk_150m", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x230, 4, 0, },
|
||||
{ HI6220_UART1_PCLK, "uart1_pclk", "uart1_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x230, 5, 0, },
|
||||
{ HI6220_UART2_PCLK, "uart2_pclk", "uart2_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x230, 6, 0, },
|
||||
{ HI6220_UART3_PCLK, "uart3_pclk", "uart3_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x230, 7, 0, },
|
||||
{ HI6220_UART4_PCLK, "uart4_pclk", "uart4_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x230, 8, 0, },
|
||||
{ HI6220_SPI_CLK, "spi_clk", "clk_150m", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x230, 9, 0, },
|
||||
{ HI6220_TSENSOR_CLK, "tsensor_clk", "clk_bus", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x230, 12, 0, },
|
||||
{ HI6220_MMU_CLK, "mmu_clk", "ddrc_axi1", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x240, 11, 0, },
|
||||
{ HI6220_HIFI_SEL, "hifi_sel", "hifi_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x270, 0, 0, },
|
||||
{ HI6220_MMC0_SYSPLL, "mmc0_syspll", "syspll", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x270, 1, 0, },
|
||||
{ HI6220_MMC1_SYSPLL, "mmc1_syspll", "syspll", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x270, 2, 0, },
|
||||
{ HI6220_MMC2_SYSPLL, "mmc2_syspll", "syspll", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x270, 3, 0, },
|
||||
{ HI6220_MMC0_SEL, "mmc0_sel", "mmc0_mux1", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x270, 6, 0, },
|
||||
{ HI6220_MMC1_SEL, "mmc1_sel", "mmc1_mux1", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x270, 7, 0, },
|
||||
{ HI6220_BBPPLL_SEL, "bbppll_sel", "pll0_bbp_gate", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x270, 9, 0, },
|
||||
{ HI6220_MEDIA_PLL_SRC, "media_pll_src", "pll_media_gate", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x270, 10, 0, },
|
||||
{ HI6220_MMC2_SEL, "mmc2_sel", "mmc2_mux1", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x270, 11, 0, },
|
||||
{ HI6220_CS_ATB_SYSPLL, "cs_atb_syspll", "syspll", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x270, 12, 0, },
|
||||
};
|
||||
|
||||
static struct hisi_mux_clock hi6220_mux_clks_sys[] __initdata = {
|
||||
{ HI6220_MMC0_SRC, "mmc0_src", mmc0_src_p, ARRAY_SIZE(mmc0_src_p), CLK_SET_RATE_PARENT, 0x4, 0, 1, 0, },
|
||||
{ HI6220_MMC0_SMP_IN, "mmc0_smp_in", mmc0_sample_in, ARRAY_SIZE(mmc0_sample_in), CLK_SET_RATE_PARENT, 0x4, 0, 1, 0, },
|
||||
{ HI6220_MMC1_SRC, "mmc1_src", mmc1_src_p, ARRAY_SIZE(mmc1_src_p), CLK_SET_RATE_PARENT, 0x4, 2, 1, 0, },
|
||||
{ HI6220_MMC1_SMP_IN, "mmc1_smp_in", mmc1_sample_in, ARRAY_SIZE(mmc1_sample_in), CLK_SET_RATE_PARENT, 0x4, 2, 1, 0, },
|
||||
{ HI6220_MMC2_SRC, "mmc2_src", mmc2_src_p, ARRAY_SIZE(mmc2_src_p), CLK_SET_RATE_PARENT, 0x4, 4, 1, 0, },
|
||||
{ HI6220_MMC2_SMP_IN, "mmc2_smp_in", mmc2_sample_in, ARRAY_SIZE(mmc2_sample_in), CLK_SET_RATE_PARENT, 0x4, 4, 1, 0, },
|
||||
{ HI6220_HIFI_SRC, "hifi_src", hifi_src, ARRAY_SIZE(hifi_src), CLK_SET_RATE_PARENT, 0x400, 0, 1, CLK_MUX_HIWORD_MASK,},
|
||||
{ HI6220_UART1_SRC, "uart1_src", uart1_src, ARRAY_SIZE(uart1_src), CLK_SET_RATE_PARENT, 0x400, 1, 1, CLK_MUX_HIWORD_MASK,},
|
||||
{ HI6220_UART2_SRC, "uart2_src", uart2_src, ARRAY_SIZE(uart2_src), CLK_SET_RATE_PARENT, 0x400, 2, 1, CLK_MUX_HIWORD_MASK,},
|
||||
{ HI6220_UART3_SRC, "uart3_src", uart3_src, ARRAY_SIZE(uart3_src), CLK_SET_RATE_PARENT, 0x400, 3, 1, CLK_MUX_HIWORD_MASK,},
|
||||
{ HI6220_UART4_SRC, "uart4_src", uart4_src, ARRAY_SIZE(uart4_src), CLK_SET_RATE_PARENT, 0x400, 4, 1, CLK_MUX_HIWORD_MASK,},
|
||||
{ HI6220_MMC0_MUX0, "mmc0_mux0", mmc0_mux0_p, ARRAY_SIZE(mmc0_mux0_p), CLK_SET_RATE_PARENT, 0x400, 5, 1, CLK_MUX_HIWORD_MASK,},
|
||||
{ HI6220_MMC1_MUX0, "mmc1_mux0", mmc1_mux0_p, ARRAY_SIZE(mmc1_mux0_p), CLK_SET_RATE_PARENT, 0x400, 11, 1, CLK_MUX_HIWORD_MASK,},
|
||||
{ HI6220_MMC2_MUX0, "mmc2_mux0", mmc2_mux0_p, ARRAY_SIZE(mmc2_mux0_p), CLK_SET_RATE_PARENT, 0x400, 12, 1, CLK_MUX_HIWORD_MASK,},
|
||||
{ HI6220_MMC0_MUX1, "mmc0_mux1", mmc0_mux1_p, ARRAY_SIZE(mmc0_mux1_p), CLK_SET_RATE_PARENT, 0x400, 13, 1, CLK_MUX_HIWORD_MASK,},
|
||||
{ HI6220_MMC1_MUX1, "mmc1_mux1", mmc1_mux1_p, ARRAY_SIZE(mmc1_mux1_p), CLK_SET_RATE_PARENT, 0x400, 14, 1, CLK_MUX_HIWORD_MASK,},
|
||||
{ HI6220_MMC2_MUX1, "mmc2_mux1", mmc2_mux1_p, ARRAY_SIZE(mmc2_mux1_p), CLK_SET_RATE_PARENT, 0x400, 15, 1, CLK_MUX_HIWORD_MASK,},
|
||||
};
|
||||
|
||||
static struct hi6220_divider_clock hi6220_div_clks_sys[] __initdata = {
|
||||
{ HI6220_CLK_BUS, "clk_bus", "clk_300m", CLK_SET_RATE_PARENT, 0x490, 0, 4, 7, },
|
||||
{ HI6220_MMC0_DIV, "mmc0_div", "mmc0_syspll", CLK_SET_RATE_PARENT, 0x494, 0, 6, 7, },
|
||||
{ HI6220_MMC1_DIV, "mmc1_div", "mmc1_syspll", CLK_SET_RATE_PARENT, 0x498, 0, 6, 7, },
|
||||
{ HI6220_MMC2_DIV, "mmc2_div", "mmc2_syspll", CLK_SET_RATE_PARENT, 0x49c, 0, 6, 7, },
|
||||
{ HI6220_HIFI_DIV, "hifi_div", "hifi_sel", CLK_SET_RATE_PARENT, 0x4a0, 0, 4, 7, },
|
||||
{ HI6220_BBPPLL0_DIV, "bbppll0_div", "bbppll_sel", CLK_SET_RATE_PARENT, 0x4a0, 8, 6, 15,},
|
||||
{ HI6220_CS_DAPB, "cs_dapb", "picophy_src", CLK_SET_RATE_PARENT, 0x4a0, 24, 2, 31,},
|
||||
{ HI6220_CS_ATB_DIV, "cs_atb_div", "cs_atb_syspll", CLK_SET_RATE_PARENT, 0x4a4, 0, 4, 7, },
|
||||
};
|
||||
|
||||
static void __init hi6220_clk_sys_init(struct device_node *np)
|
||||
{
|
||||
struct hisi_clock_data *clk_data;
|
||||
|
||||
clk_data = hisi_clk_init(np, HI6220_SYS_NR_CLKS);
|
||||
if (!clk_data)
|
||||
return;
|
||||
|
||||
hisi_clk_register_gate_sep(hi6220_separated_gate_clks_sys,
|
||||
ARRAY_SIZE(hi6220_separated_gate_clks_sys), clk_data);
|
||||
|
||||
hisi_clk_register_mux(hi6220_mux_clks_sys,
|
||||
ARRAY_SIZE(hi6220_mux_clks_sys), clk_data);
|
||||
|
||||
hi6220_clk_register_divider(hi6220_div_clks_sys,
|
||||
ARRAY_SIZE(hi6220_div_clks_sys), clk_data);
|
||||
}
|
||||
CLK_OF_DECLARE(hi6220_clk_sys, "hisilicon,hi6220-sysctrl", hi6220_clk_sys_init);
|
||||
|
||||
|
||||
/* clocks in media controller */
|
||||
static const char *clk_1000_1200_src[] __initdata = { "pll_gpu_gate", "media_syspll_src", };
|
||||
static const char *clk_1440_1200_src[] __initdata = { "media_syspll_src", "media_pll_src", };
|
||||
static const char *clk_1000_1440_src[] __initdata = { "pll_gpu_gate", "media_pll_src", };
|
||||
|
||||
static struct hisi_gate_clock hi6220_separated_gate_clks_media[] __initdata = {
|
||||
{ HI6220_DSI_PCLK, "dsi_pclk", "vpucodec", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x520, 0, 0, },
|
||||
{ HI6220_G3D_PCLK, "g3d_pclk", "vpucodec", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x520, 1, 0, },
|
||||
{ HI6220_ACLK_CODEC_VPU, "aclk_codec_vpu", "ade_core_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x520, 3, 0, },
|
||||
{ HI6220_ISP_SCLK, "isp_sclk", "isp_sclk_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x520, 5, 0, },
|
||||
{ HI6220_ADE_CORE, "ade_core", "ade_core_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x520, 6, 0, },
|
||||
{ HI6220_MED_MMU, "media_mmu", "mmu_clk", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x520, 8, 0, },
|
||||
{ HI6220_CFG_CSI4PHY, "cfg_csi4phy", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x520, 9, 0, },
|
||||
{ HI6220_CFG_CSI2PHY, "cfg_csi2phy", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x520, 10, 0, },
|
||||
{ HI6220_ISP_SCLK_GATE, "isp_sclk_gate", "media_pll_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x520, 11, 0, },
|
||||
{ HI6220_ISP_SCLK_GATE1, "isp_sclk_gate1", "media_pll_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x520, 12, 0, },
|
||||
{ HI6220_ADE_CORE_GATE, "ade_core_gate", "media_pll_src", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x520, 14, 0, },
|
||||
{ HI6220_CODEC_VPU_GATE, "codec_vpu_gate", "clk_1000_1440", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x520, 15, 0, },
|
||||
{ HI6220_MED_SYSPLL, "media_syspll_src", "media_syspll", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x520, 17, 0, },
|
||||
};
|
||||
|
||||
static struct hisi_mux_clock hi6220_mux_clks_media[] __initdata = {
|
||||
{ HI6220_1440_1200, "clk_1440_1200", clk_1440_1200_src, ARRAY_SIZE(clk_1440_1200_src), CLK_SET_RATE_PARENT, 0x51c, 0, 1, 0, },
|
||||
{ HI6220_1000_1200, "clk_1000_1200", clk_1000_1200_src, ARRAY_SIZE(clk_1000_1200_src), CLK_SET_RATE_PARENT, 0x51c, 1, 1, 0, },
|
||||
{ HI6220_1000_1440, "clk_1000_1440", clk_1000_1440_src, ARRAY_SIZE(clk_1000_1440_src), CLK_SET_RATE_PARENT, 0x51c, 6, 1, 0, },
|
||||
};
|
||||
|
||||
static struct hi6220_divider_clock hi6220_div_clks_media[] __initdata = {
|
||||
{ HI6220_CODEC_JPEG, "codec_jpeg_aclk", "media_pll_src", CLK_SET_RATE_PARENT, 0xcbc, 0, 4, 23, },
|
||||
{ HI6220_ISP_SCLK_SRC, "isp_sclk_src", "isp_sclk_gate", CLK_SET_RATE_PARENT, 0xcbc, 8, 4, 15, },
|
||||
{ HI6220_ISP_SCLK1, "isp_sclk1", "isp_sclk_gate1", CLK_SET_RATE_PARENT, 0xcbc, 24, 4, 31, },
|
||||
{ HI6220_ADE_CORE_SRC, "ade_core_src", "ade_core_gate", CLK_SET_RATE_PARENT, 0xcc0, 16, 3, 23, },
|
||||
{ HI6220_ADE_PIX_SRC, "ade_pix_src", "clk_1440_1200", CLK_SET_RATE_PARENT, 0xcc0, 24, 6, 31, },
|
||||
{ HI6220_G3D_CLK, "g3d_clk", "clk_1000_1200", CLK_SET_RATE_PARENT, 0xcc4, 8, 4, 15, },
|
||||
{ HI6220_CODEC_VPU_SRC, "codec_vpu_src", "codec_vpu_gate", CLK_SET_RATE_PARENT, 0xcc4, 24, 6, 31, },
|
||||
};
|
||||
|
||||
static void __init hi6220_clk_media_init(struct device_node *np)
|
||||
{
|
||||
struct hisi_clock_data *clk_data;
|
||||
|
||||
clk_data = hisi_clk_init(np, HI6220_MEDIA_NR_CLKS);
|
||||
if (!clk_data)
|
||||
return;
|
||||
|
||||
hisi_clk_register_gate_sep(hi6220_separated_gate_clks_media,
|
||||
ARRAY_SIZE(hi6220_separated_gate_clks_media), clk_data);
|
||||
|
||||
hisi_clk_register_mux(hi6220_mux_clks_media,
|
||||
ARRAY_SIZE(hi6220_mux_clks_media), clk_data);
|
||||
|
||||
hi6220_clk_register_divider(hi6220_div_clks_media,
|
||||
ARRAY_SIZE(hi6220_div_clks_media), clk_data);
|
||||
}
|
||||
CLK_OF_DECLARE(hi6220_clk_media, "hisilicon,hi6220-mediactrl", hi6220_clk_media_init);
|
||||
|
||||
|
||||
/* clocks in pmctrl */
|
||||
static struct hisi_gate_clock hi6220_gate_clks_power[] __initdata = {
|
||||
{ HI6220_PLL_GPU_GATE, "pll_gpu_gate", "gpupll", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x8, 0, 0, },
|
||||
{ HI6220_PLL1_DDR_GATE, "pll1_ddr_gate", "ddrpll1", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x10, 0, 0, },
|
||||
{ HI6220_PLL_DDR_GATE, "pll_ddr_gate", "ddrpll0", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x18, 0, 0, },
|
||||
{ HI6220_PLL_MEDIA_GATE, "pll_media_gate", "media_pll", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x38, 0, 0, },
|
||||
{ HI6220_PLL0_BBP_GATE, "pll0_bbp_gate", "bbppll0", CLK_SET_RATE_PARENT|CLK_IGNORE_UNUSED, 0x48, 0, 0, },
|
||||
};
|
||||
|
||||
static struct hi6220_divider_clock hi6220_div_clks_power[] __initdata = {
|
||||
{ HI6220_DDRC_SRC, "ddrc_src", "ddr_sel_src", CLK_SET_RATE_PARENT, 0x5a8, 0, 4, 0, },
|
||||
{ HI6220_DDRC_AXI1, "ddrc_axi1", "ddrc_src", CLK_SET_RATE_PARENT, 0x5a8, 8, 2, 0, },
|
||||
};
|
||||
|
||||
static void __init hi6220_clk_power_init(struct device_node *np)
|
||||
{
|
||||
struct hisi_clock_data *clk_data;
|
||||
|
||||
clk_data = hisi_clk_init(np, HI6220_POWER_NR_CLKS);
|
||||
if (!clk_data)
|
||||
return;
|
||||
|
||||
hisi_clk_register_gate(hi6220_gate_clks_power,
|
||||
ARRAY_SIZE(hi6220_gate_clks_power), clk_data);
|
||||
|
||||
hi6220_clk_register_divider(hi6220_div_clks_power,
|
||||
ARRAY_SIZE(hi6220_div_clks_power), clk_data);
|
||||
}
|
||||
CLK_OF_DECLARE(hi6220_clk_power, "hisilicon,hi6220-pmctrl", hi6220_clk_power_init);
|
||||
|
|
@ -46,15 +46,15 @@ static struct hisi_fixed_rate_clock hix5hd2_fixed_rate_clks[] __initdata = {
|
|||
{ HIX5HD2_FIXED_83M, "83m", NULL, CLK_IS_ROOT, 83333333, },
|
||||
};
|
||||
|
||||
static const char *sfc_mux_p[] __initdata = {
|
||||
static const char *const sfc_mux_p[] __initconst = {
|
||||
"24m", "150m", "200m", "100m", "75m", };
|
||||
static u32 sfc_mux_table[] = {0, 4, 5, 6, 7};
|
||||
|
||||
static const char *sdio_mux_p[] __initdata = {
|
||||
static const char *const sdio_mux_p[] __initconst = {
|
||||
"75m", "100m", "50m", "15m", };
|
||||
static u32 sdio_mux_table[] = {0, 1, 2, 3};
|
||||
|
||||
static const char *fephy_mux_p[] __initdata = { "25m", "125m"};
|
||||
static const char *const fephy_mux_p[] __initconst = { "25m", "125m"};
|
||||
static u32 fephy_mux_table[] = {0, 1};
|
||||
|
||||
|
||||
|
|
@ -252,8 +252,9 @@ static struct clk_ops clk_complex_ops = {
|
|||
.disable = clk_complex_disable,
|
||||
};
|
||||
|
||||
void __init hix5hd2_clk_register_complex(struct hix5hd2_complex_clock *clks,
|
||||
int nums, struct hisi_clock_data *data)
|
||||
static void __init
|
||||
hix5hd2_clk_register_complex(struct hix5hd2_complex_clock *clks, int nums,
|
||||
struct hisi_clock_data *data)
|
||||
{
|
||||
void __iomem *base = data->base;
|
||||
int i;
|
||||
|
|
|
|||
|
|
@ -232,3 +232,32 @@ void __init hisi_clk_register_gate_sep(struct hisi_gate_clock *clks,
|
|||
data->clk_data.clks[clks[i].id] = clk;
|
||||
}
|
||||
}
|
||||
|
||||
void __init hi6220_clk_register_divider(struct hi6220_divider_clock *clks,
|
||||
int nums, struct hisi_clock_data *data)
|
||||
{
|
||||
struct clk *clk;
|
||||
void __iomem *base = data->base;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < nums; i++) {
|
||||
clk = hi6220_register_clkdiv(NULL, clks[i].name,
|
||||
clks[i].parent_name,
|
||||
clks[i].flags,
|
||||
base + clks[i].offset,
|
||||
clks[i].shift,
|
||||
clks[i].width,
|
||||
clks[i].mask_bit,
|
||||
&hisi_clk_lock);
|
||||
if (IS_ERR(clk)) {
|
||||
pr_err("%s: failed to register clock %s\n",
|
||||
__func__, clks[i].name);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (clks[i].alias)
|
||||
clk_register_clkdev(clk, clks[i].alias, NULL);
|
||||
|
||||
data->clk_data.clks[clks[i].id] = clk;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ struct hisi_fixed_factor_clock {
|
|||
struct hisi_mux_clock {
|
||||
unsigned int id;
|
||||
const char *name;
|
||||
const char **parent_names;
|
||||
const char *const *parent_names;
|
||||
u8 num_parents;
|
||||
unsigned long flags;
|
||||
unsigned long offset;
|
||||
|
|
@ -79,6 +79,18 @@ struct hisi_divider_clock {
|
|||
const char *alias;
|
||||
};
|
||||
|
||||
struct hi6220_divider_clock {
|
||||
unsigned int id;
|
||||
const char *name;
|
||||
const char *parent_name;
|
||||
unsigned long flags;
|
||||
unsigned long offset;
|
||||
u8 shift;
|
||||
u8 width;
|
||||
u32 mask_bit;
|
||||
const char *alias;
|
||||
};
|
||||
|
||||
struct hisi_gate_clock {
|
||||
unsigned int id;
|
||||
const char *name;
|
||||
|
|
@ -94,18 +106,23 @@ struct clk *hisi_register_clkgate_sep(struct device *, const char *,
|
|||
const char *, unsigned long,
|
||||
void __iomem *, u8,
|
||||
u8, spinlock_t *);
|
||||
struct clk *hi6220_register_clkdiv(struct device *dev, const char *name,
|
||||
const char *parent_name, unsigned long flags, void __iomem *reg,
|
||||
u8 shift, u8 width, u32 mask_bit, spinlock_t *lock);
|
||||
|
||||
struct hisi_clock_data __init *hisi_clk_init(struct device_node *, int);
|
||||
void __init hisi_clk_register_fixed_rate(struct hisi_fixed_rate_clock *,
|
||||
int, struct hisi_clock_data *);
|
||||
void __init hisi_clk_register_fixed_factor(struct hisi_fixed_factor_clock *,
|
||||
int, struct hisi_clock_data *);
|
||||
void __init hisi_clk_register_mux(struct hisi_mux_clock *, int,
|
||||
struct hisi_clock_data *);
|
||||
void __init hisi_clk_register_divider(struct hisi_divider_clock *,
|
||||
struct hisi_clock_data *hisi_clk_init(struct device_node *, int);
|
||||
void hisi_clk_register_fixed_rate(struct hisi_fixed_rate_clock *,
|
||||
int, struct hisi_clock_data *);
|
||||
void hisi_clk_register_fixed_factor(struct hisi_fixed_factor_clock *,
|
||||
int, struct hisi_clock_data *);
|
||||
void hisi_clk_register_mux(struct hisi_mux_clock *, int,
|
||||
struct hisi_clock_data *);
|
||||
void hisi_clk_register_divider(struct hisi_divider_clock *,
|
||||
int, struct hisi_clock_data *);
|
||||
void hisi_clk_register_gate(struct hisi_gate_clock *,
|
||||
int, struct hisi_clock_data *);
|
||||
void hisi_clk_register_gate_sep(struct hisi_gate_clock *,
|
||||
int, struct hisi_clock_data *);
|
||||
void hi6220_clk_register_divider(struct hi6220_divider_clock *,
|
||||
int, struct hisi_clock_data *);
|
||||
void __init hisi_clk_register_gate(struct hisi_gate_clock *,
|
||||
int, struct hisi_clock_data *);
|
||||
void __init hisi_clk_register_gate_sep(struct hisi_gate_clock *,
|
||||
int, struct hisi_clock_data *);
|
||||
#endif /* __HISI_CLK_H */
|
||||
|
|
|
|||
|
|
@ -0,0 +1,156 @@
|
|||
/*
|
||||
* Hisilicon hi6220 SoC divider clock driver
|
||||
*
|
||||
* Copyright (c) 2015 Hisilicon Limited.
|
||||
*
|
||||
* Author: Bintian Wang <bintian.wang@huawei.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/clk-provider.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/spinlock.h>
|
||||
|
||||
#define div_mask(width) ((1 << (width)) - 1)
|
||||
|
||||
/**
|
||||
* struct hi6220_clk_divider - divider clock for hi6220
|
||||
*
|
||||
* @hw: handle between common and hardware-specific interfaces
|
||||
* @reg: register containing divider
|
||||
* @shift: shift to the divider bit field
|
||||
* @width: width of the divider bit field
|
||||
* @mask: mask for setting divider rate
|
||||
* @table: the div table that the divider supports
|
||||
* @lock: register lock
|
||||
*/
|
||||
struct hi6220_clk_divider {
|
||||
struct clk_hw hw;
|
||||
void __iomem *reg;
|
||||
u8 shift;
|
||||
u8 width;
|
||||
u32 mask;
|
||||
const struct clk_div_table *table;
|
||||
spinlock_t *lock;
|
||||
};
|
||||
|
||||
#define to_hi6220_clk_divider(_hw) \
|
||||
container_of(_hw, struct hi6220_clk_divider, hw)
|
||||
|
||||
static unsigned long hi6220_clkdiv_recalc_rate(struct clk_hw *hw,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
unsigned int val;
|
||||
struct hi6220_clk_divider *dclk = to_hi6220_clk_divider(hw);
|
||||
|
||||
val = readl_relaxed(dclk->reg) >> dclk->shift;
|
||||
val &= div_mask(dclk->width);
|
||||
|
||||
return divider_recalc_rate(hw, parent_rate, val, dclk->table,
|
||||
CLK_DIVIDER_ROUND_CLOSEST);
|
||||
}
|
||||
|
||||
static long hi6220_clkdiv_round_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long *prate)
|
||||
{
|
||||
struct hi6220_clk_divider *dclk = to_hi6220_clk_divider(hw);
|
||||
|
||||
return divider_round_rate(hw, rate, prate, dclk->table,
|
||||
dclk->width, CLK_DIVIDER_ROUND_CLOSEST);
|
||||
}
|
||||
|
||||
static int hi6220_clkdiv_set_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
int value;
|
||||
unsigned long flags = 0;
|
||||
u32 data;
|
||||
struct hi6220_clk_divider *dclk = to_hi6220_clk_divider(hw);
|
||||
|
||||
value = divider_get_val(rate, parent_rate, dclk->table,
|
||||
dclk->width, CLK_DIVIDER_ROUND_CLOSEST);
|
||||
|
||||
if (dclk->lock)
|
||||
spin_lock_irqsave(dclk->lock, flags);
|
||||
|
||||
data = readl_relaxed(dclk->reg);
|
||||
data &= ~(div_mask(dclk->width) << dclk->shift);
|
||||
data |= value << dclk->shift;
|
||||
data |= dclk->mask;
|
||||
|
||||
writel_relaxed(data, dclk->reg);
|
||||
|
||||
if (dclk->lock)
|
||||
spin_unlock_irqrestore(dclk->lock, flags);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct clk_ops hi6220_clkdiv_ops = {
|
||||
.recalc_rate = hi6220_clkdiv_recalc_rate,
|
||||
.round_rate = hi6220_clkdiv_round_rate,
|
||||
.set_rate = hi6220_clkdiv_set_rate,
|
||||
};
|
||||
|
||||
struct clk *hi6220_register_clkdiv(struct device *dev, const char *name,
|
||||
const char *parent_name, unsigned long flags, void __iomem *reg,
|
||||
u8 shift, u8 width, u32 mask_bit, spinlock_t *lock)
|
||||
{
|
||||
struct hi6220_clk_divider *div;
|
||||
struct clk *clk;
|
||||
struct clk_init_data init;
|
||||
struct clk_div_table *table;
|
||||
u32 max_div, min_div;
|
||||
int i;
|
||||
|
||||
/* allocate the divider */
|
||||
div = kzalloc(sizeof(*div), GFP_KERNEL);
|
||||
if (!div)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
/* Init the divider table */
|
||||
max_div = div_mask(width) + 1;
|
||||
min_div = 1;
|
||||
|
||||
table = kcalloc(max_div + 1, sizeof(*table), GFP_KERNEL);
|
||||
if (!table) {
|
||||
kfree(div);
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
|
||||
for (i = 0; i < max_div; i++) {
|
||||
table[i].div = min_div + i;
|
||||
table[i].val = table[i].div - 1;
|
||||
}
|
||||
|
||||
init.name = name;
|
||||
init.ops = &hi6220_clkdiv_ops;
|
||||
init.flags = flags;
|
||||
init.parent_names = parent_name ? &parent_name : NULL;
|
||||
init.num_parents = parent_name ? 1 : 0;
|
||||
|
||||
/* struct hi6220_clk_divider assignments */
|
||||
div->reg = reg;
|
||||
div->shift = shift;
|
||||
div->width = width;
|
||||
div->mask = mask_bit ? BIT(mask_bit) : 0;
|
||||
div->lock = lock;
|
||||
div->hw.init = &init;
|
||||
div->table = table;
|
||||
|
||||
/* register the clock */
|
||||
clk = clk_register(dev, &div->hw);
|
||||
if (IS_ERR(clk)) {
|
||||
kfree(table);
|
||||
kfree(div);
|
||||
}
|
||||
|
||||
return clk;
|
||||
}
|
||||
|
|
@ -37,7 +37,8 @@
|
|||
* Main PLL or any other PLLs in the device such as ARM PLL, DDR PLL
|
||||
* or PA PLL available on keystone2. These PLLs are controlled by
|
||||
* this register. Main PLL is controlled by a PLL controller.
|
||||
* @pllm: PLL register map address
|
||||
* @pllm: PLL register map address for multiplier bits
|
||||
* @pllod: PLL register map address for post divider bits
|
||||
* @pll_ctl0: PLL controller map address
|
||||
* @pllm_lower_mask: multiplier lower mask
|
||||
* @pllm_upper_mask: multiplier upper mask
|
||||
|
|
@ -53,6 +54,7 @@ struct clk_pll_data {
|
|||
u32 phy_pllm;
|
||||
u32 phy_pll_ctl0;
|
||||
void __iomem *pllm;
|
||||
void __iomem *pllod;
|
||||
void __iomem *pll_ctl0;
|
||||
u32 pllm_lower_mask;
|
||||
u32 pllm_upper_mask;
|
||||
|
|
@ -102,7 +104,11 @@ static unsigned long clk_pllclk_recalc(struct clk_hw *hw,
|
|||
/* read post divider from od bits*/
|
||||
postdiv = ((val & pll_data->clkod_mask) >>
|
||||
pll_data->clkod_shift) + 1;
|
||||
else
|
||||
else if (pll_data->pllod) {
|
||||
postdiv = readl(pll_data->pllod);
|
||||
postdiv = ((postdiv & pll_data->clkod_mask) >>
|
||||
pll_data->clkod_shift) + 1;
|
||||
} else
|
||||
postdiv = pll_data->postdiv;
|
||||
|
||||
rate /= (prediv + 1);
|
||||
|
|
@ -172,12 +178,21 @@ static void __init _of_pll_clk_init(struct device_node *node, bool pllctrl)
|
|||
/* assume the PLL has output divider register bits */
|
||||
pll_data->clkod_mask = CLKOD_MASK;
|
||||
pll_data->clkod_shift = CLKOD_SHIFT;
|
||||
|
||||
/*
|
||||
* Check if there is an post-divider register. If not
|
||||
* assume od bits are part of control register.
|
||||
*/
|
||||
i = of_property_match_string(node, "reg-names",
|
||||
"post-divider");
|
||||
pll_data->pllod = of_iomap(node, i);
|
||||
}
|
||||
|
||||
i = of_property_match_string(node, "reg-names", "control");
|
||||
pll_data->pll_ctl0 = of_iomap(node, i);
|
||||
if (!pll_data->pll_ctl0) {
|
||||
pr_err("%s: ioremap failed\n", __func__);
|
||||
iounmap(pll_data->pllod);
|
||||
goto out;
|
||||
}
|
||||
|
||||
|
|
@ -193,6 +208,7 @@ static void __init _of_pll_clk_init(struct device_node *node, bool pllctrl)
|
|||
pll_data->pllm = of_iomap(node, i);
|
||||
if (!pll_data->pllm) {
|
||||
iounmap(pll_data->pll_ctl0);
|
||||
iounmap(pll_data->pllod);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,4 @@
|
|||
obj-y += clk-mtk.o clk-pll.o clk-gate.o
|
||||
obj-$(CONFIG_RESET_CONTROLLER) += reset.o
|
||||
obj-y += clk-mt8135.o
|
||||
obj-y += clk-mt8173.o
|
||||
|
|
@ -0,0 +1,137 @@
|
|||
/*
|
||||
* Copyright (c) 2014 MediaTek Inc.
|
||||
* Author: James Liao <jamesjj.liao@mediatek.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_address.h>
|
||||
|
||||
#include <linux/io.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/clkdev.h>
|
||||
|
||||
#include "clk-mtk.h"
|
||||
#include "clk-gate.h"
|
||||
|
||||
static int mtk_cg_bit_is_cleared(struct clk_hw *hw)
|
||||
{
|
||||
struct mtk_clk_gate *cg = to_clk_gate(hw);
|
||||
u32 val;
|
||||
|
||||
regmap_read(cg->regmap, cg->sta_ofs, &val);
|
||||
|
||||
val &= BIT(cg->bit);
|
||||
|
||||
return val == 0;
|
||||
}
|
||||
|
||||
static int mtk_cg_bit_is_set(struct clk_hw *hw)
|
||||
{
|
||||
struct mtk_clk_gate *cg = to_clk_gate(hw);
|
||||
u32 val;
|
||||
|
||||
regmap_read(cg->regmap, cg->sta_ofs, &val);
|
||||
|
||||
val &= BIT(cg->bit);
|
||||
|
||||
return val != 0;
|
||||
}
|
||||
|
||||
static void mtk_cg_set_bit(struct clk_hw *hw)
|
||||
{
|
||||
struct mtk_clk_gate *cg = to_clk_gate(hw);
|
||||
|
||||
regmap_write(cg->regmap, cg->set_ofs, BIT(cg->bit));
|
||||
}
|
||||
|
||||
static void mtk_cg_clr_bit(struct clk_hw *hw)
|
||||
{
|
||||
struct mtk_clk_gate *cg = to_clk_gate(hw);
|
||||
|
||||
regmap_write(cg->regmap, cg->clr_ofs, BIT(cg->bit));
|
||||
}
|
||||
|
||||
static int mtk_cg_enable(struct clk_hw *hw)
|
||||
{
|
||||
mtk_cg_clr_bit(hw);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void mtk_cg_disable(struct clk_hw *hw)
|
||||
{
|
||||
mtk_cg_set_bit(hw);
|
||||
}
|
||||
|
||||
static int mtk_cg_enable_inv(struct clk_hw *hw)
|
||||
{
|
||||
mtk_cg_set_bit(hw);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void mtk_cg_disable_inv(struct clk_hw *hw)
|
||||
{
|
||||
mtk_cg_clr_bit(hw);
|
||||
}
|
||||
|
||||
const struct clk_ops mtk_clk_gate_ops_setclr = {
|
||||
.is_enabled = mtk_cg_bit_is_cleared,
|
||||
.enable = mtk_cg_enable,
|
||||
.disable = mtk_cg_disable,
|
||||
};
|
||||
|
||||
const struct clk_ops mtk_clk_gate_ops_setclr_inv = {
|
||||
.is_enabled = mtk_cg_bit_is_set,
|
||||
.enable = mtk_cg_enable_inv,
|
||||
.disable = mtk_cg_disable_inv,
|
||||
};
|
||||
|
||||
struct clk *mtk_clk_register_gate(
|
||||
const char *name,
|
||||
const char *parent_name,
|
||||
struct regmap *regmap,
|
||||
int set_ofs,
|
||||
int clr_ofs,
|
||||
int sta_ofs,
|
||||
u8 bit,
|
||||
const struct clk_ops *ops)
|
||||
{
|
||||
struct mtk_clk_gate *cg;
|
||||
struct clk *clk;
|
||||
struct clk_init_data init = {};
|
||||
|
||||
cg = kzalloc(sizeof(*cg), GFP_KERNEL);
|
||||
if (!cg)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
init.name = name;
|
||||
init.flags = CLK_SET_RATE_PARENT;
|
||||
init.parent_names = parent_name ? &parent_name : NULL;
|
||||
init.num_parents = parent_name ? 1 : 0;
|
||||
init.ops = ops;
|
||||
|
||||
cg->regmap = regmap;
|
||||
cg->set_ofs = set_ofs;
|
||||
cg->clr_ofs = clr_ofs;
|
||||
cg->sta_ofs = sta_ofs;
|
||||
cg->bit = bit;
|
||||
|
||||
cg->hw.init = &init;
|
||||
|
||||
clk = clk_register(NULL, &cg->hw);
|
||||
if (IS_ERR(clk))
|
||||
kfree(cg);
|
||||
|
||||
return clk;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
/*
|
||||
* Copyright (c) 2014 MediaTek Inc.
|
||||
* Author: James Liao <jamesjj.liao@mediatek.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#ifndef __DRV_CLK_GATE_H
|
||||
#define __DRV_CLK_GATE_H
|
||||
|
||||
#include <linux/regmap.h>
|
||||
#include <linux/clk.h>
|
||||
#include <linux/clk-provider.h>
|
||||
|
||||
struct mtk_clk_gate {
|
||||
struct clk_hw hw;
|
||||
struct regmap *regmap;
|
||||
int set_ofs;
|
||||
int clr_ofs;
|
||||
int sta_ofs;
|
||||
u8 bit;
|
||||
};
|
||||
|
||||
static inline struct mtk_clk_gate *to_clk_gate(struct clk_hw *hw)
|
||||
{
|
||||
return container_of(hw, struct mtk_clk_gate, hw);
|
||||
}
|
||||
|
||||
extern const struct clk_ops mtk_clk_gate_ops_setclr;
|
||||
extern const struct clk_ops mtk_clk_gate_ops_setclr_inv;
|
||||
|
||||
struct clk *mtk_clk_register_gate(
|
||||
const char *name,
|
||||
const char *parent_name,
|
||||
struct regmap *regmap,
|
||||
int set_ofs,
|
||||
int clr_ofs,
|
||||
int sta_ofs,
|
||||
u8 bit,
|
||||
const struct clk_ops *ops);
|
||||
|
||||
#endif /* __DRV_CLK_GATE_H */
|
||||
|
|
@ -0,0 +1,644 @@
|
|||
/*
|
||||
* Copyright (c) 2014 MediaTek Inc.
|
||||
* Author: James Liao <jamesjj.liao@mediatek.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_address.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/mfd/syscon.h>
|
||||
#include <dt-bindings/clock/mt8135-clk.h>
|
||||
|
||||
#include "clk-mtk.h"
|
||||
#include "clk-gate.h"
|
||||
|
||||
static DEFINE_SPINLOCK(mt8135_clk_lock);
|
||||
|
||||
static const struct mtk_fixed_factor root_clk_alias[] __initconst = {
|
||||
FACTOR(CLK_TOP_DSI0_LNTC_DSICLK, "dsi0_lntc_dsiclk", "clk_null", 1, 1),
|
||||
FACTOR(CLK_TOP_HDMITX_CLKDIG_CTS, "hdmitx_clkdig_cts", "clk_null", 1, 1),
|
||||
FACTOR(CLK_TOP_CLKPH_MCK, "clkph_mck", "clk_null", 1, 1),
|
||||
FACTOR(CLK_TOP_CPUM_TCK_IN, "cpum_tck_in", "clk_null", 1, 1),
|
||||
};
|
||||
|
||||
static const struct mtk_fixed_factor top_divs[] __initconst = {
|
||||
FACTOR(CLK_TOP_MAINPLL_806M, "mainpll_806m", "mainpll", 1, 2),
|
||||
FACTOR(CLK_TOP_MAINPLL_537P3M, "mainpll_537p3m", "mainpll", 1, 3),
|
||||
FACTOR(CLK_TOP_MAINPLL_322P4M, "mainpll_322p4m", "mainpll", 1, 5),
|
||||
FACTOR(CLK_TOP_MAINPLL_230P3M, "mainpll_230p3m", "mainpll", 1, 7),
|
||||
|
||||
FACTOR(CLK_TOP_UNIVPLL_624M, "univpll_624m", "univpll", 1, 2),
|
||||
FACTOR(CLK_TOP_UNIVPLL_416M, "univpll_416m", "univpll", 1, 3),
|
||||
FACTOR(CLK_TOP_UNIVPLL_249P6M, "univpll_249p6m", "univpll", 1, 5),
|
||||
FACTOR(CLK_TOP_UNIVPLL_178P3M, "univpll_178p3m", "univpll", 1, 7),
|
||||
FACTOR(CLK_TOP_UNIVPLL_48M, "univpll_48m", "univpll", 1, 26),
|
||||
|
||||
FACTOR(CLK_TOP_MMPLL_D2, "mmpll_d2", "mmpll", 1, 2),
|
||||
FACTOR(CLK_TOP_MMPLL_D3, "mmpll_d3", "mmpll", 1, 3),
|
||||
FACTOR(CLK_TOP_MMPLL_D5, "mmpll_d5", "mmpll", 1, 5),
|
||||
FACTOR(CLK_TOP_MMPLL_D7, "mmpll_d7", "mmpll", 1, 7),
|
||||
FACTOR(CLK_TOP_MMPLL_D4, "mmpll_d4", "mmpll_d2", 1, 2),
|
||||
FACTOR(CLK_TOP_MMPLL_D6, "mmpll_d6", "mmpll_d3", 1, 2),
|
||||
|
||||
FACTOR(CLK_TOP_SYSPLL_D2, "syspll_d2", "mainpll_806m", 1, 1),
|
||||
FACTOR(CLK_TOP_SYSPLL_D4, "syspll_d4", "mainpll_806m", 1, 2),
|
||||
FACTOR(CLK_TOP_SYSPLL_D6, "syspll_d6", "mainpll_806m", 1, 3),
|
||||
FACTOR(CLK_TOP_SYSPLL_D8, "syspll_d8", "mainpll_806m", 1, 4),
|
||||
FACTOR(CLK_TOP_SYSPLL_D10, "syspll_d10", "mainpll_806m", 1, 5),
|
||||
FACTOR(CLK_TOP_SYSPLL_D12, "syspll_d12", "mainpll_806m", 1, 6),
|
||||
FACTOR(CLK_TOP_SYSPLL_D16, "syspll_d16", "mainpll_806m", 1, 8),
|
||||
FACTOR(CLK_TOP_SYSPLL_D24, "syspll_d24", "mainpll_806m", 1, 12),
|
||||
|
||||
FACTOR(CLK_TOP_SYSPLL_D3, "syspll_d3", "mainpll_537p3m", 1, 1),
|
||||
|
||||
FACTOR(CLK_TOP_SYSPLL_D2P5, "syspll_d2p5", "mainpll_322p4m", 2, 1),
|
||||
FACTOR(CLK_TOP_SYSPLL_D5, "syspll_d5", "mainpll_322p4m", 1, 1),
|
||||
|
||||
FACTOR(CLK_TOP_SYSPLL_D3P5, "syspll_d3p5", "mainpll_230p3m", 2, 1),
|
||||
|
||||
FACTOR(CLK_TOP_UNIVPLL1_D2, "univpll1_d2", "univpll_624m", 1, 2),
|
||||
FACTOR(CLK_TOP_UNIVPLL1_D4, "univpll1_d4", "univpll_624m", 1, 4),
|
||||
FACTOR(CLK_TOP_UNIVPLL1_D6, "univpll1_d6", "univpll_624m", 1, 6),
|
||||
FACTOR(CLK_TOP_UNIVPLL1_D8, "univpll1_d8", "univpll_624m", 1, 8),
|
||||
FACTOR(CLK_TOP_UNIVPLL1_D10, "univpll1_d10", "univpll_624m", 1, 10),
|
||||
|
||||
FACTOR(CLK_TOP_UNIVPLL2_D2, "univpll2_d2", "univpll_416m", 1, 2),
|
||||
FACTOR(CLK_TOP_UNIVPLL2_D4, "univpll2_d4", "univpll_416m", 1, 4),
|
||||
FACTOR(CLK_TOP_UNIVPLL2_D6, "univpll2_d6", "univpll_416m", 1, 6),
|
||||
FACTOR(CLK_TOP_UNIVPLL2_D8, "univpll2_d8", "univpll_416m", 1, 8),
|
||||
|
||||
FACTOR(CLK_TOP_UNIVPLL_D3, "univpll_d3", "univpll_416m", 1, 1),
|
||||
FACTOR(CLK_TOP_UNIVPLL_D5, "univpll_d5", "univpll_249p6m", 1, 1),
|
||||
FACTOR(CLK_TOP_UNIVPLL_D7, "univpll_d7", "univpll_178p3m", 1, 1),
|
||||
FACTOR(CLK_TOP_UNIVPLL_D10, "univpll_d10", "univpll_249p6m", 1, 2),
|
||||
FACTOR(CLK_TOP_UNIVPLL_D26, "univpll_d26", "univpll_48m", 1, 1),
|
||||
|
||||
FACTOR(CLK_TOP_APLL, "apll_ck", "audpll", 1, 1),
|
||||
FACTOR(CLK_TOP_APLL_D4, "apll_d4", "audpll", 1, 4),
|
||||
FACTOR(CLK_TOP_APLL_D8, "apll_d8", "audpll", 1, 8),
|
||||
FACTOR(CLK_TOP_APLL_D16, "apll_d16", "audpll", 1, 16),
|
||||
FACTOR(CLK_TOP_APLL_D24, "apll_d24", "audpll", 1, 24),
|
||||
|
||||
FACTOR(CLK_TOP_LVDSPLL_D2, "lvdspll_d2", "lvdspll", 1, 2),
|
||||
FACTOR(CLK_TOP_LVDSPLL_D4, "lvdspll_d4", "lvdspll", 1, 4),
|
||||
FACTOR(CLK_TOP_LVDSPLL_D8, "lvdspll_d8", "lvdspll", 1, 8),
|
||||
|
||||
FACTOR(CLK_TOP_LVDSTX_CLKDIG_CT, "lvdstx_clkdig_cts", "lvdspll", 1, 1),
|
||||
FACTOR(CLK_TOP_VPLL_DPIX, "vpll_dpix_ck", "lvdspll", 1, 1),
|
||||
|
||||
FACTOR(CLK_TOP_TVHDMI_H, "tvhdmi_h_ck", "tvdpll", 1, 1),
|
||||
|
||||
FACTOR(CLK_TOP_HDMITX_CLKDIG_D2, "hdmitx_clkdig_d2", "hdmitx_clkdig_cts", 1, 2),
|
||||
FACTOR(CLK_TOP_HDMITX_CLKDIG_D3, "hdmitx_clkdig_d3", "hdmitx_clkdig_cts", 1, 3),
|
||||
|
||||
FACTOR(CLK_TOP_TVHDMI_D2, "tvhdmi_d2", "tvhdmi_h_ck", 1, 2),
|
||||
FACTOR(CLK_TOP_TVHDMI_D4, "tvhdmi_d4", "tvhdmi_h_ck", 1, 4),
|
||||
|
||||
FACTOR(CLK_TOP_MEMPLL_MCK_D4, "mempll_mck_d4", "clkph_mck", 1, 4),
|
||||
};
|
||||
|
||||
static const char * const axi_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll_d3",
|
||||
"syspll_d4",
|
||||
"syspll_d6",
|
||||
"univpll_d5",
|
||||
"univpll2_d2",
|
||||
"syspll_d3p5"
|
||||
};
|
||||
|
||||
static const char * const smi_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"clkph_mck",
|
||||
"syspll_d2p5",
|
||||
"syspll_d3",
|
||||
"syspll_d8",
|
||||
"univpll_d5",
|
||||
"univpll1_d2",
|
||||
"univpll1_d6",
|
||||
"mmpll_d3",
|
||||
"mmpll_d4",
|
||||
"mmpll_d5",
|
||||
"mmpll_d6",
|
||||
"mmpll_d7",
|
||||
"vdecpll",
|
||||
"lvdspll"
|
||||
};
|
||||
|
||||
static const char * const mfg_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll1_d4",
|
||||
"syspll_d2",
|
||||
"syspll_d2p5",
|
||||
"syspll_d3",
|
||||
"univpll_d5",
|
||||
"univpll1_d2",
|
||||
"mmpll_d2",
|
||||
"mmpll_d3",
|
||||
"mmpll_d4",
|
||||
"mmpll_d5",
|
||||
"mmpll_d6",
|
||||
"mmpll_d7"
|
||||
};
|
||||
|
||||
static const char * const irda_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll2_d8",
|
||||
"univpll1_d6"
|
||||
};
|
||||
|
||||
static const char * const cam_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll_d3",
|
||||
"syspll_d3p5",
|
||||
"syspll_d4",
|
||||
"univpll_d5",
|
||||
"univpll2_d2",
|
||||
"univpll_d7",
|
||||
"univpll1_d4"
|
||||
};
|
||||
|
||||
static const char * const aud_intbus_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll_d6",
|
||||
"univpll_d10"
|
||||
};
|
||||
|
||||
static const char * const jpg_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll_d5",
|
||||
"syspll_d4",
|
||||
"syspll_d3",
|
||||
"univpll_d7",
|
||||
"univpll2_d2",
|
||||
"univpll_d5"
|
||||
};
|
||||
|
||||
static const char * const disp_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll_d3p5",
|
||||
"syspll_d3",
|
||||
"univpll2_d2",
|
||||
"univpll_d5",
|
||||
"univpll1_d2",
|
||||
"lvdspll",
|
||||
"vdecpll"
|
||||
};
|
||||
|
||||
static const char * const msdc30_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll_d6",
|
||||
"syspll_d5",
|
||||
"univpll1_d4",
|
||||
"univpll2_d4",
|
||||
"msdcpll"
|
||||
};
|
||||
|
||||
static const char * const usb20_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll2_d6",
|
||||
"univpll1_d10"
|
||||
};
|
||||
|
||||
static const char * const venc_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll_d3",
|
||||
"syspll_d8",
|
||||
"univpll_d5",
|
||||
"univpll1_d6",
|
||||
"mmpll_d4",
|
||||
"mmpll_d5",
|
||||
"mmpll_d6"
|
||||
};
|
||||
|
||||
static const char * const spi_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll_d6",
|
||||
"syspll_d8",
|
||||
"syspll_d10",
|
||||
"univpll1_d6",
|
||||
"univpll1_d8"
|
||||
};
|
||||
|
||||
static const char * const uart_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll2_d8"
|
||||
};
|
||||
|
||||
static const char * const mem_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"clkph_mck"
|
||||
};
|
||||
|
||||
static const char * const camtg_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll_d26",
|
||||
"univpll1_d6",
|
||||
"syspll_d16",
|
||||
"syspll_d8"
|
||||
};
|
||||
|
||||
static const char * const audio_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll_d24"
|
||||
};
|
||||
|
||||
static const char * const fix_parents[] __initconst = {
|
||||
"rtc32k",
|
||||
"clk26m",
|
||||
"univpll_d5",
|
||||
"univpll_d7",
|
||||
"univpll1_d2",
|
||||
"univpll1_d4",
|
||||
"univpll1_d6",
|
||||
"univpll1_d8"
|
||||
};
|
||||
|
||||
static const char * const vdec_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"vdecpll",
|
||||
"clkph_mck",
|
||||
"syspll_d2p5",
|
||||
"syspll_d3",
|
||||
"syspll_d3p5",
|
||||
"syspll_d4",
|
||||
"syspll_d5",
|
||||
"syspll_d6",
|
||||
"syspll_d8",
|
||||
"univpll1_d2",
|
||||
"univpll2_d2",
|
||||
"univpll_d7",
|
||||
"univpll_d10",
|
||||
"univpll2_d4",
|
||||
"lvdspll"
|
||||
};
|
||||
|
||||
static const char * const ddrphycfg_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"axi_sel",
|
||||
"syspll_d12"
|
||||
};
|
||||
|
||||
static const char * const dpilvds_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"lvdspll",
|
||||
"lvdspll_d2",
|
||||
"lvdspll_d4",
|
||||
"lvdspll_d8"
|
||||
};
|
||||
|
||||
static const char * const pmicspi_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll2_d6",
|
||||
"syspll_d8",
|
||||
"syspll_d10",
|
||||
"univpll1_d10",
|
||||
"mempll_mck_d4",
|
||||
"univpll_d26",
|
||||
"syspll_d24"
|
||||
};
|
||||
|
||||
static const char * const smi_mfg_as_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"smi_sel",
|
||||
"mfg_sel",
|
||||
"mem_sel"
|
||||
};
|
||||
|
||||
static const char * const gcpu_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll_d4",
|
||||
"univpll_d7",
|
||||
"syspll_d5",
|
||||
"syspll_d6"
|
||||
};
|
||||
|
||||
static const char * const dpi1_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"tvhdmi_h_ck",
|
||||
"tvhdmi_d2",
|
||||
"tvhdmi_d4"
|
||||
};
|
||||
|
||||
static const char * const cci_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"mainpll_537p3m",
|
||||
"univpll_d3",
|
||||
"syspll_d2p5",
|
||||
"syspll_d3",
|
||||
"syspll_d5"
|
||||
};
|
||||
|
||||
static const char * const apll_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"apll_ck",
|
||||
"apll_d4",
|
||||
"apll_d8",
|
||||
"apll_d16",
|
||||
"apll_d24"
|
||||
};
|
||||
|
||||
static const char * const hdmipll_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"hdmitx_clkdig_cts",
|
||||
"hdmitx_clkdig_d2",
|
||||
"hdmitx_clkdig_d3"
|
||||
};
|
||||
|
||||
static const struct mtk_composite top_muxes[] __initconst = {
|
||||
/* CLK_CFG_0 */
|
||||
MUX_GATE(CLK_TOP_AXI_SEL, "axi_sel", axi_parents,
|
||||
0x0140, 0, 3, INVALID_MUX_GATE_BIT),
|
||||
MUX_GATE(CLK_TOP_SMI_SEL, "smi_sel", smi_parents, 0x0140, 8, 4, 15),
|
||||
MUX_GATE(CLK_TOP_MFG_SEL, "mfg_sel", mfg_parents, 0x0140, 16, 4, 23),
|
||||
MUX_GATE(CLK_TOP_IRDA_SEL, "irda_sel", irda_parents, 0x0140, 24, 2, 31),
|
||||
/* CLK_CFG_1 */
|
||||
MUX_GATE(CLK_TOP_CAM_SEL, "cam_sel", cam_parents, 0x0144, 0, 3, 7),
|
||||
MUX_GATE(CLK_TOP_AUD_INTBUS_SEL, "aud_intbus_sel", aud_intbus_parents,
|
||||
0x0144, 8, 2, 15),
|
||||
MUX_GATE(CLK_TOP_JPG_SEL, "jpg_sel", jpg_parents, 0x0144, 16, 3, 23),
|
||||
MUX_GATE(CLK_TOP_DISP_SEL, "disp_sel", disp_parents, 0x0144, 24, 3, 31),
|
||||
/* CLK_CFG_2 */
|
||||
MUX_GATE(CLK_TOP_MSDC30_1_SEL, "msdc30_1_sel", msdc30_parents, 0x0148, 0, 3, 7),
|
||||
MUX_GATE(CLK_TOP_MSDC30_2_SEL, "msdc30_2_sel", msdc30_parents, 0x0148, 8, 3, 15),
|
||||
MUX_GATE(CLK_TOP_MSDC30_3_SEL, "msdc30_3_sel", msdc30_parents, 0x0148, 16, 3, 23),
|
||||
MUX_GATE(CLK_TOP_MSDC30_4_SEL, "msdc30_4_sel", msdc30_parents, 0x0148, 24, 3, 31),
|
||||
/* CLK_CFG_3 */
|
||||
MUX_GATE(CLK_TOP_USB20_SEL, "usb20_sel", usb20_parents, 0x014c, 0, 2, 7),
|
||||
/* CLK_CFG_4 */
|
||||
MUX_GATE(CLK_TOP_VENC_SEL, "venc_sel", venc_parents, 0x0150, 8, 3, 15),
|
||||
MUX_GATE(CLK_TOP_SPI_SEL, "spi_sel", spi_parents, 0x0150, 16, 3, 23),
|
||||
MUX_GATE(CLK_TOP_UART_SEL, "uart_sel", uart_parents, 0x0150, 24, 2, 31),
|
||||
/* CLK_CFG_6 */
|
||||
MUX_GATE(CLK_TOP_MEM_SEL, "mem_sel", mem_parents, 0x0158, 0, 2, 7),
|
||||
MUX_GATE(CLK_TOP_CAMTG_SEL, "camtg_sel", camtg_parents, 0x0158, 8, 3, 15),
|
||||
MUX_GATE(CLK_TOP_AUDIO_SEL, "audio_sel", audio_parents, 0x0158, 24, 2, 31),
|
||||
/* CLK_CFG_7 */
|
||||
MUX_GATE(CLK_TOP_FIX_SEL, "fix_sel", fix_parents, 0x015c, 0, 3, 7),
|
||||
MUX_GATE(CLK_TOP_VDEC_SEL, "vdec_sel", vdec_parents, 0x015c, 8, 4, 15),
|
||||
MUX_GATE(CLK_TOP_DDRPHYCFG_SEL, "ddrphycfg_sel", ddrphycfg_parents,
|
||||
0x015c, 16, 2, 23),
|
||||
MUX_GATE(CLK_TOP_DPILVDS_SEL, "dpilvds_sel", dpilvds_parents, 0x015c, 24, 3, 31),
|
||||
/* CLK_CFG_8 */
|
||||
MUX_GATE(CLK_TOP_PMICSPI_SEL, "pmicspi_sel", pmicspi_parents, 0x0164, 0, 3, 7),
|
||||
MUX_GATE(CLK_TOP_MSDC30_0_SEL, "msdc30_0_sel", msdc30_parents, 0x0164, 8, 3, 15),
|
||||
MUX_GATE(CLK_TOP_SMI_MFG_AS_SEL, "smi_mfg_as_sel", smi_mfg_as_parents,
|
||||
0x0164, 16, 2, 23),
|
||||
MUX_GATE(CLK_TOP_GCPU_SEL, "gcpu_sel", gcpu_parents, 0x0164, 24, 3, 31),
|
||||
/* CLK_CFG_9 */
|
||||
MUX_GATE(CLK_TOP_DPI1_SEL, "dpi1_sel", dpi1_parents, 0x0168, 0, 2, 7),
|
||||
MUX_GATE(CLK_TOP_CCI_SEL, "cci_sel", cci_parents, 0x0168, 8, 3, 15),
|
||||
MUX_GATE(CLK_TOP_APLL_SEL, "apll_sel", apll_parents, 0x0168, 16, 3, 23),
|
||||
MUX_GATE(CLK_TOP_HDMIPLL_SEL, "hdmipll_sel", hdmipll_parents, 0x0168, 24, 2, 31),
|
||||
};
|
||||
|
||||
static const struct mtk_gate_regs infra_cg_regs = {
|
||||
.set_ofs = 0x0040,
|
||||
.clr_ofs = 0x0044,
|
||||
.sta_ofs = 0x0048,
|
||||
};
|
||||
|
||||
#define GATE_ICG(_id, _name, _parent, _shift) { \
|
||||
.id = _id, \
|
||||
.name = _name, \
|
||||
.parent_name = _parent, \
|
||||
.regs = &infra_cg_regs, \
|
||||
.shift = _shift, \
|
||||
.ops = &mtk_clk_gate_ops_setclr, \
|
||||
}
|
||||
|
||||
static const struct mtk_gate infra_clks[] __initconst = {
|
||||
GATE_ICG(CLK_INFRA_PMIC_WRAP, "pmic_wrap_ck", "axi_sel", 23),
|
||||
GATE_ICG(CLK_INFRA_PMICSPI, "pmicspi_ck", "pmicspi_sel", 22),
|
||||
GATE_ICG(CLK_INFRA_CCIF1_AP_CTRL, "ccif1_ap_ctrl", "axi_sel", 21),
|
||||
GATE_ICG(CLK_INFRA_CCIF0_AP_CTRL, "ccif0_ap_ctrl", "axi_sel", 20),
|
||||
GATE_ICG(CLK_INFRA_KP, "kp_ck", "axi_sel", 16),
|
||||
GATE_ICG(CLK_INFRA_CPUM, "cpum_ck", "cpum_tck_in", 15),
|
||||
GATE_ICG(CLK_INFRA_M4U, "m4u_ck", "mem_sel", 8),
|
||||
GATE_ICG(CLK_INFRA_MFGAXI, "mfgaxi_ck", "axi_sel", 7),
|
||||
GATE_ICG(CLK_INFRA_DEVAPC, "devapc_ck", "axi_sel", 6),
|
||||
GATE_ICG(CLK_INFRA_AUDIO, "audio_ck", "aud_intbus_sel", 5),
|
||||
GATE_ICG(CLK_INFRA_MFG_BUS, "mfg_bus_ck", "axi_sel", 2),
|
||||
GATE_ICG(CLK_INFRA_SMI, "smi_ck", "smi_sel", 1),
|
||||
GATE_ICG(CLK_INFRA_DBGCLK, "dbgclk_ck", "axi_sel", 0),
|
||||
};
|
||||
|
||||
static const struct mtk_gate_regs peri0_cg_regs = {
|
||||
.set_ofs = 0x0008,
|
||||
.clr_ofs = 0x0010,
|
||||
.sta_ofs = 0x0018,
|
||||
};
|
||||
|
||||
static const struct mtk_gate_regs peri1_cg_regs = {
|
||||
.set_ofs = 0x000c,
|
||||
.clr_ofs = 0x0014,
|
||||
.sta_ofs = 0x001c,
|
||||
};
|
||||
|
||||
#define GATE_PERI0(_id, _name, _parent, _shift) { \
|
||||
.id = _id, \
|
||||
.name = _name, \
|
||||
.parent_name = _parent, \
|
||||
.regs = &peri0_cg_regs, \
|
||||
.shift = _shift, \
|
||||
.ops = &mtk_clk_gate_ops_setclr, \
|
||||
}
|
||||
|
||||
#define GATE_PERI1(_id, _name, _parent, _shift) { \
|
||||
.id = _id, \
|
||||
.name = _name, \
|
||||
.parent_name = _parent, \
|
||||
.regs = &peri1_cg_regs, \
|
||||
.shift = _shift, \
|
||||
.ops = &mtk_clk_gate_ops_setclr, \
|
||||
}
|
||||
|
||||
static const struct mtk_gate peri_gates[] __initconst = {
|
||||
/* PERI0 */
|
||||
GATE_PERI0(CLK_PERI_I2C5, "i2c5_ck", "axi_sel", 31),
|
||||
GATE_PERI0(CLK_PERI_I2C4, "i2c4_ck", "axi_sel", 30),
|
||||
GATE_PERI0(CLK_PERI_I2C3, "i2c3_ck", "axi_sel", 29),
|
||||
GATE_PERI0(CLK_PERI_I2C2, "i2c2_ck", "axi_sel", 28),
|
||||
GATE_PERI0(CLK_PERI_I2C1, "i2c1_ck", "axi_sel", 27),
|
||||
GATE_PERI0(CLK_PERI_I2C0, "i2c0_ck", "axi_sel", 26),
|
||||
GATE_PERI0(CLK_PERI_UART3, "uart3_ck", "axi_sel", 25),
|
||||
GATE_PERI0(CLK_PERI_UART2, "uart2_ck", "axi_sel", 24),
|
||||
GATE_PERI0(CLK_PERI_UART1, "uart1_ck", "axi_sel", 23),
|
||||
GATE_PERI0(CLK_PERI_UART0, "uart0_ck", "axi_sel", 22),
|
||||
GATE_PERI0(CLK_PERI_IRDA, "irda_ck", "irda_sel", 21),
|
||||
GATE_PERI0(CLK_PERI_NLI, "nli_ck", "axi_sel", 20),
|
||||
GATE_PERI0(CLK_PERI_MD_HIF, "md_hif_ck", "axi_sel", 19),
|
||||
GATE_PERI0(CLK_PERI_AP_HIF, "ap_hif_ck", "axi_sel", 18),
|
||||
GATE_PERI0(CLK_PERI_MSDC30_3, "msdc30_3_ck", "msdc30_4_sel", 17),
|
||||
GATE_PERI0(CLK_PERI_MSDC30_2, "msdc30_2_ck", "msdc30_3_sel", 16),
|
||||
GATE_PERI0(CLK_PERI_MSDC30_1, "msdc30_1_ck", "msdc30_2_sel", 15),
|
||||
GATE_PERI0(CLK_PERI_MSDC20_2, "msdc20_2_ck", "msdc30_1_sel", 14),
|
||||
GATE_PERI0(CLK_PERI_MSDC20_1, "msdc20_1_ck", "msdc30_0_sel", 13),
|
||||
GATE_PERI0(CLK_PERI_AP_DMA, "ap_dma_ck", "axi_sel", 12),
|
||||
GATE_PERI0(CLK_PERI_USB1, "usb1_ck", "usb20_sel", 11),
|
||||
GATE_PERI0(CLK_PERI_USB0, "usb0_ck", "usb20_sel", 10),
|
||||
GATE_PERI0(CLK_PERI_PWM, "pwm_ck", "axi_sel", 9),
|
||||
GATE_PERI0(CLK_PERI_PWM7, "pwm7_ck", "axi_sel", 8),
|
||||
GATE_PERI0(CLK_PERI_PWM6, "pwm6_ck", "axi_sel", 7),
|
||||
GATE_PERI0(CLK_PERI_PWM5, "pwm5_ck", "axi_sel", 6),
|
||||
GATE_PERI0(CLK_PERI_PWM4, "pwm4_ck", "axi_sel", 5),
|
||||
GATE_PERI0(CLK_PERI_PWM3, "pwm3_ck", "axi_sel", 4),
|
||||
GATE_PERI0(CLK_PERI_PWM2, "pwm2_ck", "axi_sel", 3),
|
||||
GATE_PERI0(CLK_PERI_PWM1, "pwm1_ck", "axi_sel", 2),
|
||||
GATE_PERI0(CLK_PERI_THERM, "therm_ck", "axi_sel", 1),
|
||||
GATE_PERI0(CLK_PERI_NFI, "nfi_ck", "axi_sel", 0),
|
||||
/* PERI1 */
|
||||
GATE_PERI1(CLK_PERI_USBSLV, "usbslv_ck", "axi_sel", 8),
|
||||
GATE_PERI1(CLK_PERI_USB1_MCU, "usb1_mcu_ck", "axi_sel", 7),
|
||||
GATE_PERI1(CLK_PERI_USB0_MCU, "usb0_mcu_ck", "axi_sel", 6),
|
||||
GATE_PERI1(CLK_PERI_GCPU, "gcpu_ck", "gcpu_sel", 5),
|
||||
GATE_PERI1(CLK_PERI_FHCTL, "fhctl_ck", "clk26m", 4),
|
||||
GATE_PERI1(CLK_PERI_SPI1, "spi1_ck", "spi_sel", 3),
|
||||
GATE_PERI1(CLK_PERI_AUXADC, "auxadc_ck", "clk26m", 2),
|
||||
GATE_PERI1(CLK_PERI_PERI_PWRAP, "peri_pwrap_ck", "axi_sel", 1),
|
||||
GATE_PERI1(CLK_PERI_I2C6, "i2c6_ck", "axi_sel", 0),
|
||||
};
|
||||
|
||||
static const char * const uart_ck_sel_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"uart_sel",
|
||||
};
|
||||
|
||||
static const struct mtk_composite peri_clks[] __initconst = {
|
||||
MUX(CLK_PERI_UART0_SEL, "uart0_ck_sel", uart_ck_sel_parents, 0x40c, 0, 1),
|
||||
MUX(CLK_PERI_UART1_SEL, "uart1_ck_sel", uart_ck_sel_parents, 0x40c, 1, 1),
|
||||
MUX(CLK_PERI_UART2_SEL, "uart2_ck_sel", uart_ck_sel_parents, 0x40c, 2, 1),
|
||||
MUX(CLK_PERI_UART3_SEL, "uart3_ck_sel", uart_ck_sel_parents, 0x40c, 3, 1),
|
||||
};
|
||||
|
||||
static void __init mtk_topckgen_init(struct device_node *node)
|
||||
{
|
||||
struct clk_onecell_data *clk_data;
|
||||
void __iomem *base;
|
||||
int r;
|
||||
|
||||
base = of_iomap(node, 0);
|
||||
if (!base) {
|
||||
pr_err("%s(): ioremap failed\n", __func__);
|
||||
return;
|
||||
}
|
||||
|
||||
clk_data = mtk_alloc_clk_data(CLK_TOP_NR_CLK);
|
||||
|
||||
mtk_clk_register_factors(root_clk_alias, ARRAY_SIZE(root_clk_alias), clk_data);
|
||||
mtk_clk_register_factors(top_divs, ARRAY_SIZE(top_divs), clk_data);
|
||||
mtk_clk_register_composites(top_muxes, ARRAY_SIZE(top_muxes), base,
|
||||
&mt8135_clk_lock, clk_data);
|
||||
|
||||
clk_prepare_enable(clk_data->clks[CLK_TOP_CCI_SEL]);
|
||||
|
||||
r = of_clk_add_provider(node, of_clk_src_onecell_get, clk_data);
|
||||
if (r)
|
||||
pr_err("%s(): could not register clock provider: %d\n",
|
||||
__func__, r);
|
||||
}
|
||||
CLK_OF_DECLARE(mtk_topckgen, "mediatek,mt8135-topckgen", mtk_topckgen_init);
|
||||
|
||||
static void __init mtk_infrasys_init(struct device_node *node)
|
||||
{
|
||||
struct clk_onecell_data *clk_data;
|
||||
int r;
|
||||
|
||||
clk_data = mtk_alloc_clk_data(CLK_INFRA_NR_CLK);
|
||||
|
||||
mtk_clk_register_gates(node, infra_clks, ARRAY_SIZE(infra_clks),
|
||||
clk_data);
|
||||
|
||||
clk_prepare_enable(clk_data->clks[CLK_INFRA_M4U]);
|
||||
|
||||
r = of_clk_add_provider(node, of_clk_src_onecell_get, clk_data);
|
||||
if (r)
|
||||
pr_err("%s(): could not register clock provider: %d\n",
|
||||
__func__, r);
|
||||
|
||||
mtk_register_reset_controller(node, 2, 0x30);
|
||||
}
|
||||
CLK_OF_DECLARE(mtk_infrasys, "mediatek,mt8135-infracfg", mtk_infrasys_init);
|
||||
|
||||
static void __init mtk_pericfg_init(struct device_node *node)
|
||||
{
|
||||
struct clk_onecell_data *clk_data;
|
||||
int r;
|
||||
void __iomem *base;
|
||||
|
||||
base = of_iomap(node, 0);
|
||||
if (!base) {
|
||||
pr_err("%s(): ioremap failed\n", __func__);
|
||||
return;
|
||||
}
|
||||
|
||||
clk_data = mtk_alloc_clk_data(CLK_PERI_NR_CLK);
|
||||
|
||||
mtk_clk_register_gates(node, peri_gates, ARRAY_SIZE(peri_gates),
|
||||
clk_data);
|
||||
mtk_clk_register_composites(peri_clks, ARRAY_SIZE(peri_clks), base,
|
||||
&mt8135_clk_lock, clk_data);
|
||||
|
||||
r = of_clk_add_provider(node, of_clk_src_onecell_get, clk_data);
|
||||
if (r)
|
||||
pr_err("%s(): could not register clock provider: %d\n",
|
||||
__func__, r);
|
||||
|
||||
mtk_register_reset_controller(node, 2, 0);
|
||||
}
|
||||
CLK_OF_DECLARE(mtk_pericfg, "mediatek,mt8135-pericfg", mtk_pericfg_init);
|
||||
|
||||
#define MT8135_PLL_FMAX (2000 * MHZ)
|
||||
#define CON0_MT8135_RST_BAR BIT(27)
|
||||
|
||||
#define PLL(_id, _name, _reg, _pwr_reg, _en_mask, _flags, _pcwbits, _pd_reg, _pd_shift, _tuner_reg, _pcw_reg, _pcw_shift) { \
|
||||
.id = _id, \
|
||||
.name = _name, \
|
||||
.reg = _reg, \
|
||||
.pwr_reg = _pwr_reg, \
|
||||
.en_mask = _en_mask, \
|
||||
.flags = _flags, \
|
||||
.rst_bar_mask = CON0_MT8135_RST_BAR, \
|
||||
.fmax = MT8135_PLL_FMAX, \
|
||||
.pcwbits = _pcwbits, \
|
||||
.pd_reg = _pd_reg, \
|
||||
.pd_shift = _pd_shift, \
|
||||
.tuner_reg = _tuner_reg, \
|
||||
.pcw_reg = _pcw_reg, \
|
||||
.pcw_shift = _pcw_shift, \
|
||||
}
|
||||
|
||||
static const struct mtk_pll_data plls[] = {
|
||||
PLL(CLK_APMIXED_ARMPLL1, "armpll1", 0x200, 0x218, 0x80000001, 0, 21, 0x204, 24, 0x0, 0x204, 0),
|
||||
PLL(CLK_APMIXED_ARMPLL2, "armpll2", 0x2cc, 0x2e4, 0x80000001, 0, 21, 0x2d0, 24, 0x0, 0x2d0, 0),
|
||||
PLL(CLK_APMIXED_MAINPLL, "mainpll", 0x21c, 0x234, 0xf0000001, HAVE_RST_BAR, 21, 0x21c, 6, 0x0, 0x220, 0),
|
||||
PLL(CLK_APMIXED_UNIVPLL, "univpll", 0x238, 0x250, 0xf3000001, HAVE_RST_BAR, 7, 0x238, 6, 0x0, 0x238, 9),
|
||||
PLL(CLK_APMIXED_MMPLL, "mmpll", 0x254, 0x26c, 0xf0000001, HAVE_RST_BAR, 21, 0x254, 6, 0x0, 0x258, 0),
|
||||
PLL(CLK_APMIXED_MSDCPLL, "msdcpll", 0x278, 0x290, 0x80000001, 0, 21, 0x278, 6, 0x0, 0x27c, 0),
|
||||
PLL(CLK_APMIXED_TVDPLL, "tvdpll", 0x294, 0x2ac, 0x80000001, 0, 31, 0x294, 6, 0x0, 0x298, 0),
|
||||
PLL(CLK_APMIXED_LVDSPLL, "lvdspll", 0x2b0, 0x2c8, 0x80000001, 0, 21, 0x2b0, 6, 0x0, 0x2b4, 0),
|
||||
PLL(CLK_APMIXED_AUDPLL, "audpll", 0x2e8, 0x300, 0x80000001, 0, 31, 0x2e8, 6, 0x2f8, 0x2ec, 0),
|
||||
PLL(CLK_APMIXED_VDECPLL, "vdecpll", 0x304, 0x31c, 0x80000001, 0, 21, 0x2b0, 6, 0x0, 0x308, 0),
|
||||
};
|
||||
|
||||
static void __init mtk_apmixedsys_init(struct device_node *node)
|
||||
{
|
||||
struct clk_onecell_data *clk_data;
|
||||
|
||||
clk_data = mtk_alloc_clk_data(CLK_APMIXED_NR_CLK);
|
||||
if (!clk_data)
|
||||
return;
|
||||
|
||||
mtk_clk_register_plls(node, plls, ARRAY_SIZE(plls), clk_data);
|
||||
}
|
||||
CLK_OF_DECLARE(mtk_apmixedsys, "mediatek,mt8135-apmixedsys",
|
||||
mtk_apmixedsys_init);
|
||||
|
|
@ -0,0 +1,830 @@
|
|||
/*
|
||||
* Copyright (c) 2014 MediaTek Inc.
|
||||
* Author: James Liao <jamesjj.liao@mediatek.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_address.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/mfd/syscon.h>
|
||||
|
||||
#include "clk-mtk.h"
|
||||
#include "clk-gate.h"
|
||||
|
||||
#include <dt-bindings/clock/mt8173-clk.h>
|
||||
|
||||
static DEFINE_SPINLOCK(mt8173_clk_lock);
|
||||
|
||||
static const struct mtk_fixed_factor root_clk_alias[] __initconst = {
|
||||
FACTOR(CLK_TOP_CLKPH_MCK_O, "clkph_mck_o", "clk_null", 1, 1),
|
||||
FACTOR(CLK_TOP_DPI, "dpi_ck", "clk_null", 1, 1),
|
||||
FACTOR(CLK_TOP_USB_SYSPLL_125M, "usb_syspll_125m", "clk_null", 1, 1),
|
||||
FACTOR(CLK_TOP_HDMITX_DIG_CTS, "hdmitx_dig_cts", "clk_null", 1, 1),
|
||||
};
|
||||
|
||||
static const struct mtk_fixed_factor top_divs[] __initconst = {
|
||||
FACTOR(CLK_TOP_ARMCA7PLL_754M, "armca7pll_754m", "armca7pll", 1, 2),
|
||||
FACTOR(CLK_TOP_ARMCA7PLL_502M, "armca7pll_502m", "armca7pll", 1, 3),
|
||||
|
||||
FACTOR(CLK_TOP_MAIN_H546M, "main_h546m", "mainpll", 1, 2),
|
||||
FACTOR(CLK_TOP_MAIN_H364M, "main_h364m", "mainpll", 1, 3),
|
||||
FACTOR(CLK_TOP_MAIN_H218P4M, "main_h218p4m", "mainpll", 1, 5),
|
||||
FACTOR(CLK_TOP_MAIN_H156M, "main_h156m", "mainpll", 1, 7),
|
||||
|
||||
FACTOR(CLK_TOP_TVDPLL_445P5M, "tvdpll_445p5m", "tvdpll", 1, 4),
|
||||
FACTOR(CLK_TOP_TVDPLL_594M, "tvdpll_594m", "tvdpll", 1, 3),
|
||||
|
||||
FACTOR(CLK_TOP_UNIV_624M, "univ_624m", "univpll", 1, 2),
|
||||
FACTOR(CLK_TOP_UNIV_416M, "univ_416m", "univpll", 1, 3),
|
||||
FACTOR(CLK_TOP_UNIV_249P6M, "univ_249p6m", "univpll", 1, 5),
|
||||
FACTOR(CLK_TOP_UNIV_178P3M, "univ_178p3m", "univpll", 1, 7),
|
||||
FACTOR(CLK_TOP_UNIV_48M, "univ_48m", "univpll", 1, 26),
|
||||
|
||||
FACTOR(CLK_TOP_CLKRTC_EXT, "clkrtc_ext", "clk32k", 1, 1),
|
||||
FACTOR(CLK_TOP_CLKRTC_INT, "clkrtc_int", "clk26m", 1, 793),
|
||||
FACTOR(CLK_TOP_FPC, "fpc_ck", "clk26m", 1, 1),
|
||||
|
||||
FACTOR(CLK_TOP_HDMITXPLL_D2, "hdmitxpll_d2", "hdmitx_dig_cts", 1, 2),
|
||||
FACTOR(CLK_TOP_HDMITXPLL_D3, "hdmitxpll_d3", "hdmitx_dig_cts", 1, 3),
|
||||
|
||||
FACTOR(CLK_TOP_ARMCA7PLL_D2, "armca7pll_d2", "armca7pll_754m", 1, 1),
|
||||
FACTOR(CLK_TOP_ARMCA7PLL_D3, "armca7pll_d3", "armca7pll_502m", 1, 1),
|
||||
|
||||
FACTOR(CLK_TOP_APLL1, "apll1_ck", "apll1", 1, 1),
|
||||
FACTOR(CLK_TOP_APLL2, "apll2_ck", "apll2", 1, 1),
|
||||
|
||||
FACTOR(CLK_TOP_DMPLL, "dmpll_ck", "clkph_mck_o", 1, 1),
|
||||
FACTOR(CLK_TOP_DMPLL_D2, "dmpll_d2", "clkph_mck_o", 1, 2),
|
||||
FACTOR(CLK_TOP_DMPLL_D4, "dmpll_d4", "clkph_mck_o", 1, 4),
|
||||
FACTOR(CLK_TOP_DMPLL_D8, "dmpll_d8", "clkph_mck_o", 1, 8),
|
||||
FACTOR(CLK_TOP_DMPLL_D16, "dmpll_d16", "clkph_mck_o", 1, 16),
|
||||
|
||||
FACTOR(CLK_TOP_LVDSPLL_D2, "lvdspll_d2", "lvdspll", 1, 2),
|
||||
FACTOR(CLK_TOP_LVDSPLL_D4, "lvdspll_d4", "lvdspll", 1, 4),
|
||||
FACTOR(CLK_TOP_LVDSPLL_D8, "lvdspll_d8", "lvdspll", 1, 8),
|
||||
|
||||
FACTOR(CLK_TOP_MMPLL, "mmpll_ck", "mmpll", 1, 1),
|
||||
FACTOR(CLK_TOP_MMPLL_D2, "mmpll_d2", "mmpll", 1, 2),
|
||||
|
||||
FACTOR(CLK_TOP_MSDCPLL, "msdcpll_ck", "msdcpll", 1, 1),
|
||||
FACTOR(CLK_TOP_MSDCPLL_D2, "msdcpll_d2", "msdcpll", 1, 2),
|
||||
FACTOR(CLK_TOP_MSDCPLL_D4, "msdcpll_d4", "msdcpll", 1, 4),
|
||||
FACTOR(CLK_TOP_MSDCPLL2, "msdcpll2_ck", "msdcpll2", 1, 1),
|
||||
FACTOR(CLK_TOP_MSDCPLL2_D2, "msdcpll2_d2", "msdcpll2", 1, 2),
|
||||
FACTOR(CLK_TOP_MSDCPLL2_D4, "msdcpll2_d4", "msdcpll2", 1, 4),
|
||||
|
||||
FACTOR(CLK_TOP_SYSPLL_D2, "syspll_d2", "main_h546m", 1, 1),
|
||||
FACTOR(CLK_TOP_SYSPLL1_D2, "syspll1_d2", "main_h546m", 1, 2),
|
||||
FACTOR(CLK_TOP_SYSPLL1_D4, "syspll1_d4", "main_h546m", 1, 4),
|
||||
FACTOR(CLK_TOP_SYSPLL1_D8, "syspll1_d8", "main_h546m", 1, 8),
|
||||
FACTOR(CLK_TOP_SYSPLL1_D16, "syspll1_d16", "main_h546m", 1, 16),
|
||||
FACTOR(CLK_TOP_SYSPLL_D3, "syspll_d3", "main_h364m", 1, 1),
|
||||
FACTOR(CLK_TOP_SYSPLL2_D2, "syspll2_d2", "main_h364m", 1, 2),
|
||||
FACTOR(CLK_TOP_SYSPLL2_D4, "syspll2_d4", "main_h364m", 1, 4),
|
||||
FACTOR(CLK_TOP_SYSPLL_D5, "syspll_d5", "main_h218p4m", 1, 1),
|
||||
FACTOR(CLK_TOP_SYSPLL3_D2, "syspll3_d2", "main_h218p4m", 1, 2),
|
||||
FACTOR(CLK_TOP_SYSPLL3_D4, "syspll3_d4", "main_h218p4m", 1, 4),
|
||||
FACTOR(CLK_TOP_SYSPLL_D7, "syspll_d7", "main_h156m", 1, 1),
|
||||
FACTOR(CLK_TOP_SYSPLL4_D2, "syspll4_d2", "main_h156m", 1, 2),
|
||||
FACTOR(CLK_TOP_SYSPLL4_D4, "syspll4_d4", "main_h156m", 1, 4),
|
||||
|
||||
FACTOR(CLK_TOP_TVDPLL, "tvdpll_ck", "tvdpll_594m", 1, 1),
|
||||
FACTOR(CLK_TOP_TVDPLL_D2, "tvdpll_d2", "tvdpll_594m", 1, 2),
|
||||
FACTOR(CLK_TOP_TVDPLL_D4, "tvdpll_d4", "tvdpll_594m", 1, 4),
|
||||
FACTOR(CLK_TOP_TVDPLL_D8, "tvdpll_d8", "tvdpll_594m", 1, 8),
|
||||
FACTOR(CLK_TOP_TVDPLL_D16, "tvdpll_d16", "tvdpll_594m", 1, 16),
|
||||
|
||||
FACTOR(CLK_TOP_UNIVPLL_D2, "univpll_d2", "univ_624m", 1, 1),
|
||||
FACTOR(CLK_TOP_UNIVPLL1_D2, "univpll1_d2", "univ_624m", 1, 2),
|
||||
FACTOR(CLK_TOP_UNIVPLL1_D4, "univpll1_d4", "univ_624m", 1, 4),
|
||||
FACTOR(CLK_TOP_UNIVPLL1_D8, "univpll1_d8", "univ_624m", 1, 8),
|
||||
FACTOR(CLK_TOP_UNIVPLL_D3, "univpll_d3", "univ_416m", 1, 1),
|
||||
FACTOR(CLK_TOP_UNIVPLL2_D2, "univpll2_d2", "univ_416m", 1, 2),
|
||||
FACTOR(CLK_TOP_UNIVPLL2_D4, "univpll2_d4", "univ_416m", 1, 4),
|
||||
FACTOR(CLK_TOP_UNIVPLL2_D8, "univpll2_d8", "univ_416m", 1, 8),
|
||||
FACTOR(CLK_TOP_UNIVPLL_D5, "univpll_d5", "univ_249p6m", 1, 1),
|
||||
FACTOR(CLK_TOP_UNIVPLL3_D2, "univpll3_d2", "univ_249p6m", 1, 2),
|
||||
FACTOR(CLK_TOP_UNIVPLL3_D4, "univpll3_d4", "univ_249p6m", 1, 4),
|
||||
FACTOR(CLK_TOP_UNIVPLL3_D8, "univpll3_d8", "univ_249p6m", 1, 8),
|
||||
FACTOR(CLK_TOP_UNIVPLL_D7, "univpll_d7", "univ_178p3m", 1, 1),
|
||||
FACTOR(CLK_TOP_UNIVPLL_D26, "univpll_d26", "univ_48m", 1, 1),
|
||||
FACTOR(CLK_TOP_UNIVPLL_D52, "univpll_d52", "univ_48m", 1, 2),
|
||||
|
||||
FACTOR(CLK_TOP_VCODECPLL, "vcodecpll_ck", "vcodecpll", 1, 3),
|
||||
FACTOR(CLK_TOP_VCODECPLL_370P5, "vcodecpll_370p5", "vcodecpll", 1, 4),
|
||||
|
||||
FACTOR(CLK_TOP_VENCPLL, "vencpll_ck", "vencpll", 1, 1),
|
||||
FACTOR(CLK_TOP_VENCPLL_D2, "vencpll_d2", "vencpll", 1, 2),
|
||||
FACTOR(CLK_TOP_VENCPLL_D4, "vencpll_d4", "vencpll", 1, 4),
|
||||
};
|
||||
|
||||
static const char * const axi_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll1_d2",
|
||||
"syspll_d5",
|
||||
"syspll1_d4",
|
||||
"univpll_d5",
|
||||
"univpll2_d2",
|
||||
"dmpll_d2",
|
||||
"dmpll_d4"
|
||||
};
|
||||
|
||||
static const char * const mem_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"dmpll_ck"
|
||||
};
|
||||
|
||||
static const char * const ddrphycfg_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll1_d8"
|
||||
};
|
||||
|
||||
static const char * const mm_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"vencpll_d2",
|
||||
"main_h364m",
|
||||
"syspll1_d2",
|
||||
"syspll_d5",
|
||||
"syspll1_d4",
|
||||
"univpll1_d2",
|
||||
"univpll2_d2",
|
||||
"dmpll_d2"
|
||||
};
|
||||
|
||||
static const char * const pwm_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll2_d4",
|
||||
"univpll3_d2",
|
||||
"univpll1_d4"
|
||||
};
|
||||
|
||||
static const char * const vdec_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"vcodecpll_ck",
|
||||
"tvdpll_445p5m",
|
||||
"univpll_d3",
|
||||
"vencpll_d2",
|
||||
"syspll_d3",
|
||||
"univpll1_d2",
|
||||
"mmpll_d2",
|
||||
"dmpll_d2",
|
||||
"dmpll_d4"
|
||||
};
|
||||
|
||||
static const char * const venc_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"vcodecpll_ck",
|
||||
"tvdpll_445p5m",
|
||||
"univpll_d3",
|
||||
"vencpll_d2",
|
||||
"syspll_d3",
|
||||
"univpll1_d2",
|
||||
"univpll2_d2",
|
||||
"dmpll_d2",
|
||||
"dmpll_d4"
|
||||
};
|
||||
|
||||
static const char * const mfg_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"mmpll_ck",
|
||||
"dmpll_ck",
|
||||
"clk26m",
|
||||
"clk26m",
|
||||
"clk26m",
|
||||
"clk26m",
|
||||
"clk26m",
|
||||
"clk26m",
|
||||
"syspll_d3",
|
||||
"syspll1_d2",
|
||||
"syspll_d5",
|
||||
"univpll_d3",
|
||||
"univpll1_d2",
|
||||
"univpll_d5",
|
||||
"univpll2_d2"
|
||||
};
|
||||
|
||||
static const char * const camtg_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll_d26",
|
||||
"univpll2_d2",
|
||||
"syspll3_d2",
|
||||
"syspll3_d4",
|
||||
"univpll1_d4"
|
||||
};
|
||||
|
||||
static const char * const uart_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll2_d8"
|
||||
};
|
||||
|
||||
static const char * const spi_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll3_d2",
|
||||
"syspll1_d4",
|
||||
"syspll4_d2",
|
||||
"univpll3_d2",
|
||||
"univpll2_d4",
|
||||
"univpll1_d8"
|
||||
};
|
||||
|
||||
static const char * const usb20_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll1_d8",
|
||||
"univpll3_d4"
|
||||
};
|
||||
|
||||
static const char * const usb30_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll3_d2",
|
||||
"usb_syspll_125m",
|
||||
"univpll2_d4"
|
||||
};
|
||||
|
||||
static const char * const msdc50_0_h_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll1_d2",
|
||||
"syspll2_d2",
|
||||
"syspll4_d2",
|
||||
"univpll_d5",
|
||||
"univpll1_d4"
|
||||
};
|
||||
|
||||
static const char * const msdc50_0_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"msdcpll_ck",
|
||||
"msdcpll_d2",
|
||||
"univpll1_d4",
|
||||
"syspll2_d2",
|
||||
"syspll_d7",
|
||||
"msdcpll_d4",
|
||||
"vencpll_d4",
|
||||
"tvdpll_ck",
|
||||
"univpll_d2",
|
||||
"univpll1_d2",
|
||||
"mmpll_ck",
|
||||
"msdcpll2_ck",
|
||||
"msdcpll2_d2",
|
||||
"msdcpll2_d4"
|
||||
};
|
||||
|
||||
static const char * const msdc30_1_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll2_d2",
|
||||
"msdcpll_d4",
|
||||
"univpll1_d4",
|
||||
"syspll2_d2",
|
||||
"syspll_d7",
|
||||
"univpll_d7",
|
||||
"vencpll_d4"
|
||||
};
|
||||
|
||||
static const char * const msdc30_2_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll2_d2",
|
||||
"msdcpll_d4",
|
||||
"univpll1_d4",
|
||||
"syspll2_d2",
|
||||
"syspll_d7",
|
||||
"univpll_d7",
|
||||
"vencpll_d2"
|
||||
};
|
||||
|
||||
static const char * const msdc30_3_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"msdcpll2_ck",
|
||||
"msdcpll2_d2",
|
||||
"univpll2_d2",
|
||||
"msdcpll2_d4",
|
||||
"msdcpll_d4",
|
||||
"univpll1_d4",
|
||||
"syspll2_d2",
|
||||
"syspll_d7",
|
||||
"univpll_d7",
|
||||
"vencpll_d4",
|
||||
"msdcpll_ck",
|
||||
"msdcpll_d2",
|
||||
"msdcpll_d4"
|
||||
};
|
||||
|
||||
static const char * const audio_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll3_d4",
|
||||
"syspll4_d4",
|
||||
"syspll1_d16"
|
||||
};
|
||||
|
||||
static const char * const aud_intbus_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll1_d4",
|
||||
"syspll4_d2",
|
||||
"univpll3_d2",
|
||||
"univpll2_d8",
|
||||
"dmpll_d4",
|
||||
"dmpll_d8"
|
||||
};
|
||||
|
||||
static const char * const pmicspi_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll1_d8",
|
||||
"syspll3_d4",
|
||||
"syspll1_d16",
|
||||
"univpll3_d4",
|
||||
"univpll_d26",
|
||||
"dmpll_d8",
|
||||
"dmpll_d16"
|
||||
};
|
||||
|
||||
static const char * const scp_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll1_d2",
|
||||
"univpll_d5",
|
||||
"syspll_d5",
|
||||
"dmpll_d2",
|
||||
"dmpll_d4"
|
||||
};
|
||||
|
||||
static const char * const atb_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll1_d2",
|
||||
"univpll_d5",
|
||||
"dmpll_d2"
|
||||
};
|
||||
|
||||
static const char * const venc_lt_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll_d3",
|
||||
"vcodecpll_ck",
|
||||
"tvdpll_445p5m",
|
||||
"vencpll_d2",
|
||||
"syspll_d3",
|
||||
"univpll1_d2",
|
||||
"univpll2_d2",
|
||||
"syspll1_d2",
|
||||
"univpll_d5",
|
||||
"vcodecpll_370p5",
|
||||
"dmpll_ck"
|
||||
};
|
||||
|
||||
static const char * const dpi0_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"tvdpll_d2",
|
||||
"tvdpll_d4",
|
||||
"clk26m",
|
||||
"clk26m",
|
||||
"tvdpll_d8",
|
||||
"tvdpll_d16"
|
||||
};
|
||||
|
||||
static const char * const irda_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll2_d4",
|
||||
"syspll2_d4"
|
||||
};
|
||||
|
||||
static const char * const cci400_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"vencpll_ck",
|
||||
"armca7pll_754m",
|
||||
"armca7pll_502m",
|
||||
"univpll_d2",
|
||||
"syspll_d2",
|
||||
"msdcpll_ck",
|
||||
"dmpll_ck"
|
||||
};
|
||||
|
||||
static const char * const aud_1_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"apll1_ck",
|
||||
"univpll2_d4",
|
||||
"univpll2_d8"
|
||||
};
|
||||
|
||||
static const char * const aud_2_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"apll2_ck",
|
||||
"univpll2_d4",
|
||||
"univpll2_d8"
|
||||
};
|
||||
|
||||
static const char * const mem_mfg_in_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"mmpll_ck",
|
||||
"dmpll_ck",
|
||||
"clk26m"
|
||||
};
|
||||
|
||||
static const char * const axi_mfg_in_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"axi_sel",
|
||||
"dmpll_d2"
|
||||
};
|
||||
|
||||
static const char * const scam_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll3_d2",
|
||||
"univpll2_d4",
|
||||
"dmpll_d4"
|
||||
};
|
||||
|
||||
static const char * const spinfi_ifr_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll2_d8",
|
||||
"univpll3_d4",
|
||||
"syspll4_d2",
|
||||
"univpll2_d4",
|
||||
"univpll3_d2",
|
||||
"syspll1_d4",
|
||||
"univpll1_d4"
|
||||
};
|
||||
|
||||
static const char * const hdmi_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"hdmitx_dig_cts",
|
||||
"hdmitxpll_d2",
|
||||
"hdmitxpll_d3"
|
||||
};
|
||||
|
||||
static const char * const dpilvds_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"lvdspll",
|
||||
"lvdspll_d2",
|
||||
"lvdspll_d4",
|
||||
"lvdspll_d8",
|
||||
"fpc_ck"
|
||||
};
|
||||
|
||||
static const char * const msdc50_2_h_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll1_d2",
|
||||
"syspll2_d2",
|
||||
"syspll4_d2",
|
||||
"univpll_d5",
|
||||
"univpll1_d4"
|
||||
};
|
||||
|
||||
static const char * const hdcp_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"syspll4_d2",
|
||||
"syspll3_d4",
|
||||
"univpll2_d4"
|
||||
};
|
||||
|
||||
static const char * const hdcp_24m_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"univpll_d26",
|
||||
"univpll_d52",
|
||||
"univpll2_d8"
|
||||
};
|
||||
|
||||
static const char * const rtc_parents[] __initconst = {
|
||||
"clkrtc_int",
|
||||
"clkrtc_ext",
|
||||
"clk26m",
|
||||
"univpll3_d8"
|
||||
};
|
||||
|
||||
static const char * const i2s0_m_ck_parents[] __initconst = {
|
||||
"apll1_div1",
|
||||
"apll2_div1"
|
||||
};
|
||||
|
||||
static const char * const i2s1_m_ck_parents[] __initconst = {
|
||||
"apll1_div2",
|
||||
"apll2_div2"
|
||||
};
|
||||
|
||||
static const char * const i2s2_m_ck_parents[] __initconst = {
|
||||
"apll1_div3",
|
||||
"apll2_div3"
|
||||
};
|
||||
|
||||
static const char * const i2s3_m_ck_parents[] __initconst = {
|
||||
"apll1_div4",
|
||||
"apll2_div4"
|
||||
};
|
||||
|
||||
static const char * const i2s3_b_ck_parents[] __initconst = {
|
||||
"apll1_div5",
|
||||
"apll2_div5"
|
||||
};
|
||||
|
||||
static const struct mtk_composite top_muxes[] __initconst = {
|
||||
/* CLK_CFG_0 */
|
||||
MUX(CLK_TOP_AXI_SEL, "axi_sel", axi_parents, 0x0040, 0, 3),
|
||||
MUX(CLK_TOP_MEM_SEL, "mem_sel", mem_parents, 0x0040, 8, 1),
|
||||
MUX_GATE(CLK_TOP_DDRPHYCFG_SEL, "ddrphycfg_sel", ddrphycfg_parents, 0x0040, 16, 1, 23),
|
||||
MUX_GATE(CLK_TOP_MM_SEL, "mm_sel", mm_parents, 0x0040, 24, 4, 31),
|
||||
/* CLK_CFG_1 */
|
||||
MUX_GATE(CLK_TOP_PWM_SEL, "pwm_sel", pwm_parents, 0x0050, 0, 2, 7),
|
||||
MUX_GATE(CLK_TOP_VDEC_SEL, "vdec_sel", vdec_parents, 0x0050, 8, 4, 15),
|
||||
MUX_GATE(CLK_TOP_VENC_SEL, "venc_sel", venc_parents, 0x0050, 16, 4, 23),
|
||||
MUX_GATE(CLK_TOP_MFG_SEL, "mfg_sel", mfg_parents, 0x0050, 24, 4, 31),
|
||||
/* CLK_CFG_2 */
|
||||
MUX_GATE(CLK_TOP_CAMTG_SEL, "camtg_sel", camtg_parents, 0x0060, 0, 3, 7),
|
||||
MUX_GATE(CLK_TOP_UART_SEL, "uart_sel", uart_parents, 0x0060, 8, 1, 15),
|
||||
MUX_GATE(CLK_TOP_SPI_SEL, "spi_sel", spi_parents, 0x0060, 16, 3, 23),
|
||||
MUX_GATE(CLK_TOP_USB20_SEL, "usb20_sel", usb20_parents, 0x0060, 24, 2, 31),
|
||||
/* CLK_CFG_3 */
|
||||
MUX_GATE(CLK_TOP_USB30_SEL, "usb30_sel", usb30_parents, 0x0070, 0, 2, 7),
|
||||
MUX_GATE(CLK_TOP_MSDC50_0_H_SEL, "msdc50_0_h_sel", msdc50_0_h_parents, 0x0070, 8, 3, 15),
|
||||
MUX_GATE(CLK_TOP_MSDC50_0_SEL, "msdc50_0_sel", msdc50_0_parents, 0x0070, 16, 4, 23),
|
||||
MUX_GATE(CLK_TOP_MSDC30_1_SEL, "msdc30_1_sel", msdc30_1_parents, 0x0070, 24, 3, 31),
|
||||
/* CLK_CFG_4 */
|
||||
MUX_GATE(CLK_TOP_MSDC30_2_SEL, "msdc30_2_sel", msdc30_2_parents, 0x0080, 0, 3, 7),
|
||||
MUX_GATE(CLK_TOP_MSDC30_3_SEL, "msdc30_3_sel", msdc30_3_parents, 0x0080, 8, 4, 15),
|
||||
MUX_GATE(CLK_TOP_AUDIO_SEL, "audio_sel", audio_parents, 0x0080, 16, 2, 23),
|
||||
MUX_GATE(CLK_TOP_AUD_INTBUS_SEL, "aud_intbus_sel", aud_intbus_parents, 0x0080, 24, 3, 31),
|
||||
/* CLK_CFG_5 */
|
||||
MUX_GATE(CLK_TOP_PMICSPI_SEL, "pmicspi_sel", pmicspi_parents, 0x0090, 0, 3, 7 /* 7:5 */),
|
||||
MUX_GATE(CLK_TOP_SCP_SEL, "scp_sel", scp_parents, 0x0090, 8, 3, 15),
|
||||
MUX_GATE(CLK_TOP_ATB_SEL, "atb_sel", atb_parents, 0x0090, 16, 2, 23),
|
||||
MUX_GATE(CLK_TOP_VENC_LT_SEL, "venclt_sel", venc_lt_parents, 0x0090, 24, 4, 31),
|
||||
/* CLK_CFG_6 */
|
||||
MUX_GATE(CLK_TOP_DPI0_SEL, "dpi0_sel", dpi0_parents, 0x00a0, 0, 3, 7),
|
||||
MUX_GATE(CLK_TOP_IRDA_SEL, "irda_sel", irda_parents, 0x00a0, 8, 2, 15),
|
||||
MUX_GATE(CLK_TOP_CCI400_SEL, "cci400_sel", cci400_parents, 0x00a0, 16, 3, 23),
|
||||
MUX_GATE(CLK_TOP_AUD_1_SEL, "aud_1_sel", aud_1_parents, 0x00a0, 24, 2, 31),
|
||||
/* CLK_CFG_7 */
|
||||
MUX_GATE(CLK_TOP_AUD_2_SEL, "aud_2_sel", aud_2_parents, 0x00b0, 0, 2, 7),
|
||||
MUX_GATE(CLK_TOP_MEM_MFG_IN_SEL, "mem_mfg_in_sel", mem_mfg_in_parents, 0x00b0, 8, 2, 15),
|
||||
MUX_GATE(CLK_TOP_AXI_MFG_IN_SEL, "axi_mfg_in_sel", axi_mfg_in_parents, 0x00b0, 16, 2, 23),
|
||||
MUX_GATE(CLK_TOP_SCAM_SEL, "scam_sel", scam_parents, 0x00b0, 24, 2, 31),
|
||||
/* CLK_CFG_12 */
|
||||
MUX_GATE(CLK_TOP_SPINFI_IFR_SEL, "spinfi_ifr_sel", spinfi_ifr_parents, 0x00c0, 0, 3, 7),
|
||||
MUX_GATE(CLK_TOP_HDMI_SEL, "hdmi_sel", hdmi_parents, 0x00c0, 8, 2, 15),
|
||||
MUX_GATE(CLK_TOP_DPILVDS_SEL, "dpilvds_sel", dpilvds_parents, 0x00c0, 24, 3, 31),
|
||||
/* CLK_CFG_13 */
|
||||
MUX_GATE(CLK_TOP_MSDC50_2_H_SEL, "msdc50_2_h_sel", msdc50_2_h_parents, 0x00d0, 0, 3, 7),
|
||||
MUX_GATE(CLK_TOP_HDCP_SEL, "hdcp_sel", hdcp_parents, 0x00d0, 8, 2, 15),
|
||||
MUX_GATE(CLK_TOP_HDCP_24M_SEL, "hdcp_24m_sel", hdcp_24m_parents, 0x00d0, 16, 2, 23),
|
||||
MUX(CLK_TOP_RTC_SEL, "rtc_sel", rtc_parents, 0x00d0, 24, 2),
|
||||
|
||||
DIV_GATE(CLK_TOP_APLL1_DIV0, "apll1_div0", "aud_1_sel", 0x12c, 8, 0x120, 4, 24),
|
||||
DIV_GATE(CLK_TOP_APLL1_DIV1, "apll1_div1", "aud_1_sel", 0x12c, 9, 0x124, 8, 0),
|
||||
DIV_GATE(CLK_TOP_APLL1_DIV2, "apll1_div2", "aud_1_sel", 0x12c, 10, 0x124, 8, 8),
|
||||
DIV_GATE(CLK_TOP_APLL1_DIV3, "apll1_div3", "aud_1_sel", 0x12c, 11, 0x124, 8, 16),
|
||||
DIV_GATE(CLK_TOP_APLL1_DIV4, "apll1_div4", "aud_1_sel", 0x12c, 12, 0x124, 8, 24),
|
||||
DIV_GATE(CLK_TOP_APLL1_DIV5, "apll1_div5", "apll1_div4", 0x12c, 13, 0x12c, 4, 0),
|
||||
|
||||
DIV_GATE(CLK_TOP_APLL2_DIV0, "apll2_div0", "aud_2_sel", 0x12c, 16, 0x120, 4, 28),
|
||||
DIV_GATE(CLK_TOP_APLL2_DIV1, "apll2_div1", "aud_2_sel", 0x12c, 17, 0x128, 8, 0),
|
||||
DIV_GATE(CLK_TOP_APLL2_DIV2, "apll2_div2", "aud_2_sel", 0x12c, 18, 0x128, 8, 8),
|
||||
DIV_GATE(CLK_TOP_APLL2_DIV3, "apll2_div3", "aud_2_sel", 0x12c, 19, 0x128, 8, 16),
|
||||
DIV_GATE(CLK_TOP_APLL2_DIV4, "apll2_div4", "aud_2_sel", 0x12c, 20, 0x128, 8, 24),
|
||||
DIV_GATE(CLK_TOP_APLL2_DIV5, "apll2_div5", "apll2_div4", 0x12c, 21, 0x12c, 4, 4),
|
||||
|
||||
MUX(CLK_TOP_I2S0_M_SEL, "i2s0_m_ck_sel", i2s0_m_ck_parents, 0x120, 4, 1),
|
||||
MUX(CLK_TOP_I2S1_M_SEL, "i2s1_m_ck_sel", i2s1_m_ck_parents, 0x120, 5, 1),
|
||||
MUX(CLK_TOP_I2S2_M_SEL, "i2s2_m_ck_sel", i2s2_m_ck_parents, 0x120, 6, 1),
|
||||
MUX(CLK_TOP_I2S3_M_SEL, "i2s3_m_ck_sel", i2s3_m_ck_parents, 0x120, 7, 1),
|
||||
MUX(CLK_TOP_I2S3_B_SEL, "i2s3_b_ck_sel", i2s3_b_ck_parents, 0x120, 8, 1),
|
||||
};
|
||||
|
||||
static const struct mtk_gate_regs infra_cg_regs = {
|
||||
.set_ofs = 0x0040,
|
||||
.clr_ofs = 0x0044,
|
||||
.sta_ofs = 0x0048,
|
||||
};
|
||||
|
||||
#define GATE_ICG(_id, _name, _parent, _shift) { \
|
||||
.id = _id, \
|
||||
.name = _name, \
|
||||
.parent_name = _parent, \
|
||||
.regs = &infra_cg_regs, \
|
||||
.shift = _shift, \
|
||||
.ops = &mtk_clk_gate_ops_setclr, \
|
||||
}
|
||||
|
||||
static const struct mtk_gate infra_clks[] __initconst = {
|
||||
GATE_ICG(CLK_INFRA_DBGCLK, "infra_dbgclk", "axi_sel", 0),
|
||||
GATE_ICG(CLK_INFRA_SMI, "infra_smi", "mm_sel", 1),
|
||||
GATE_ICG(CLK_INFRA_AUDIO, "infra_audio", "aud_intbus_sel", 5),
|
||||
GATE_ICG(CLK_INFRA_GCE, "infra_gce", "axi_sel", 6),
|
||||
GATE_ICG(CLK_INFRA_L2C_SRAM, "infra_l2c_sram", "axi_sel", 7),
|
||||
GATE_ICG(CLK_INFRA_M4U, "infra_m4u", "mem_sel", 8),
|
||||
GATE_ICG(CLK_INFRA_CPUM, "infra_cpum", "clk_null", 15),
|
||||
GATE_ICG(CLK_INFRA_KP, "infra_kp", "axi_sel", 16),
|
||||
GATE_ICG(CLK_INFRA_CEC, "infra_cec", "clk26m", 18),
|
||||
GATE_ICG(CLK_INFRA_PMICSPI, "infra_pmicspi", "pmicspi_sel", 22),
|
||||
GATE_ICG(CLK_INFRA_PMICWRAP, "infra_pmicwrap", "axi_sel", 23),
|
||||
};
|
||||
|
||||
static const struct mtk_gate_regs peri0_cg_regs = {
|
||||
.set_ofs = 0x0008,
|
||||
.clr_ofs = 0x0010,
|
||||
.sta_ofs = 0x0018,
|
||||
};
|
||||
|
||||
static const struct mtk_gate_regs peri1_cg_regs = {
|
||||
.set_ofs = 0x000c,
|
||||
.clr_ofs = 0x0014,
|
||||
.sta_ofs = 0x001c,
|
||||
};
|
||||
|
||||
#define GATE_PERI0(_id, _name, _parent, _shift) { \
|
||||
.id = _id, \
|
||||
.name = _name, \
|
||||
.parent_name = _parent, \
|
||||
.regs = &peri0_cg_regs, \
|
||||
.shift = _shift, \
|
||||
.ops = &mtk_clk_gate_ops_setclr, \
|
||||
}
|
||||
|
||||
#define GATE_PERI1(_id, _name, _parent, _shift) { \
|
||||
.id = _id, \
|
||||
.name = _name, \
|
||||
.parent_name = _parent, \
|
||||
.regs = &peri1_cg_regs, \
|
||||
.shift = _shift, \
|
||||
.ops = &mtk_clk_gate_ops_setclr, \
|
||||
}
|
||||
|
||||
static const struct mtk_gate peri_gates[] __initconst = {
|
||||
/* PERI0 */
|
||||
GATE_PERI0(CLK_PERI_NFI, "peri_nfi", "axi_sel", 0),
|
||||
GATE_PERI0(CLK_PERI_THERM, "peri_therm", "axi_sel", 1),
|
||||
GATE_PERI0(CLK_PERI_PWM1, "peri_pwm1", "axi_sel", 2),
|
||||
GATE_PERI0(CLK_PERI_PWM2, "peri_pwm2", "axi_sel", 3),
|
||||
GATE_PERI0(CLK_PERI_PWM3, "peri_pwm3", "axi_sel", 4),
|
||||
GATE_PERI0(CLK_PERI_PWM4, "peri_pwm4", "axi_sel", 5),
|
||||
GATE_PERI0(CLK_PERI_PWM5, "peri_pwm5", "axi_sel", 6),
|
||||
GATE_PERI0(CLK_PERI_PWM6, "peri_pwm6", "axi_sel", 7),
|
||||
GATE_PERI0(CLK_PERI_PWM7, "peri_pwm7", "axi_sel", 8),
|
||||
GATE_PERI0(CLK_PERI_PWM, "peri_pwm", "axi_sel", 9),
|
||||
GATE_PERI0(CLK_PERI_USB0, "peri_usb0", "usb20_sel", 10),
|
||||
GATE_PERI0(CLK_PERI_USB1, "peri_usb1", "usb20_sel", 11),
|
||||
GATE_PERI0(CLK_PERI_AP_DMA, "peri_ap_dma", "axi_sel", 12),
|
||||
GATE_PERI0(CLK_PERI_MSDC30_0, "peri_msdc30_0", "msdc50_0_sel", 13),
|
||||
GATE_PERI0(CLK_PERI_MSDC30_1, "peri_msdc30_1", "msdc30_1_sel", 14),
|
||||
GATE_PERI0(CLK_PERI_MSDC30_2, "peri_msdc30_2", "msdc30_2_sel", 15),
|
||||
GATE_PERI0(CLK_PERI_MSDC30_3, "peri_msdc30_3", "msdc30_3_sel", 16),
|
||||
GATE_PERI0(CLK_PERI_NLI_ARB, "peri_nli_arb", "axi_sel", 17),
|
||||
GATE_PERI0(CLK_PERI_IRDA, "peri_irda", "irda_sel", 18),
|
||||
GATE_PERI0(CLK_PERI_UART0, "peri_uart0", "axi_sel", 19),
|
||||
GATE_PERI0(CLK_PERI_UART1, "peri_uart1", "axi_sel", 20),
|
||||
GATE_PERI0(CLK_PERI_UART2, "peri_uart2", "axi_sel", 21),
|
||||
GATE_PERI0(CLK_PERI_UART3, "peri_uart3", "axi_sel", 22),
|
||||
GATE_PERI0(CLK_PERI_I2C0, "peri_i2c0", "axi_sel", 23),
|
||||
GATE_PERI0(CLK_PERI_I2C1, "peri_i2c1", "axi_sel", 24),
|
||||
GATE_PERI0(CLK_PERI_I2C2, "peri_i2c2", "axi_sel", 25),
|
||||
GATE_PERI0(CLK_PERI_I2C3, "peri_i2c3", "axi_sel", 26),
|
||||
GATE_PERI0(CLK_PERI_I2C4, "peri_i2c4", "axi_sel", 27),
|
||||
GATE_PERI0(CLK_PERI_AUXADC, "peri_auxadc", "clk26m", 28),
|
||||
GATE_PERI0(CLK_PERI_SPI0, "peri_spi0", "spi_sel", 29),
|
||||
GATE_PERI0(CLK_PERI_I2C5, "peri_i2c5", "axi_sel", 30),
|
||||
GATE_PERI0(CLK_PERI_NFIECC, "peri_nfiecc", "axi_sel", 31),
|
||||
/* PERI1 */
|
||||
GATE_PERI1(CLK_PERI_SPI, "peri_spi", "spi_sel", 0),
|
||||
GATE_PERI1(CLK_PERI_IRRX, "peri_irrx", "spi_sel", 1),
|
||||
GATE_PERI1(CLK_PERI_I2C6, "peri_i2c6", "axi_sel", 2),
|
||||
};
|
||||
|
||||
static const char * const uart_ck_sel_parents[] __initconst = {
|
||||
"clk26m",
|
||||
"uart_sel",
|
||||
};
|
||||
|
||||
static const struct mtk_composite peri_clks[] __initconst = {
|
||||
MUX(CLK_PERI_UART0_SEL, "uart0_ck_sel", uart_ck_sel_parents, 0x40c, 0, 1),
|
||||
MUX(CLK_PERI_UART1_SEL, "uart1_ck_sel", uart_ck_sel_parents, 0x40c, 1, 1),
|
||||
MUX(CLK_PERI_UART2_SEL, "uart2_ck_sel", uart_ck_sel_parents, 0x40c, 2, 1),
|
||||
MUX(CLK_PERI_UART3_SEL, "uart3_ck_sel", uart_ck_sel_parents, 0x40c, 3, 1),
|
||||
};
|
||||
|
||||
static void __init mtk_topckgen_init(struct device_node *node)
|
||||
{
|
||||
struct clk_onecell_data *clk_data;
|
||||
void __iomem *base;
|
||||
int r;
|
||||
|
||||
base = of_iomap(node, 0);
|
||||
if (!base) {
|
||||
pr_err("%s(): ioremap failed\n", __func__);
|
||||
return;
|
||||
}
|
||||
|
||||
clk_data = mtk_alloc_clk_data(CLK_TOP_NR_CLK);
|
||||
|
||||
mtk_clk_register_factors(root_clk_alias, ARRAY_SIZE(root_clk_alias), clk_data);
|
||||
mtk_clk_register_factors(top_divs, ARRAY_SIZE(top_divs), clk_data);
|
||||
mtk_clk_register_composites(top_muxes, ARRAY_SIZE(top_muxes), base,
|
||||
&mt8173_clk_lock, clk_data);
|
||||
|
||||
clk_prepare_enable(clk_data->clks[CLK_TOP_CCI400_SEL]);
|
||||
|
||||
r = of_clk_add_provider(node, of_clk_src_onecell_get, clk_data);
|
||||
if (r)
|
||||
pr_err("%s(): could not register clock provider: %d\n",
|
||||
__func__, r);
|
||||
}
|
||||
CLK_OF_DECLARE(mtk_topckgen, "mediatek,mt8173-topckgen", mtk_topckgen_init);
|
||||
|
||||
static void __init mtk_infrasys_init(struct device_node *node)
|
||||
{
|
||||
struct clk_onecell_data *clk_data;
|
||||
int r;
|
||||
|
||||
clk_data = mtk_alloc_clk_data(CLK_INFRA_NR_CLK);
|
||||
|
||||
mtk_clk_register_gates(node, infra_clks, ARRAY_SIZE(infra_clks),
|
||||
clk_data);
|
||||
|
||||
r = of_clk_add_provider(node, of_clk_src_onecell_get, clk_data);
|
||||
if (r)
|
||||
pr_err("%s(): could not register clock provider: %d\n",
|
||||
__func__, r);
|
||||
|
||||
mtk_register_reset_controller(node, 2, 0x30);
|
||||
}
|
||||
CLK_OF_DECLARE(mtk_infrasys, "mediatek,mt8173-infracfg", mtk_infrasys_init);
|
||||
|
||||
static void __init mtk_pericfg_init(struct device_node *node)
|
||||
{
|
||||
struct clk_onecell_data *clk_data;
|
||||
int r;
|
||||
void __iomem *base;
|
||||
|
||||
base = of_iomap(node, 0);
|
||||
if (!base) {
|
||||
pr_err("%s(): ioremap failed\n", __func__);
|
||||
return;
|
||||
}
|
||||
|
||||
clk_data = mtk_alloc_clk_data(CLK_PERI_NR_CLK);
|
||||
|
||||
mtk_clk_register_gates(node, peri_gates, ARRAY_SIZE(peri_gates),
|
||||
clk_data);
|
||||
mtk_clk_register_composites(peri_clks, ARRAY_SIZE(peri_clks), base,
|
||||
&mt8173_clk_lock, clk_data);
|
||||
|
||||
r = of_clk_add_provider(node, of_clk_src_onecell_get, clk_data);
|
||||
if (r)
|
||||
pr_err("%s(): could not register clock provider: %d\n",
|
||||
__func__, r);
|
||||
|
||||
mtk_register_reset_controller(node, 2, 0);
|
||||
}
|
||||
CLK_OF_DECLARE(mtk_pericfg, "mediatek,mt8173-pericfg", mtk_pericfg_init);
|
||||
|
||||
#define MT8173_PLL_FMAX (3000UL * MHZ)
|
||||
|
||||
#define CON0_MT8173_RST_BAR BIT(24)
|
||||
|
||||
#define PLL(_id, _name, _reg, _pwr_reg, _en_mask, _flags, _pcwbits, _pd_reg, _pd_shift, \
|
||||
_tuner_reg, _pcw_reg, _pcw_shift) { \
|
||||
.id = _id, \
|
||||
.name = _name, \
|
||||
.reg = _reg, \
|
||||
.pwr_reg = _pwr_reg, \
|
||||
.en_mask = _en_mask, \
|
||||
.flags = _flags, \
|
||||
.rst_bar_mask = CON0_MT8173_RST_BAR, \
|
||||
.fmax = MT8173_PLL_FMAX, \
|
||||
.pcwbits = _pcwbits, \
|
||||
.pd_reg = _pd_reg, \
|
||||
.pd_shift = _pd_shift, \
|
||||
.tuner_reg = _tuner_reg, \
|
||||
.pcw_reg = _pcw_reg, \
|
||||
.pcw_shift = _pcw_shift, \
|
||||
}
|
||||
|
||||
static const struct mtk_pll_data plls[] = {
|
||||
PLL(CLK_APMIXED_ARMCA15PLL, "armca15pll", 0x200, 0x20c, 0x00000001, 0, 21, 0x204, 24, 0x0, 0x204, 0),
|
||||
PLL(CLK_APMIXED_ARMCA7PLL, "armca7pll", 0x210, 0x21c, 0x00000001, 0, 21, 0x214, 24, 0x0, 0x214, 0),
|
||||
PLL(CLK_APMIXED_MAINPLL, "mainpll", 0x220, 0x22c, 0xf0000101, HAVE_RST_BAR, 21, 0x220, 4, 0x0, 0x224, 0),
|
||||
PLL(CLK_APMIXED_UNIVPLL, "univpll", 0x230, 0x23c, 0xfe000001, HAVE_RST_BAR, 7, 0x230, 4, 0x0, 0x234, 14),
|
||||
PLL(CLK_APMIXED_MMPLL, "mmpll", 0x240, 0x24c, 0x00000001, 0, 21, 0x244, 24, 0x0, 0x244, 0),
|
||||
PLL(CLK_APMIXED_MSDCPLL, "msdcpll", 0x250, 0x25c, 0x00000001, 0, 21, 0x250, 4, 0x0, 0x254, 0),
|
||||
PLL(CLK_APMIXED_VENCPLL, "vencpll", 0x260, 0x26c, 0x00000001, 0, 21, 0x260, 4, 0x0, 0x264, 0),
|
||||
PLL(CLK_APMIXED_TVDPLL, "tvdpll", 0x270, 0x27c, 0x00000001, 0, 21, 0x270, 4, 0x0, 0x274, 0),
|
||||
PLL(CLK_APMIXED_MPLL, "mpll", 0x280, 0x28c, 0x00000001, 0, 21, 0x280, 4, 0x0, 0x284, 0),
|
||||
PLL(CLK_APMIXED_VCODECPLL, "vcodecpll", 0x290, 0x29c, 0x00000001, 0, 21, 0x290, 4, 0x0, 0x294, 0),
|
||||
PLL(CLK_APMIXED_APLL1, "apll1", 0x2a0, 0x2b0, 0x00000001, 0, 31, 0x2a0, 4, 0x2a4, 0x2a4, 0),
|
||||
PLL(CLK_APMIXED_APLL2, "apll2", 0x2b4, 0x2c4, 0x00000001, 0, 31, 0x2b4, 4, 0x2b8, 0x2b8, 0),
|
||||
PLL(CLK_APMIXED_LVDSPLL, "lvdspll", 0x2d0, 0x2dc, 0x00000001, 0, 21, 0x2d0, 4, 0x0, 0x2d4, 0),
|
||||
PLL(CLK_APMIXED_MSDCPLL2, "msdcpll2", 0x2f0, 0x2fc, 0x00000001, 0, 21, 0x2f0, 4, 0x0, 0x2f4, 0),
|
||||
};
|
||||
|
||||
static void __init mtk_apmixedsys_init(struct device_node *node)
|
||||
{
|
||||
struct clk_onecell_data *clk_data;
|
||||
|
||||
clk_data = mtk_alloc_clk_data(CLK_APMIXED_NR_CLK);
|
||||
if (!clk_data)
|
||||
return;
|
||||
|
||||
mtk_clk_register_plls(node, plls, ARRAY_SIZE(plls), clk_data);
|
||||
|
||||
clk_prepare_enable(clk_data->clks[CLK_APMIXED_ARMCA15PLL]);
|
||||
}
|
||||
CLK_OF_DECLARE(mtk_apmixedsys, "mediatek,mt8173-apmixedsys",
|
||||
mtk_apmixedsys_init);
|
||||
|
|
@ -0,0 +1,220 @@
|
|||
/*
|
||||
* Copyright (c) 2014 MediaTek Inc.
|
||||
* Author: James Liao <jamesjj.liao@mediatek.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_address.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/clkdev.h>
|
||||
#include <linux/mfd/syscon.h>
|
||||
|
||||
#include "clk-mtk.h"
|
||||
#include "clk-gate.h"
|
||||
|
||||
struct clk_onecell_data *mtk_alloc_clk_data(unsigned int clk_num)
|
||||
{
|
||||
int i;
|
||||
struct clk_onecell_data *clk_data;
|
||||
|
||||
clk_data = kzalloc(sizeof(*clk_data), GFP_KERNEL);
|
||||
if (!clk_data)
|
||||
return NULL;
|
||||
|
||||
clk_data->clks = kcalloc(clk_num, sizeof(*clk_data->clks), GFP_KERNEL);
|
||||
if (!clk_data->clks)
|
||||
goto err_out;
|
||||
|
||||
clk_data->clk_num = clk_num;
|
||||
|
||||
for (i = 0; i < clk_num; i++)
|
||||
clk_data->clks[i] = ERR_PTR(-ENOENT);
|
||||
|
||||
return clk_data;
|
||||
err_out:
|
||||
kfree(clk_data);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void mtk_clk_register_factors(const struct mtk_fixed_factor *clks, int num,
|
||||
struct clk_onecell_data *clk_data)
|
||||
{
|
||||
int i;
|
||||
struct clk *clk;
|
||||
|
||||
for (i = 0; i < num; i++) {
|
||||
const struct mtk_fixed_factor *ff = &clks[i];
|
||||
|
||||
clk = clk_register_fixed_factor(NULL, ff->name, ff->parent_name,
|
||||
CLK_SET_RATE_PARENT, ff->mult, ff->div);
|
||||
|
||||
if (IS_ERR(clk)) {
|
||||
pr_err("Failed to register clk %s: %ld\n",
|
||||
ff->name, PTR_ERR(clk));
|
||||
continue;
|
||||
}
|
||||
|
||||
if (clk_data)
|
||||
clk_data->clks[ff->id] = clk;
|
||||
}
|
||||
}
|
||||
|
||||
int mtk_clk_register_gates(struct device_node *node, const struct mtk_gate *clks,
|
||||
int num, struct clk_onecell_data *clk_data)
|
||||
{
|
||||
int i;
|
||||
struct clk *clk;
|
||||
struct regmap *regmap;
|
||||
|
||||
if (!clk_data)
|
||||
return -ENOMEM;
|
||||
|
||||
regmap = syscon_node_to_regmap(node);
|
||||
if (IS_ERR(regmap)) {
|
||||
pr_err("Cannot find regmap for %s: %ld\n", node->full_name,
|
||||
PTR_ERR(regmap));
|
||||
return PTR_ERR(regmap);
|
||||
}
|
||||
|
||||
for (i = 0; i < num; i++) {
|
||||
const struct mtk_gate *gate = &clks[i];
|
||||
|
||||
clk = mtk_clk_register_gate(gate->name, gate->parent_name,
|
||||
regmap,
|
||||
gate->regs->set_ofs,
|
||||
gate->regs->clr_ofs,
|
||||
gate->regs->sta_ofs,
|
||||
gate->shift, gate->ops);
|
||||
|
||||
if (IS_ERR(clk)) {
|
||||
pr_err("Failed to register clk %s: %ld\n",
|
||||
gate->name, PTR_ERR(clk));
|
||||
continue;
|
||||
}
|
||||
|
||||
clk_data->clks[gate->id] = clk;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct clk *mtk_clk_register_composite(const struct mtk_composite *mc,
|
||||
void __iomem *base, spinlock_t *lock)
|
||||
{
|
||||
struct clk *clk;
|
||||
struct clk_mux *mux = NULL;
|
||||
struct clk_gate *gate = NULL;
|
||||
struct clk_divider *div = NULL;
|
||||
struct clk_hw *mux_hw = NULL, *gate_hw = NULL, *div_hw = NULL;
|
||||
const struct clk_ops *mux_ops = NULL, *gate_ops = NULL, *div_ops = NULL;
|
||||
const char * const *parent_names;
|
||||
const char *parent;
|
||||
int num_parents;
|
||||
int ret;
|
||||
|
||||
if (mc->mux_shift >= 0) {
|
||||
mux = kzalloc(sizeof(*mux), GFP_KERNEL);
|
||||
if (!mux)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
mux->reg = base + mc->mux_reg;
|
||||
mux->mask = BIT(mc->mux_width) - 1;
|
||||
mux->shift = mc->mux_shift;
|
||||
mux->lock = lock;
|
||||
|
||||
mux_hw = &mux->hw;
|
||||
mux_ops = &clk_mux_ops;
|
||||
|
||||
parent_names = mc->parent_names;
|
||||
num_parents = mc->num_parents;
|
||||
} else {
|
||||
parent = mc->parent;
|
||||
parent_names = &parent;
|
||||
num_parents = 1;
|
||||
}
|
||||
|
||||
if (mc->gate_shift >= 0) {
|
||||
gate = kzalloc(sizeof(*gate), GFP_KERNEL);
|
||||
if (!gate) {
|
||||
ret = -ENOMEM;
|
||||
goto err_out;
|
||||
}
|
||||
|
||||
gate->reg = base + mc->gate_reg;
|
||||
gate->bit_idx = mc->gate_shift;
|
||||
gate->flags = CLK_GATE_SET_TO_DISABLE;
|
||||
gate->lock = lock;
|
||||
|
||||
gate_hw = &gate->hw;
|
||||
gate_ops = &clk_gate_ops;
|
||||
}
|
||||
|
||||
if (mc->divider_shift >= 0) {
|
||||
div = kzalloc(sizeof(*div), GFP_KERNEL);
|
||||
if (!div) {
|
||||
ret = -ENOMEM;
|
||||
goto err_out;
|
||||
}
|
||||
|
||||
div->reg = base + mc->divider_reg;
|
||||
div->shift = mc->divider_shift;
|
||||
div->width = mc->divider_width;
|
||||
div->lock = lock;
|
||||
|
||||
div_hw = &div->hw;
|
||||
div_ops = &clk_divider_ops;
|
||||
}
|
||||
|
||||
clk = clk_register_composite(NULL, mc->name, parent_names, num_parents,
|
||||
mux_hw, mux_ops,
|
||||
div_hw, div_ops,
|
||||
gate_hw, gate_ops,
|
||||
mc->flags);
|
||||
|
||||
if (IS_ERR(clk)) {
|
||||
kfree(gate);
|
||||
kfree(mux);
|
||||
}
|
||||
|
||||
return clk;
|
||||
err_out:
|
||||
kfree(mux);
|
||||
|
||||
return ERR_PTR(ret);
|
||||
}
|
||||
|
||||
void mtk_clk_register_composites(const struct mtk_composite *mcs,
|
||||
int num, void __iomem *base, spinlock_t *lock,
|
||||
struct clk_onecell_data *clk_data)
|
||||
{
|
||||
struct clk *clk;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < num; i++) {
|
||||
const struct mtk_composite *mc = &mcs[i];
|
||||
|
||||
clk = mtk_clk_register_composite(mc, base, lock);
|
||||
|
||||
if (IS_ERR(clk)) {
|
||||
pr_err("Failed to register clk %s: %ld\n",
|
||||
mc->name, PTR_ERR(clk));
|
||||
continue;
|
||||
}
|
||||
|
||||
if (clk_data)
|
||||
clk_data->clks[mc->id] = clk;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,169 @@
|
|||
/*
|
||||
* Copyright (c) 2014 MediaTek Inc.
|
||||
* Author: James Liao <jamesjj.liao@mediatek.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#ifndef __DRV_CLK_MTK_H
|
||||
#define __DRV_CLK_MTK_H
|
||||
|
||||
#include <linux/regmap.h>
|
||||
#include <linux/bitops.h>
|
||||
#include <linux/clk.h>
|
||||
#include <linux/clk-provider.h>
|
||||
|
||||
#define MAX_MUX_GATE_BIT 31
|
||||
#define INVALID_MUX_GATE_BIT (MAX_MUX_GATE_BIT + 1)
|
||||
|
||||
#define MHZ (1000 * 1000)
|
||||
|
||||
struct mtk_fixed_factor {
|
||||
int id;
|
||||
const char *name;
|
||||
const char *parent_name;
|
||||
int mult;
|
||||
int div;
|
||||
};
|
||||
|
||||
#define FACTOR(_id, _name, _parent, _mult, _div) { \
|
||||
.id = _id, \
|
||||
.name = _name, \
|
||||
.parent_name = _parent, \
|
||||
.mult = _mult, \
|
||||
.div = _div, \
|
||||
}
|
||||
|
||||
extern void mtk_clk_register_factors(const struct mtk_fixed_factor *clks,
|
||||
int num, struct clk_onecell_data *clk_data);
|
||||
|
||||
struct mtk_composite {
|
||||
int id;
|
||||
const char *name;
|
||||
const char * const *parent_names;
|
||||
const char *parent;
|
||||
unsigned flags;
|
||||
|
||||
uint32_t mux_reg;
|
||||
uint32_t divider_reg;
|
||||
uint32_t gate_reg;
|
||||
|
||||
signed char mux_shift;
|
||||
signed char mux_width;
|
||||
signed char gate_shift;
|
||||
|
||||
signed char divider_shift;
|
||||
signed char divider_width;
|
||||
|
||||
signed char num_parents;
|
||||
};
|
||||
|
||||
#define MUX_GATE(_id, _name, _parents, _reg, _shift, _width, _gate) { \
|
||||
.id = _id, \
|
||||
.name = _name, \
|
||||
.mux_reg = _reg, \
|
||||
.mux_shift = _shift, \
|
||||
.mux_width = _width, \
|
||||
.gate_reg = _reg, \
|
||||
.gate_shift = _gate, \
|
||||
.divider_shift = -1, \
|
||||
.parent_names = _parents, \
|
||||
.num_parents = ARRAY_SIZE(_parents), \
|
||||
.flags = CLK_SET_RATE_PARENT, \
|
||||
}
|
||||
|
||||
#define MUX(_id, _name, _parents, _reg, _shift, _width) { \
|
||||
.id = _id, \
|
||||
.name = _name, \
|
||||
.mux_reg = _reg, \
|
||||
.mux_shift = _shift, \
|
||||
.mux_width = _width, \
|
||||
.gate_shift = -1, \
|
||||
.divider_shift = -1, \
|
||||
.parent_names = _parents, \
|
||||
.num_parents = ARRAY_SIZE(_parents), \
|
||||
.flags = CLK_SET_RATE_PARENT, \
|
||||
}
|
||||
|
||||
#define DIV_GATE(_id, _name, _parent, _gate_reg, _gate_shift, _div_reg, _div_width, _div_shift) { \
|
||||
.id = _id, \
|
||||
.parent = _parent, \
|
||||
.name = _name, \
|
||||
.divider_reg = _div_reg, \
|
||||
.divider_shift = _div_shift, \
|
||||
.divider_width = _div_width, \
|
||||
.gate_reg = _gate_reg, \
|
||||
.gate_shift = _gate_shift, \
|
||||
.mux_shift = -1, \
|
||||
.flags = 0, \
|
||||
}
|
||||
|
||||
struct clk *mtk_clk_register_composite(const struct mtk_composite *mc,
|
||||
void __iomem *base, spinlock_t *lock);
|
||||
|
||||
void mtk_clk_register_composites(const struct mtk_composite *mcs,
|
||||
int num, void __iomem *base, spinlock_t *lock,
|
||||
struct clk_onecell_data *clk_data);
|
||||
|
||||
struct mtk_gate_regs {
|
||||
u32 sta_ofs;
|
||||
u32 clr_ofs;
|
||||
u32 set_ofs;
|
||||
};
|
||||
|
||||
struct mtk_gate {
|
||||
int id;
|
||||
const char *name;
|
||||
const char *parent_name;
|
||||
const struct mtk_gate_regs *regs;
|
||||
int shift;
|
||||
const struct clk_ops *ops;
|
||||
};
|
||||
|
||||
int mtk_clk_register_gates(struct device_node *node, const struct mtk_gate *clks,
|
||||
int num, struct clk_onecell_data *clk_data);
|
||||
|
||||
struct clk_onecell_data *mtk_alloc_clk_data(unsigned int clk_num);
|
||||
|
||||
#define HAVE_RST_BAR BIT(0)
|
||||
|
||||
struct mtk_pll_data {
|
||||
int id;
|
||||
const char *name;
|
||||
uint32_t reg;
|
||||
uint32_t pwr_reg;
|
||||
uint32_t en_mask;
|
||||
uint32_t pd_reg;
|
||||
uint32_t tuner_reg;
|
||||
int pd_shift;
|
||||
unsigned int flags;
|
||||
const struct clk_ops *ops;
|
||||
u32 rst_bar_mask;
|
||||
unsigned long fmax;
|
||||
int pcwbits;
|
||||
uint32_t pcw_reg;
|
||||
int pcw_shift;
|
||||
};
|
||||
|
||||
void __init mtk_clk_register_plls(struct device_node *node,
|
||||
const struct mtk_pll_data *plls, int num_plls,
|
||||
struct clk_onecell_data *clk_data);
|
||||
|
||||
#ifdef CONFIG_RESET_CONTROLLER
|
||||
void mtk_register_reset_controller(struct device_node *np,
|
||||
unsigned int num_regs, int regofs);
|
||||
#else
|
||||
static inline void mtk_register_reset_controller(struct device_node *np,
|
||||
unsigned int num_regs, int regofs)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __DRV_CLK_MTK_H */
|
||||
|
|
@ -0,0 +1,332 @@
|
|||
/*
|
||||
* Copyright (c) 2014 MediaTek Inc.
|
||||
* Author: James Liao <jamesjj.liao@mediatek.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_address.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/clkdev.h>
|
||||
#include <linux/delay.h>
|
||||
|
||||
#include "clk-mtk.h"
|
||||
|
||||
#define REG_CON0 0
|
||||
#define REG_CON1 4
|
||||
|
||||
#define CON0_BASE_EN BIT(0)
|
||||
#define CON0_PWR_ON BIT(0)
|
||||
#define CON0_ISO_EN BIT(1)
|
||||
#define CON0_PCW_CHG BIT(31)
|
||||
|
||||
#define AUDPLL_TUNER_EN BIT(31)
|
||||
|
||||
#define POSTDIV_MASK 0x7
|
||||
#define INTEGER_BITS 7
|
||||
|
||||
/*
|
||||
* MediaTek PLLs are configured through their pcw value. The pcw value describes
|
||||
* a divider in the PLL feedback loop which consists of 7 bits for the integer
|
||||
* part and the remaining bits (if present) for the fractional part. Also they
|
||||
* have a 3 bit power-of-two post divider.
|
||||
*/
|
||||
|
||||
struct mtk_clk_pll {
|
||||
struct clk_hw hw;
|
||||
void __iomem *base_addr;
|
||||
void __iomem *pd_addr;
|
||||
void __iomem *pwr_addr;
|
||||
void __iomem *tuner_addr;
|
||||
void __iomem *pcw_addr;
|
||||
const struct mtk_pll_data *data;
|
||||
};
|
||||
|
||||
static inline struct mtk_clk_pll *to_mtk_clk_pll(struct clk_hw *hw)
|
||||
{
|
||||
return container_of(hw, struct mtk_clk_pll, hw);
|
||||
}
|
||||
|
||||
static int mtk_pll_is_prepared(struct clk_hw *hw)
|
||||
{
|
||||
struct mtk_clk_pll *pll = to_mtk_clk_pll(hw);
|
||||
|
||||
return (readl(pll->base_addr + REG_CON0) & CON0_BASE_EN) != 0;
|
||||
}
|
||||
|
||||
static unsigned long __mtk_pll_recalc_rate(struct mtk_clk_pll *pll, u32 fin,
|
||||
u32 pcw, int postdiv)
|
||||
{
|
||||
int pcwbits = pll->data->pcwbits;
|
||||
int pcwfbits;
|
||||
u64 vco;
|
||||
u8 c = 0;
|
||||
|
||||
/* The fractional part of the PLL divider. */
|
||||
pcwfbits = pcwbits > INTEGER_BITS ? pcwbits - INTEGER_BITS : 0;
|
||||
|
||||
vco = (u64)fin * pcw;
|
||||
|
||||
if (pcwfbits && (vco & GENMASK(pcwfbits - 1, 0)))
|
||||
c = 1;
|
||||
|
||||
vco >>= pcwfbits;
|
||||
|
||||
if (c)
|
||||
vco++;
|
||||
|
||||
return ((unsigned long)vco + postdiv - 1) / postdiv;
|
||||
}
|
||||
|
||||
static void mtk_pll_set_rate_regs(struct mtk_clk_pll *pll, u32 pcw,
|
||||
int postdiv)
|
||||
{
|
||||
u32 con1, pd, val;
|
||||
int pll_en;
|
||||
|
||||
/* set postdiv */
|
||||
pd = readl(pll->pd_addr);
|
||||
pd &= ~(POSTDIV_MASK << pll->data->pd_shift);
|
||||
pd |= (ffs(postdiv) - 1) << pll->data->pd_shift;
|
||||
writel(pd, pll->pd_addr);
|
||||
|
||||
pll_en = readl(pll->base_addr + REG_CON0) & CON0_BASE_EN;
|
||||
|
||||
/* set pcw */
|
||||
val = readl(pll->pcw_addr);
|
||||
|
||||
val &= ~GENMASK(pll->data->pcw_shift + pll->data->pcwbits - 1,
|
||||
pll->data->pcw_shift);
|
||||
val |= pcw << pll->data->pcw_shift;
|
||||
writel(val, pll->pcw_addr);
|
||||
|
||||
con1 = readl(pll->base_addr + REG_CON1);
|
||||
|
||||
if (pll_en)
|
||||
con1 |= CON0_PCW_CHG;
|
||||
|
||||
writel(con1, pll->base_addr + REG_CON1);
|
||||
if (pll->tuner_addr)
|
||||
writel(con1 + 1, pll->tuner_addr);
|
||||
|
||||
if (pll_en)
|
||||
udelay(20);
|
||||
}
|
||||
|
||||
/*
|
||||
* mtk_pll_calc_values - calculate good values for a given input frequency.
|
||||
* @pll: The pll
|
||||
* @pcw: The pcw value (output)
|
||||
* @postdiv: The post divider (output)
|
||||
* @freq: The desired target frequency
|
||||
* @fin: The input frequency
|
||||
*
|
||||
*/
|
||||
static void mtk_pll_calc_values(struct mtk_clk_pll *pll, u32 *pcw, u32 *postdiv,
|
||||
u32 freq, u32 fin)
|
||||
{
|
||||
unsigned long fmin = 1000 * MHZ;
|
||||
u64 _pcw;
|
||||
u32 val;
|
||||
|
||||
if (freq > pll->data->fmax)
|
||||
freq = pll->data->fmax;
|
||||
|
||||
for (val = 0; val < 4; val++) {
|
||||
*postdiv = 1 << val;
|
||||
if (freq * *postdiv >= fmin)
|
||||
break;
|
||||
}
|
||||
|
||||
/* _pcw = freq * postdiv / fin * 2^pcwfbits */
|
||||
_pcw = ((u64)freq << val) << (pll->data->pcwbits - INTEGER_BITS);
|
||||
do_div(_pcw, fin);
|
||||
|
||||
*pcw = (u32)_pcw;
|
||||
}
|
||||
|
||||
static int mtk_pll_set_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct mtk_clk_pll *pll = to_mtk_clk_pll(hw);
|
||||
u32 pcw = 0;
|
||||
u32 postdiv;
|
||||
|
||||
mtk_pll_calc_values(pll, &pcw, &postdiv, rate, parent_rate);
|
||||
mtk_pll_set_rate_regs(pll, pcw, postdiv);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static unsigned long mtk_pll_recalc_rate(struct clk_hw *hw,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct mtk_clk_pll *pll = to_mtk_clk_pll(hw);
|
||||
u32 postdiv;
|
||||
u32 pcw;
|
||||
|
||||
postdiv = (readl(pll->pd_addr) >> pll->data->pd_shift) & POSTDIV_MASK;
|
||||
postdiv = 1 << postdiv;
|
||||
|
||||
pcw = readl(pll->pcw_addr) >> pll->data->pcw_shift;
|
||||
pcw &= GENMASK(pll->data->pcwbits - 1, 0);
|
||||
|
||||
return __mtk_pll_recalc_rate(pll, parent_rate, pcw, postdiv);
|
||||
}
|
||||
|
||||
static long mtk_pll_round_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long *prate)
|
||||
{
|
||||
struct mtk_clk_pll *pll = to_mtk_clk_pll(hw);
|
||||
u32 pcw = 0;
|
||||
int postdiv;
|
||||
|
||||
mtk_pll_calc_values(pll, &pcw, &postdiv, rate, *prate);
|
||||
|
||||
return __mtk_pll_recalc_rate(pll, *prate, pcw, postdiv);
|
||||
}
|
||||
|
||||
static int mtk_pll_prepare(struct clk_hw *hw)
|
||||
{
|
||||
struct mtk_clk_pll *pll = to_mtk_clk_pll(hw);
|
||||
u32 r;
|
||||
|
||||
r = readl(pll->pwr_addr) | CON0_PWR_ON;
|
||||
writel(r, pll->pwr_addr);
|
||||
udelay(1);
|
||||
|
||||
r = readl(pll->pwr_addr) & ~CON0_ISO_EN;
|
||||
writel(r, pll->pwr_addr);
|
||||
udelay(1);
|
||||
|
||||
r = readl(pll->base_addr + REG_CON0);
|
||||
r |= pll->data->en_mask;
|
||||
writel(r, pll->base_addr + REG_CON0);
|
||||
|
||||
if (pll->tuner_addr) {
|
||||
r = readl(pll->tuner_addr) | AUDPLL_TUNER_EN;
|
||||
writel(r, pll->tuner_addr);
|
||||
}
|
||||
|
||||
udelay(20);
|
||||
|
||||
if (pll->data->flags & HAVE_RST_BAR) {
|
||||
r = readl(pll->base_addr + REG_CON0);
|
||||
r |= pll->data->rst_bar_mask;
|
||||
writel(r, pll->base_addr + REG_CON0);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void mtk_pll_unprepare(struct clk_hw *hw)
|
||||
{
|
||||
struct mtk_clk_pll *pll = to_mtk_clk_pll(hw);
|
||||
u32 r;
|
||||
|
||||
if (pll->data->flags & HAVE_RST_BAR) {
|
||||
r = readl(pll->base_addr + REG_CON0);
|
||||
r &= ~pll->data->rst_bar_mask;
|
||||
writel(r, pll->base_addr + REG_CON0);
|
||||
}
|
||||
|
||||
if (pll->tuner_addr) {
|
||||
r = readl(pll->tuner_addr) & ~AUDPLL_TUNER_EN;
|
||||
writel(r, pll->tuner_addr);
|
||||
}
|
||||
|
||||
r = readl(pll->base_addr + REG_CON0);
|
||||
r &= ~CON0_BASE_EN;
|
||||
writel(r, pll->base_addr + REG_CON0);
|
||||
|
||||
r = readl(pll->pwr_addr) | CON0_ISO_EN;
|
||||
writel(r, pll->pwr_addr);
|
||||
|
||||
r = readl(pll->pwr_addr) & ~CON0_PWR_ON;
|
||||
writel(r, pll->pwr_addr);
|
||||
}
|
||||
|
||||
static const struct clk_ops mtk_pll_ops = {
|
||||
.is_prepared = mtk_pll_is_prepared,
|
||||
.prepare = mtk_pll_prepare,
|
||||
.unprepare = mtk_pll_unprepare,
|
||||
.recalc_rate = mtk_pll_recalc_rate,
|
||||
.round_rate = mtk_pll_round_rate,
|
||||
.set_rate = mtk_pll_set_rate,
|
||||
};
|
||||
|
||||
static struct clk *mtk_clk_register_pll(const struct mtk_pll_data *data,
|
||||
void __iomem *base)
|
||||
{
|
||||
struct mtk_clk_pll *pll;
|
||||
struct clk_init_data init = {};
|
||||
struct clk *clk;
|
||||
const char *parent_name = "clk26m";
|
||||
|
||||
pll = kzalloc(sizeof(*pll), GFP_KERNEL);
|
||||
if (!pll)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
pll->base_addr = base + data->reg;
|
||||
pll->pwr_addr = base + data->pwr_reg;
|
||||
pll->pd_addr = base + data->pd_reg;
|
||||
pll->pcw_addr = base + data->pcw_reg;
|
||||
if (data->tuner_reg)
|
||||
pll->tuner_addr = base + data->tuner_reg;
|
||||
pll->hw.init = &init;
|
||||
pll->data = data;
|
||||
|
||||
init.name = data->name;
|
||||
init.ops = &mtk_pll_ops;
|
||||
init.parent_names = &parent_name;
|
||||
init.num_parents = 1;
|
||||
|
||||
clk = clk_register(NULL, &pll->hw);
|
||||
|
||||
if (IS_ERR(clk))
|
||||
kfree(pll);
|
||||
|
||||
return clk;
|
||||
}
|
||||
|
||||
void __init mtk_clk_register_plls(struct device_node *node,
|
||||
const struct mtk_pll_data *plls, int num_plls, struct clk_onecell_data *clk_data)
|
||||
{
|
||||
void __iomem *base;
|
||||
int r, i;
|
||||
struct clk *clk;
|
||||
|
||||
base = of_iomap(node, 0);
|
||||
if (!base) {
|
||||
pr_err("%s(): ioremap failed\n", __func__);
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < num_plls; i++) {
|
||||
const struct mtk_pll_data *pll = &plls[i];
|
||||
|
||||
clk = mtk_clk_register_pll(pll, base);
|
||||
|
||||
if (IS_ERR(clk)) {
|
||||
pr_err("Failed to register clk %s: %ld\n",
|
||||
pll->name, PTR_ERR(clk));
|
||||
continue;
|
||||
}
|
||||
|
||||
clk_data->clks[pll->id] = clk;
|
||||
}
|
||||
|
||||
r = of_clk_add_provider(node, of_clk_src_onecell_get, clk_data);
|
||||
if (r)
|
||||
pr_err("%s(): could not register clock provider: %d\n",
|
||||
__func__, r);
|
||||
}
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
/*
|
||||
* Copyright (c) 2014 MediaTek Inc.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#include <linux/mfd/syscon.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/regmap.h>
|
||||
#include <linux/reset-controller.h>
|
||||
#include <linux/slab.h>
|
||||
|
||||
#include "clk-mtk.h"
|
||||
|
||||
struct mtk_reset {
|
||||
struct regmap *regmap;
|
||||
int regofs;
|
||||
struct reset_controller_dev rcdev;
|
||||
};
|
||||
|
||||
static int mtk_reset_assert(struct reset_controller_dev *rcdev,
|
||||
unsigned long id)
|
||||
{
|
||||
struct mtk_reset *data = container_of(rcdev, struct mtk_reset, rcdev);
|
||||
|
||||
return regmap_update_bits(data->regmap, data->regofs + ((id / 32) << 2),
|
||||
BIT(id % 32), ~0);
|
||||
}
|
||||
|
||||
static int mtk_reset_deassert(struct reset_controller_dev *rcdev,
|
||||
unsigned long id)
|
||||
{
|
||||
struct mtk_reset *data = container_of(rcdev, struct mtk_reset, rcdev);
|
||||
|
||||
return regmap_update_bits(data->regmap, data->regofs + ((id / 32) << 2),
|
||||
BIT(id % 32), 0);
|
||||
}
|
||||
|
||||
static int mtk_reset(struct reset_controller_dev *rcdev,
|
||||
unsigned long id)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = mtk_reset_assert(rcdev, id);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
return mtk_reset_deassert(rcdev, id);
|
||||
}
|
||||
|
||||
static struct reset_control_ops mtk_reset_ops = {
|
||||
.assert = mtk_reset_assert,
|
||||
.deassert = mtk_reset_deassert,
|
||||
.reset = mtk_reset,
|
||||
};
|
||||
|
||||
void mtk_register_reset_controller(struct device_node *np,
|
||||
unsigned int num_regs, int regofs)
|
||||
{
|
||||
struct mtk_reset *data;
|
||||
int ret;
|
||||
struct regmap *regmap;
|
||||
|
||||
regmap = syscon_node_to_regmap(np);
|
||||
if (IS_ERR(regmap)) {
|
||||
pr_err("Cannot find regmap for %s: %ld\n", np->full_name,
|
||||
PTR_ERR(regmap));
|
||||
return;
|
||||
}
|
||||
|
||||
data = kzalloc(sizeof(*data), GFP_KERNEL);
|
||||
if (!data)
|
||||
return;
|
||||
|
||||
data->regmap = regmap;
|
||||
data->regofs = regofs;
|
||||
data->rcdev.owner = THIS_MODULE;
|
||||
data->rcdev.nr_resets = num_regs * 32;
|
||||
data->rcdev.ops = &mtk_reset_ops;
|
||||
data->rcdev.of_node = np;
|
||||
|
||||
ret = reset_controller_register(&data->rcdev);
|
||||
if (ret) {
|
||||
pr_err("could not register reset controller: %d\n", ret);
|
||||
kfree(data);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
#
|
||||
# Makefile for Meson specific clk
|
||||
#
|
||||
|
||||
obj-y += clkc.o clk-pll.o clk-cpu.o
|
||||
obj-y += meson8b-clkc.o
|
||||
|
|
@ -0,0 +1,242 @@
|
|||
/*
|
||||
* Copyright (c) 2015 Endless Mobile, Inc.
|
||||
* Author: Carlo Caione <carlo@endlessm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with
|
||||
* this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/*
|
||||
* CPU clock path:
|
||||
*
|
||||
* +-[/N]-----|3|
|
||||
* MUX2 +--[/3]-+----------|2| MUX1
|
||||
* [sys_pll]---|1| |--[/2]------------|1|-|1|
|
||||
* | |---+------------------|0| | |----- [a5_clk]
|
||||
* +--|0| | |
|
||||
* [xtal]---+-------------------------------|0|
|
||||
*
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/delay.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/of_address.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/clk-provider.h>
|
||||
|
||||
#define MESON_CPU_CLK_CNTL1 0x00
|
||||
#define MESON_CPU_CLK_CNTL 0x40
|
||||
|
||||
#define MESON_CPU_CLK_MUX1 BIT(7)
|
||||
#define MESON_CPU_CLK_MUX2 BIT(0)
|
||||
|
||||
#define MESON_N_WIDTH 9
|
||||
#define MESON_N_SHIFT 20
|
||||
#define MESON_SEL_WIDTH 2
|
||||
#define MESON_SEL_SHIFT 2
|
||||
|
||||
#include "clkc.h"
|
||||
|
||||
struct meson_clk_cpu {
|
||||
struct notifier_block clk_nb;
|
||||
const struct clk_div_table *div_table;
|
||||
struct clk_hw hw;
|
||||
void __iomem *base;
|
||||
u16 reg_off;
|
||||
};
|
||||
#define to_meson_clk_cpu_hw(_hw) container_of(_hw, struct meson_clk_cpu, hw)
|
||||
#define to_meson_clk_cpu_nb(_nb) container_of(_nb, struct meson_clk_cpu, clk_nb)
|
||||
|
||||
static long meson_clk_cpu_round_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long *prate)
|
||||
{
|
||||
struct meson_clk_cpu *clk_cpu = to_meson_clk_cpu_hw(hw);
|
||||
|
||||
return divider_round_rate(hw, rate, prate, clk_cpu->div_table,
|
||||
MESON_N_WIDTH, CLK_DIVIDER_ROUND_CLOSEST);
|
||||
}
|
||||
|
||||
static int meson_clk_cpu_set_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct meson_clk_cpu *clk_cpu = to_meson_clk_cpu_hw(hw);
|
||||
unsigned int div, sel, N = 0;
|
||||
u32 reg;
|
||||
|
||||
div = DIV_ROUND_UP(parent_rate, rate);
|
||||
|
||||
if (div <= 3) {
|
||||
sel = div - 1;
|
||||
} else {
|
||||
sel = 3;
|
||||
N = div / 2;
|
||||
}
|
||||
|
||||
reg = readl(clk_cpu->base + clk_cpu->reg_off + MESON_CPU_CLK_CNTL1);
|
||||
reg = PARM_SET(MESON_N_WIDTH, MESON_N_SHIFT, reg, N);
|
||||
writel(reg, clk_cpu->base + clk_cpu->reg_off + MESON_CPU_CLK_CNTL1);
|
||||
|
||||
reg = readl(clk_cpu->base + clk_cpu->reg_off + MESON_CPU_CLK_CNTL);
|
||||
reg = PARM_SET(MESON_SEL_WIDTH, MESON_SEL_SHIFT, reg, sel);
|
||||
writel(reg, clk_cpu->base + clk_cpu->reg_off + MESON_CPU_CLK_CNTL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static unsigned long meson_clk_cpu_recalc_rate(struct clk_hw *hw,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct meson_clk_cpu *clk_cpu = to_meson_clk_cpu_hw(hw);
|
||||
unsigned int N, sel;
|
||||
unsigned int div = 1;
|
||||
u32 reg;
|
||||
|
||||
reg = readl(clk_cpu->base + clk_cpu->reg_off + MESON_CPU_CLK_CNTL1);
|
||||
N = PARM_GET(MESON_N_WIDTH, MESON_N_SHIFT, reg);
|
||||
|
||||
reg = readl(clk_cpu->base + clk_cpu->reg_off + MESON_CPU_CLK_CNTL);
|
||||
sel = PARM_GET(MESON_SEL_WIDTH, MESON_SEL_SHIFT, reg);
|
||||
|
||||
if (sel < 3)
|
||||
div = sel + 1;
|
||||
else
|
||||
div = 2 * N;
|
||||
|
||||
return parent_rate / div;
|
||||
}
|
||||
|
||||
static int meson_clk_cpu_pre_rate_change(struct meson_clk_cpu *clk_cpu,
|
||||
struct clk_notifier_data *ndata)
|
||||
{
|
||||
u32 cpu_clk_cntl;
|
||||
|
||||
/* switch MUX1 to xtal */
|
||||
cpu_clk_cntl = readl(clk_cpu->base + clk_cpu->reg_off
|
||||
+ MESON_CPU_CLK_CNTL);
|
||||
cpu_clk_cntl &= ~MESON_CPU_CLK_MUX1;
|
||||
writel(cpu_clk_cntl, clk_cpu->base + clk_cpu->reg_off
|
||||
+ MESON_CPU_CLK_CNTL);
|
||||
udelay(100);
|
||||
|
||||
/* switch MUX2 to sys-pll */
|
||||
cpu_clk_cntl |= MESON_CPU_CLK_MUX2;
|
||||
writel(cpu_clk_cntl, clk_cpu->base + clk_cpu->reg_off
|
||||
+ MESON_CPU_CLK_CNTL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int meson_clk_cpu_post_rate_change(struct meson_clk_cpu *clk_cpu,
|
||||
struct clk_notifier_data *ndata)
|
||||
{
|
||||
u32 cpu_clk_cntl;
|
||||
|
||||
/* switch MUX1 to divisors' output */
|
||||
cpu_clk_cntl = readl(clk_cpu->base + clk_cpu->reg_off
|
||||
+ MESON_CPU_CLK_CNTL);
|
||||
cpu_clk_cntl |= MESON_CPU_CLK_MUX1;
|
||||
writel(cpu_clk_cntl, clk_cpu->base + clk_cpu->reg_off
|
||||
+ MESON_CPU_CLK_CNTL);
|
||||
udelay(100);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* This clock notifier is called when the frequency of the of the parent
|
||||
* PLL clock is to be changed. We use the xtal input as temporary parent
|
||||
* while the PLL frequency is stabilized.
|
||||
*/
|
||||
static int meson_clk_cpu_notifier_cb(struct notifier_block *nb,
|
||||
unsigned long event, void *data)
|
||||
{
|
||||
struct clk_notifier_data *ndata = data;
|
||||
struct meson_clk_cpu *clk_cpu = to_meson_clk_cpu_nb(nb);
|
||||
int ret = 0;
|
||||
|
||||
if (event == PRE_RATE_CHANGE)
|
||||
ret = meson_clk_cpu_pre_rate_change(clk_cpu, ndata);
|
||||
else if (event == POST_RATE_CHANGE)
|
||||
ret = meson_clk_cpu_post_rate_change(clk_cpu, ndata);
|
||||
|
||||
return notifier_from_errno(ret);
|
||||
}
|
||||
|
||||
static const struct clk_ops meson_clk_cpu_ops = {
|
||||
.recalc_rate = meson_clk_cpu_recalc_rate,
|
||||
.round_rate = meson_clk_cpu_round_rate,
|
||||
.set_rate = meson_clk_cpu_set_rate,
|
||||
};
|
||||
|
||||
struct clk *meson_clk_register_cpu(const struct clk_conf *clk_conf,
|
||||
void __iomem *reg_base,
|
||||
spinlock_t *lock)
|
||||
{
|
||||
struct clk *clk;
|
||||
struct clk *pclk;
|
||||
struct meson_clk_cpu *clk_cpu;
|
||||
struct clk_init_data init;
|
||||
int ret;
|
||||
|
||||
clk_cpu = kzalloc(sizeof(*clk_cpu), GFP_KERNEL);
|
||||
if (!clk_cpu)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
clk_cpu->base = reg_base;
|
||||
clk_cpu->reg_off = clk_conf->reg_off;
|
||||
clk_cpu->div_table = clk_conf->conf.div_table;
|
||||
clk_cpu->clk_nb.notifier_call = meson_clk_cpu_notifier_cb;
|
||||
|
||||
init.name = clk_conf->clk_name;
|
||||
init.ops = &meson_clk_cpu_ops;
|
||||
init.flags = clk_conf->flags | CLK_GET_RATE_NOCACHE;
|
||||
init.flags |= CLK_SET_RATE_PARENT;
|
||||
init.parent_names = clk_conf->clks_parent;
|
||||
init.num_parents = 1;
|
||||
|
||||
clk_cpu->hw.init = &init;
|
||||
|
||||
pclk = __clk_lookup(clk_conf->clks_parent[0]);
|
||||
if (!pclk) {
|
||||
pr_err("%s: could not lookup parent clock %s\n",
|
||||
__func__, clk_conf->clks_parent[0]);
|
||||
ret = -EINVAL;
|
||||
goto free_clk;
|
||||
}
|
||||
|
||||
ret = clk_notifier_register(pclk, &clk_cpu->clk_nb);
|
||||
if (ret) {
|
||||
pr_err("%s: failed to register clock notifier for %s\n",
|
||||
__func__, clk_conf->clk_name);
|
||||
goto free_clk;
|
||||
}
|
||||
|
||||
clk = clk_register(NULL, &clk_cpu->hw);
|
||||
if (IS_ERR(clk)) {
|
||||
ret = PTR_ERR(clk);
|
||||
goto unregister_clk_nb;
|
||||
}
|
||||
|
||||
return clk;
|
||||
|
||||
unregister_clk_nb:
|
||||
clk_notifier_unregister(pclk, &clk_cpu->clk_nb);
|
||||
free_clk:
|
||||
kfree(clk_cpu);
|
||||
|
||||
return ERR_PTR(ret);
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
/*
|
||||
* Copyright (c) 2015 Endless Mobile, Inc.
|
||||
* Author: Carlo Caione <carlo@endlessm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with
|
||||
* this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/*
|
||||
* In the most basic form, a Meson PLL is composed as follows:
|
||||
*
|
||||
* PLL
|
||||
* +------------------------------+
|
||||
* | |
|
||||
* in -----[ /N ]---[ *M ]---[ >>OD ]----->> out
|
||||
* | ^ ^ |
|
||||
* +------------------------------+
|
||||
* | |
|
||||
* FREF VCO
|
||||
*
|
||||
* out = (in * M / N) >> OD
|
||||
*/
|
||||
|
||||
#include <linux/clk-provider.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/of_address.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/string.h>
|
||||
|
||||
#include "clkc.h"
|
||||
|
||||
#define MESON_PLL_RESET BIT(29)
|
||||
#define MESON_PLL_LOCK BIT(31)
|
||||
|
||||
struct meson_clk_pll {
|
||||
struct clk_hw hw;
|
||||
void __iomem *base;
|
||||
struct pll_conf *conf;
|
||||
unsigned int rate_count;
|
||||
spinlock_t *lock;
|
||||
};
|
||||
#define to_meson_clk_pll(_hw) container_of(_hw, struct meson_clk_pll, hw)
|
||||
|
||||
static unsigned long meson_clk_pll_recalc_rate(struct clk_hw *hw,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct meson_clk_pll *pll = to_meson_clk_pll(hw);
|
||||
struct parm *p;
|
||||
unsigned long parent_rate_mhz = parent_rate / 1000000;
|
||||
unsigned long rate_mhz;
|
||||
u16 n, m, od;
|
||||
u32 reg;
|
||||
|
||||
p = &pll->conf->n;
|
||||
reg = readl(pll->base + p->reg_off);
|
||||
n = PARM_GET(p->width, p->shift, reg);
|
||||
|
||||
p = &pll->conf->m;
|
||||
reg = readl(pll->base + p->reg_off);
|
||||
m = PARM_GET(p->width, p->shift, reg);
|
||||
|
||||
p = &pll->conf->od;
|
||||
reg = readl(pll->base + p->reg_off);
|
||||
od = PARM_GET(p->width, p->shift, reg);
|
||||
|
||||
rate_mhz = (parent_rate_mhz * m / n) >> od;
|
||||
|
||||
return rate_mhz * 1000000;
|
||||
}
|
||||
|
||||
static long meson_clk_pll_round_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long *parent_rate)
|
||||
{
|
||||
struct meson_clk_pll *pll = to_meson_clk_pll(hw);
|
||||
const struct pll_rate_table *rate_table = pll->conf->rate_table;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < pll->rate_count; i++) {
|
||||
if (rate <= rate_table[i].rate)
|
||||
return rate_table[i].rate;
|
||||
}
|
||||
|
||||
/* else return the smallest value */
|
||||
return rate_table[0].rate;
|
||||
}
|
||||
|
||||
static const struct pll_rate_table *meson_clk_get_pll_settings(struct meson_clk_pll *pll,
|
||||
unsigned long rate)
|
||||
{
|
||||
const struct pll_rate_table *rate_table = pll->conf->rate_table;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < pll->rate_count; i++) {
|
||||
if (rate == rate_table[i].rate)
|
||||
return &rate_table[i];
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int meson_clk_pll_wait_lock(struct meson_clk_pll *pll,
|
||||
struct parm *p_n)
|
||||
{
|
||||
int delay = 24000000;
|
||||
u32 reg;
|
||||
|
||||
while (delay > 0) {
|
||||
reg = readl(pll->base + p_n->reg_off);
|
||||
|
||||
if (reg & MESON_PLL_LOCK)
|
||||
return 0;
|
||||
delay--;
|
||||
}
|
||||
return -ETIMEDOUT;
|
||||
}
|
||||
|
||||
static int meson_clk_pll_set_rate(struct clk_hw *hw, unsigned long rate,
|
||||
unsigned long parent_rate)
|
||||
{
|
||||
struct meson_clk_pll *pll = to_meson_clk_pll(hw);
|
||||
struct parm *p;
|
||||
const struct pll_rate_table *rate_set;
|
||||
unsigned long old_rate;
|
||||
int ret = 0;
|
||||
u32 reg;
|
||||
|
||||
if (parent_rate == 0 || rate == 0)
|
||||
return -EINVAL;
|
||||
|
||||
old_rate = rate;
|
||||
|
||||
rate_set = meson_clk_get_pll_settings(pll, rate);
|
||||
if (!rate_set)
|
||||
return -EINVAL;
|
||||
|
||||
/* PLL reset */
|
||||
p = &pll->conf->n;
|
||||
reg = readl(pll->base + p->reg_off);
|
||||
writel(reg | MESON_PLL_RESET, pll->base + p->reg_off);
|
||||
|
||||
reg = PARM_SET(p->width, p->shift, reg, rate_set->n);
|
||||
writel(reg, pll->base + p->reg_off);
|
||||
|
||||
p = &pll->conf->m;
|
||||
reg = readl(pll->base + p->reg_off);
|
||||
reg = PARM_SET(p->width, p->shift, reg, rate_set->m);
|
||||
writel(reg, pll->base + p->reg_off);
|
||||
|
||||
p = &pll->conf->od;
|
||||
reg = readl(pll->base + p->reg_off);
|
||||
reg = PARM_SET(p->width, p->shift, reg, rate_set->od);
|
||||
writel(reg, pll->base + p->reg_off);
|
||||
|
||||
p = &pll->conf->n;
|
||||
ret = meson_clk_pll_wait_lock(pll, p);
|
||||
if (ret) {
|
||||
pr_warn("%s: pll did not lock, trying to restore old rate %lu\n",
|
||||
__func__, old_rate);
|
||||
meson_clk_pll_set_rate(hw, old_rate, parent_rate);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static const struct clk_ops meson_clk_pll_ops = {
|
||||
.recalc_rate = meson_clk_pll_recalc_rate,
|
||||
.round_rate = meson_clk_pll_round_rate,
|
||||
.set_rate = meson_clk_pll_set_rate,
|
||||
};
|
||||
|
||||
static const struct clk_ops meson_clk_pll_ro_ops = {
|
||||
.recalc_rate = meson_clk_pll_recalc_rate,
|
||||
};
|
||||
|
||||
struct clk *meson_clk_register_pll(const struct clk_conf *clk_conf,
|
||||
void __iomem *reg_base,
|
||||
spinlock_t *lock)
|
||||
{
|
||||
struct clk *clk;
|
||||
struct meson_clk_pll *clk_pll;
|
||||
struct clk_init_data init;
|
||||
|
||||
clk_pll = kzalloc(sizeof(*clk_pll), GFP_KERNEL);
|
||||
if (!clk_pll)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
clk_pll->base = reg_base + clk_conf->reg_off;
|
||||
clk_pll->lock = lock;
|
||||
clk_pll->conf = clk_conf->conf.pll;
|
||||
|
||||
init.name = clk_conf->clk_name;
|
||||
init.flags = clk_conf->flags | CLK_GET_RATE_NOCACHE;
|
||||
|
||||
init.parent_names = &clk_conf->clks_parent[0];
|
||||
init.num_parents = 1;
|
||||
init.ops = &meson_clk_pll_ro_ops;
|
||||
|
||||
/* If no rate_table is specified we assume the PLL is read-only */
|
||||
if (clk_pll->conf->rate_table) {
|
||||
int len;
|
||||
|
||||
for (len = 0; clk_pll->conf->rate_table[len].rate != 0; )
|
||||
len++;
|
||||
|
||||
clk_pll->rate_count = len;
|
||||
init.ops = &meson_clk_pll_ops;
|
||||
}
|
||||
|
||||
clk_pll->hw.init = &init;
|
||||
|
||||
clk = clk_register(NULL, &clk_pll->hw);
|
||||
if (IS_ERR(clk))
|
||||
kfree(clk_pll);
|
||||
|
||||
return clk;
|
||||
}
|
||||
|
|
@ -0,0 +1,250 @@
|
|||
/*
|
||||
* Copyright (c) 2015 Endless Mobile, Inc.
|
||||
* Author: Carlo Caione <carlo@endlessm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with
|
||||
* this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <linux/clk.h>
|
||||
#include <linux/clk-provider.h>
|
||||
#include <linux/mfd/syscon.h>
|
||||
#include <linux/slab.h>
|
||||
|
||||
#include "clkc.h"
|
||||
|
||||
static DEFINE_SPINLOCK(clk_lock);
|
||||
|
||||
static struct clk **clks;
|
||||
static struct clk_onecell_data clk_data;
|
||||
|
||||
struct clk ** __init meson_clk_init(struct device_node *np,
|
||||
unsigned long nr_clks)
|
||||
{
|
||||
clks = kcalloc(nr_clks, sizeof(*clks), GFP_KERNEL);
|
||||
if (!clks)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
clk_data.clks = clks;
|
||||
clk_data.clk_num = nr_clks;
|
||||
of_clk_add_provider(np, of_clk_src_onecell_get, &clk_data);
|
||||
|
||||
return clks;
|
||||
}
|
||||
|
||||
static void meson_clk_add_lookup(struct clk *clk, unsigned int id)
|
||||
{
|
||||
if (clks && id)
|
||||
clks[id] = clk;
|
||||
}
|
||||
|
||||
static struct clk * __init
|
||||
meson_clk_register_composite(const struct clk_conf *clk_conf,
|
||||
void __iomem *clk_base)
|
||||
{
|
||||
struct clk *clk;
|
||||
struct clk_mux *mux = NULL;
|
||||
struct clk_divider *div = NULL;
|
||||
struct clk_gate *gate = NULL;
|
||||
const struct clk_ops *mux_ops = NULL;
|
||||
const struct composite_conf *composite_conf;
|
||||
|
||||
composite_conf = clk_conf->conf.composite;
|
||||
|
||||
if (clk_conf->num_parents > 1) {
|
||||
mux = kzalloc(sizeof(*mux), GFP_KERNEL);
|
||||
if (!mux)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
mux->reg = clk_base + clk_conf->reg_off
|
||||
+ composite_conf->mux_parm.reg_off;
|
||||
mux->shift = composite_conf->mux_parm.shift;
|
||||
mux->mask = BIT(composite_conf->mux_parm.width) - 1;
|
||||
mux->flags = composite_conf->mux_flags;
|
||||
mux->lock = &clk_lock;
|
||||
mux->table = composite_conf->mux_table;
|
||||
mux_ops = (composite_conf->mux_flags & CLK_MUX_READ_ONLY) ?
|
||||
&clk_mux_ro_ops : &clk_mux_ops;
|
||||
}
|
||||
|
||||
if (MESON_PARM_APPLICABLE(&composite_conf->div_parm)) {
|
||||
div = kzalloc(sizeof(*div), GFP_KERNEL);
|
||||
if (!div) {
|
||||
clk = ERR_PTR(-ENOMEM);
|
||||
goto error;
|
||||
}
|
||||
|
||||
div->reg = clk_base + clk_conf->reg_off
|
||||
+ composite_conf->div_parm.reg_off;
|
||||
div->shift = composite_conf->div_parm.shift;
|
||||
div->width = composite_conf->div_parm.width;
|
||||
div->lock = &clk_lock;
|
||||
div->flags = composite_conf->div_flags;
|
||||
div->table = composite_conf->div_table;
|
||||
}
|
||||
|
||||
if (MESON_PARM_APPLICABLE(&composite_conf->gate_parm)) {
|
||||
gate = kzalloc(sizeof(*gate), GFP_KERNEL);
|
||||
if (!gate) {
|
||||
clk = ERR_PTR(-ENOMEM);
|
||||
goto error;
|
||||
}
|
||||
|
||||
gate->reg = clk_base + clk_conf->reg_off
|
||||
+ composite_conf->div_parm.reg_off;
|
||||
gate->bit_idx = composite_conf->gate_parm.shift;
|
||||
gate->flags = composite_conf->gate_flags;
|
||||
gate->lock = &clk_lock;
|
||||
}
|
||||
|
||||
clk = clk_register_composite(NULL, clk_conf->clk_name,
|
||||
clk_conf->clks_parent,
|
||||
clk_conf->num_parents,
|
||||
mux ? &mux->hw : NULL, mux_ops,
|
||||
div ? &div->hw : NULL, &clk_divider_ops,
|
||||
gate ? &gate->hw : NULL, &clk_gate_ops,
|
||||
clk_conf->flags);
|
||||
if (IS_ERR(clk))
|
||||
goto error;
|
||||
|
||||
return clk;
|
||||
|
||||
error:
|
||||
kfree(gate);
|
||||
kfree(div);
|
||||
kfree(mux);
|
||||
|
||||
return clk;
|
||||
}
|
||||
|
||||
static struct clk * __init
|
||||
meson_clk_register_fixed_factor(const struct clk_conf *clk_conf,
|
||||
void __iomem *clk_base)
|
||||
{
|
||||
struct clk *clk;
|
||||
const struct fixed_fact_conf *fixed_fact_conf;
|
||||
const struct parm *p;
|
||||
unsigned int mult, div;
|
||||
u32 reg;
|
||||
|
||||
fixed_fact_conf = &clk_conf->conf.fixed_fact;
|
||||
|
||||
mult = clk_conf->conf.fixed_fact.mult;
|
||||
div = clk_conf->conf.fixed_fact.div;
|
||||
|
||||
if (!mult) {
|
||||
mult = 1;
|
||||
p = &fixed_fact_conf->mult_parm;
|
||||
if (MESON_PARM_APPLICABLE(p)) {
|
||||
reg = readl(clk_base + clk_conf->reg_off + p->reg_off);
|
||||
mult = PARM_GET(p->width, p->shift, reg);
|
||||
}
|
||||
}
|
||||
|
||||
if (!div) {
|
||||
div = 1;
|
||||
p = &fixed_fact_conf->div_parm;
|
||||
if (MESON_PARM_APPLICABLE(p)) {
|
||||
reg = readl(clk_base + clk_conf->reg_off + p->reg_off);
|
||||
mult = PARM_GET(p->width, p->shift, reg);
|
||||
}
|
||||
}
|
||||
|
||||
clk = clk_register_fixed_factor(NULL,
|
||||
clk_conf->clk_name,
|
||||
clk_conf->clks_parent[0],
|
||||
clk_conf->flags,
|
||||
mult, div);
|
||||
|
||||
return clk;
|
||||
}
|
||||
|
||||
static struct clk * __init
|
||||
meson_clk_register_fixed_rate(const struct clk_conf *clk_conf,
|
||||
void __iomem *clk_base)
|
||||
{
|
||||
struct clk *clk;
|
||||
const struct fixed_rate_conf *fixed_rate_conf;
|
||||
const struct parm *r;
|
||||
unsigned long rate;
|
||||
u32 reg;
|
||||
|
||||
fixed_rate_conf = &clk_conf->conf.fixed_rate;
|
||||
rate = fixed_rate_conf->rate;
|
||||
|
||||
if (!rate) {
|
||||
r = &fixed_rate_conf->rate_parm;
|
||||
reg = readl(clk_base + clk_conf->reg_off + r->reg_off);
|
||||
rate = PARM_GET(r->width, r->shift, reg);
|
||||
}
|
||||
|
||||
rate *= 1000000;
|
||||
|
||||
clk = clk_register_fixed_rate(NULL,
|
||||
clk_conf->clk_name,
|
||||
clk_conf->num_parents
|
||||
? clk_conf->clks_parent[0] : NULL,
|
||||
clk_conf->flags, rate);
|
||||
|
||||
return clk;
|
||||
}
|
||||
|
||||
void __init meson_clk_register_clks(const struct clk_conf *clk_confs,
|
||||
size_t nr_confs,
|
||||
void __iomem *clk_base)
|
||||
{
|
||||
unsigned int i;
|
||||
struct clk *clk = NULL;
|
||||
|
||||
for (i = 0; i < nr_confs; i++) {
|
||||
const struct clk_conf *clk_conf = &clk_confs[i];
|
||||
|
||||
switch (clk_conf->clk_type) {
|
||||
case CLK_FIXED_RATE:
|
||||
clk = meson_clk_register_fixed_rate(clk_conf,
|
||||
clk_base);
|
||||
break;
|
||||
case CLK_FIXED_FACTOR:
|
||||
clk = meson_clk_register_fixed_factor(clk_conf,
|
||||
clk_base);
|
||||
break;
|
||||
case CLK_COMPOSITE:
|
||||
clk = meson_clk_register_composite(clk_conf,
|
||||
clk_base);
|
||||
break;
|
||||
case CLK_CPU:
|
||||
clk = meson_clk_register_cpu(clk_conf, clk_base,
|
||||
&clk_lock);
|
||||
break;
|
||||
case CLK_PLL:
|
||||
clk = meson_clk_register_pll(clk_conf, clk_base,
|
||||
&clk_lock);
|
||||
break;
|
||||
default:
|
||||
clk = NULL;
|
||||
}
|
||||
|
||||
if (!clk) {
|
||||
pr_err("%s: unknown clock type %d\n", __func__,
|
||||
clk_conf->clk_type);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (IS_ERR(clk)) {
|
||||
pr_warn("%s: Unable to create %s clock\n", __func__,
|
||||
clk_conf->clk_name);
|
||||
continue;
|
||||
}
|
||||
|
||||
meson_clk_add_lookup(clk, clk_conf->clk_id);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,187 @@
|
|||
/*
|
||||
* Copyright (c) 2015 Endless Mobile, Inc.
|
||||
* Author: Carlo Caione <carlo@endlessm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with
|
||||
* this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef __CLKC_H
|
||||
#define __CLKC_H
|
||||
|
||||
#define PMASK(width) GENMASK(width - 1, 0)
|
||||
#define SETPMASK(width, shift) GENMASK(shift + width - 1, shift)
|
||||
#define CLRPMASK(width, shift) (~SETPMASK(width, shift))
|
||||
|
||||
#define PARM_GET(width, shift, reg) \
|
||||
(((reg) & SETPMASK(width, shift)) >> (shift))
|
||||
#define PARM_SET(width, shift, reg, val) \
|
||||
(((reg) & CLRPMASK(width, shift)) | (val << (shift)))
|
||||
|
||||
#define MESON_PARM_APPLICABLE(p) (!!((p)->width))
|
||||
|
||||
struct parm {
|
||||
u16 reg_off;
|
||||
u8 shift;
|
||||
u8 width;
|
||||
};
|
||||
#define PARM(_r, _s, _w) \
|
||||
{ \
|
||||
.reg_off = (_r), \
|
||||
.shift = (_s), \
|
||||
.width = (_w), \
|
||||
} \
|
||||
|
||||
struct pll_rate_table {
|
||||
unsigned long rate;
|
||||
u16 m;
|
||||
u16 n;
|
||||
u16 od;
|
||||
};
|
||||
#define PLL_RATE(_r, _m, _n, _od) \
|
||||
{ \
|
||||
.rate = (_r), \
|
||||
.m = (_m), \
|
||||
.n = (_n), \
|
||||
.od = (_od), \
|
||||
} \
|
||||
|
||||
struct pll_conf {
|
||||
const struct pll_rate_table *rate_table;
|
||||
struct parm m;
|
||||
struct parm n;
|
||||
struct parm od;
|
||||
};
|
||||
|
||||
struct fixed_fact_conf {
|
||||
unsigned int div;
|
||||
unsigned int mult;
|
||||
struct parm div_parm;
|
||||
struct parm mult_parm;
|
||||
};
|
||||
|
||||
struct fixed_rate_conf {
|
||||
unsigned long rate;
|
||||
struct parm rate_parm;
|
||||
};
|
||||
|
||||
struct composite_conf {
|
||||
struct parm mux_parm;
|
||||
struct parm div_parm;
|
||||
struct parm gate_parm;
|
||||
struct clk_div_table *div_table;
|
||||
u32 *mux_table;
|
||||
u8 mux_flags;
|
||||
u8 div_flags;
|
||||
u8 gate_flags;
|
||||
};
|
||||
|
||||
#define PNAME(x) static const char *x[]
|
||||
|
||||
enum clk_type {
|
||||
CLK_FIXED_FACTOR,
|
||||
CLK_FIXED_RATE,
|
||||
CLK_COMPOSITE,
|
||||
CLK_CPU,
|
||||
CLK_PLL,
|
||||
};
|
||||
|
||||
struct clk_conf {
|
||||
u16 reg_off;
|
||||
enum clk_type clk_type;
|
||||
unsigned int clk_id;
|
||||
const char *clk_name;
|
||||
const char **clks_parent;
|
||||
int num_parents;
|
||||
unsigned long flags;
|
||||
union {
|
||||
struct fixed_fact_conf fixed_fact;
|
||||
struct fixed_rate_conf fixed_rate;
|
||||
const struct composite_conf *composite;
|
||||
struct pll_conf *pll;
|
||||
const struct clk_div_table *div_table;
|
||||
} conf;
|
||||
};
|
||||
|
||||
#define FIXED_RATE_P(_ro, _ci, _cn, _f, _c) \
|
||||
{ \
|
||||
.reg_off = (_ro), \
|
||||
.clk_type = CLK_FIXED_RATE, \
|
||||
.clk_id = (_ci), \
|
||||
.clk_name = (_cn), \
|
||||
.flags = (_f), \
|
||||
.conf.fixed_rate.rate_parm = _c, \
|
||||
} \
|
||||
|
||||
#define FIXED_RATE(_ci, _cn, _f, _r) \
|
||||
{ \
|
||||
.clk_type = CLK_FIXED_RATE, \
|
||||
.clk_id = (_ci), \
|
||||
.clk_name = (_cn), \
|
||||
.flags = (_f), \
|
||||
.conf.fixed_rate.rate = (_r), \
|
||||
} \
|
||||
|
||||
#define PLL(_ro, _ci, _cn, _cp, _f, _c) \
|
||||
{ \
|
||||
.reg_off = (_ro), \
|
||||
.clk_type = CLK_PLL, \
|
||||
.clk_id = (_ci), \
|
||||
.clk_name = (_cn), \
|
||||
.clks_parent = (_cp), \
|
||||
.num_parents = ARRAY_SIZE(_cp), \
|
||||
.flags = (_f), \
|
||||
.conf.pll = (_c), \
|
||||
} \
|
||||
|
||||
#define FIXED_FACTOR_DIV(_ci, _cn, _cp, _f, _d) \
|
||||
{ \
|
||||
.clk_type = CLK_FIXED_FACTOR, \
|
||||
.clk_id = (_ci), \
|
||||
.clk_name = (_cn), \
|
||||
.clks_parent = (_cp), \
|
||||
.num_parents = ARRAY_SIZE(_cp), \
|
||||
.conf.fixed_fact.div = (_d), \
|
||||
} \
|
||||
|
||||
#define CPU(_ro, _ci, _cn, _cp, _dt) \
|
||||
{ \
|
||||
.reg_off = (_ro), \
|
||||
.clk_type = CLK_CPU, \
|
||||
.clk_id = (_ci), \
|
||||
.clk_name = (_cn), \
|
||||
.clks_parent = (_cp), \
|
||||
.num_parents = ARRAY_SIZE(_cp), \
|
||||
.conf.div_table = (_dt), \
|
||||
} \
|
||||
|
||||
#define COMPOSITE(_ro, _ci, _cn, _cp, _f, _c) \
|
||||
{ \
|
||||
.reg_off = (_ro), \
|
||||
.clk_type = CLK_COMPOSITE, \
|
||||
.clk_id = (_ci), \
|
||||
.clk_name = (_cn), \
|
||||
.clks_parent = (_cp), \
|
||||
.num_parents = ARRAY_SIZE(_cp), \
|
||||
.flags = (_f), \
|
||||
.conf.composite = (_c), \
|
||||
} \
|
||||
|
||||
struct clk **meson_clk_init(struct device_node *np, unsigned long nr_clks);
|
||||
void meson_clk_register_clks(const struct clk_conf *clk_confs,
|
||||
unsigned int nr_confs, void __iomem *clk_base);
|
||||
struct clk *meson_clk_register_cpu(const struct clk_conf *clk_conf,
|
||||
void __iomem *reg_base, spinlock_t *lock);
|
||||
struct clk *meson_clk_register_pll(const struct clk_conf *clk_conf,
|
||||
void __iomem *reg_base, spinlock_t *lock);
|
||||
|
||||
#endif /* __CLKC_H */
|
||||
|
|
@ -0,0 +1,196 @@
|
|||
/*
|
||||
* Copyright (c) 2015 Endless Mobile, Inc.
|
||||
* Author: Carlo Caione <carlo@endlessm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with
|
||||
* this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <linux/clk-provider.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_address.h>
|
||||
#include <linux/slab.h>
|
||||
#include <dt-bindings/clock/meson8b-clkc.h>
|
||||
|
||||
#include "clkc.h"
|
||||
|
||||
#define MESON8B_REG_CTL0_ADDR 0x0000
|
||||
#define MESON8B_REG_SYS_CPU_CNTL1 0x015c
|
||||
#define MESON8B_REG_HHI_MPEG 0x0174
|
||||
#define MESON8B_REG_MALI 0x01b0
|
||||
#define MESON8B_REG_PLL_FIXED 0x0280
|
||||
#define MESON8B_REG_PLL_SYS 0x0300
|
||||
#define MESON8B_REG_PLL_VID 0x0320
|
||||
|
||||
static const struct pll_rate_table sys_pll_rate_table[] = {
|
||||
PLL_RATE(312000000, 52, 1, 2),
|
||||
PLL_RATE(336000000, 56, 1, 2),
|
||||
PLL_RATE(360000000, 60, 1, 2),
|
||||
PLL_RATE(384000000, 64, 1, 2),
|
||||
PLL_RATE(408000000, 68, 1, 2),
|
||||
PLL_RATE(432000000, 72, 1, 2),
|
||||
PLL_RATE(456000000, 76, 1, 2),
|
||||
PLL_RATE(480000000, 80, 1, 2),
|
||||
PLL_RATE(504000000, 84, 1, 2),
|
||||
PLL_RATE(528000000, 88, 1, 2),
|
||||
PLL_RATE(552000000, 92, 1, 2),
|
||||
PLL_RATE(576000000, 96, 1, 2),
|
||||
PLL_RATE(600000000, 50, 1, 1),
|
||||
PLL_RATE(624000000, 52, 1, 1),
|
||||
PLL_RATE(648000000, 54, 1, 1),
|
||||
PLL_RATE(672000000, 56, 1, 1),
|
||||
PLL_RATE(696000000, 58, 1, 1),
|
||||
PLL_RATE(720000000, 60, 1, 1),
|
||||
PLL_RATE(744000000, 62, 1, 1),
|
||||
PLL_RATE(768000000, 64, 1, 1),
|
||||
PLL_RATE(792000000, 66, 1, 1),
|
||||
PLL_RATE(816000000, 68, 1, 1),
|
||||
PLL_RATE(840000000, 70, 1, 1),
|
||||
PLL_RATE(864000000, 72, 1, 1),
|
||||
PLL_RATE(888000000, 74, 1, 1),
|
||||
PLL_RATE(912000000, 76, 1, 1),
|
||||
PLL_RATE(936000000, 78, 1, 1),
|
||||
PLL_RATE(960000000, 80, 1, 1),
|
||||
PLL_RATE(984000000, 82, 1, 1),
|
||||
PLL_RATE(1008000000, 84, 1, 1),
|
||||
PLL_RATE(1032000000, 86, 1, 1),
|
||||
PLL_RATE(1056000000, 88, 1, 1),
|
||||
PLL_RATE(1080000000, 90, 1, 1),
|
||||
PLL_RATE(1104000000, 92, 1, 1),
|
||||
PLL_RATE(1128000000, 94, 1, 1),
|
||||
PLL_RATE(1152000000, 96, 1, 1),
|
||||
PLL_RATE(1176000000, 98, 1, 1),
|
||||
PLL_RATE(1200000000, 50, 1, 0),
|
||||
PLL_RATE(1224000000, 51, 1, 0),
|
||||
PLL_RATE(1248000000, 52, 1, 0),
|
||||
PLL_RATE(1272000000, 53, 1, 0),
|
||||
PLL_RATE(1296000000, 54, 1, 0),
|
||||
PLL_RATE(1320000000, 55, 1, 0),
|
||||
PLL_RATE(1344000000, 56, 1, 0),
|
||||
PLL_RATE(1368000000, 57, 1, 0),
|
||||
PLL_RATE(1392000000, 58, 1, 0),
|
||||
PLL_RATE(1416000000, 59, 1, 0),
|
||||
PLL_RATE(1440000000, 60, 1, 0),
|
||||
PLL_RATE(1464000000, 61, 1, 0),
|
||||
PLL_RATE(1488000000, 62, 1, 0),
|
||||
PLL_RATE(1512000000, 63, 1, 0),
|
||||
PLL_RATE(1536000000, 64, 1, 0),
|
||||
{ /* sentinel */ },
|
||||
};
|
||||
|
||||
static const struct clk_div_table cpu_div_table[] = {
|
||||
{ .val = 1, .div = 1 },
|
||||
{ .val = 2, .div = 2 },
|
||||
{ .val = 3, .div = 3 },
|
||||
{ .val = 2, .div = 4 },
|
||||
{ .val = 3, .div = 6 },
|
||||
{ .val = 4, .div = 8 },
|
||||
{ .val = 5, .div = 10 },
|
||||
{ .val = 6, .div = 12 },
|
||||
{ .val = 7, .div = 14 },
|
||||
{ .val = 8, .div = 16 },
|
||||
{ /* sentinel */ },
|
||||
};
|
||||
|
||||
PNAME(p_xtal) = { "xtal" };
|
||||
PNAME(p_fclk_div) = { "fixed_pll" };
|
||||
PNAME(p_cpu_clk) = { "sys_pll" };
|
||||
PNAME(p_clk81) = { "fclk_div3", "fclk_div4", "fclk_div5" };
|
||||
PNAME(p_mali) = { "fclk_div3", "fclk_div4", "fclk_div5",
|
||||
"fclk_div7", "zero" };
|
||||
|
||||
static u32 mux_table_clk81[] = { 6, 5, 7 };
|
||||
static u32 mux_table_mali[] = { 6, 5, 7, 4, 0 };
|
||||
|
||||
static struct pll_conf pll_confs = {
|
||||
.m = PARM(0x00, 0, 9),
|
||||
.n = PARM(0x00, 9, 5),
|
||||
.od = PARM(0x00, 16, 2),
|
||||
};
|
||||
|
||||
static struct pll_conf sys_pll_conf = {
|
||||
.m = PARM(0x00, 0, 9),
|
||||
.n = PARM(0x00, 9, 5),
|
||||
.od = PARM(0x00, 16, 2),
|
||||
.rate_table = sys_pll_rate_table,
|
||||
};
|
||||
|
||||
static const struct composite_conf clk81_conf __initconst = {
|
||||
.mux_table = mux_table_clk81,
|
||||
.mux_flags = CLK_MUX_READ_ONLY,
|
||||
.mux_parm = PARM(0x00, 12, 3),
|
||||
.div_parm = PARM(0x00, 0, 7),
|
||||
.gate_parm = PARM(0x00, 7, 1),
|
||||
};
|
||||
|
||||
static const struct composite_conf mali_conf __initconst = {
|
||||
.mux_table = mux_table_mali,
|
||||
.mux_parm = PARM(0x00, 9, 3),
|
||||
.div_parm = PARM(0x00, 0, 7),
|
||||
.gate_parm = PARM(0x00, 8, 1),
|
||||
};
|
||||
|
||||
static const struct clk_conf meson8b_xtal_conf __initconst =
|
||||
FIXED_RATE_P(MESON8B_REG_CTL0_ADDR, CLKID_XTAL, "xtal",
|
||||
CLK_IS_ROOT, PARM(0x00, 4, 7));
|
||||
|
||||
static const struct clk_conf meson8b_clk_confs[] __initconst = {
|
||||
FIXED_RATE(CLKID_ZERO, "zero", CLK_IS_ROOT, 0),
|
||||
PLL(MESON8B_REG_PLL_FIXED, CLKID_PLL_FIXED, "fixed_pll",
|
||||
p_xtal, 0, &pll_confs),
|
||||
PLL(MESON8B_REG_PLL_VID, CLKID_PLL_VID, "vid_pll",
|
||||
p_xtal, 0, &pll_confs),
|
||||
PLL(MESON8B_REG_PLL_SYS, CLKID_PLL_SYS, "sys_pll",
|
||||
p_xtal, 0, &sys_pll_conf),
|
||||
FIXED_FACTOR_DIV(CLKID_FCLK_DIV2, "fclk_div2", p_fclk_div, 0, 2),
|
||||
FIXED_FACTOR_DIV(CLKID_FCLK_DIV3, "fclk_div3", p_fclk_div, 0, 3),
|
||||
FIXED_FACTOR_DIV(CLKID_FCLK_DIV4, "fclk_div4", p_fclk_div, 0, 4),
|
||||
FIXED_FACTOR_DIV(CLKID_FCLK_DIV5, "fclk_div5", p_fclk_div, 0, 5),
|
||||
FIXED_FACTOR_DIV(CLKID_FCLK_DIV7, "fclk_div7", p_fclk_div, 0, 7),
|
||||
CPU(MESON8B_REG_SYS_CPU_CNTL1, CLKID_CPUCLK, "a5_clk", p_cpu_clk,
|
||||
cpu_div_table),
|
||||
COMPOSITE(MESON8B_REG_HHI_MPEG, CLKID_CLK81, "clk81", p_clk81,
|
||||
CLK_SET_RATE_NO_REPARENT | CLK_IGNORE_UNUSED, &clk81_conf),
|
||||
COMPOSITE(MESON8B_REG_MALI, CLKID_MALI, "mali", p_mali,
|
||||
CLK_IGNORE_UNUSED, &mali_conf),
|
||||
};
|
||||
|
||||
static void __init meson8b_clkc_init(struct device_node *np)
|
||||
{
|
||||
void __iomem *clk_base;
|
||||
|
||||
if (!meson_clk_init(np, CLK_NR_CLKS))
|
||||
return;
|
||||
|
||||
/* XTAL */
|
||||
clk_base = of_iomap(np, 0);
|
||||
if (!clk_base) {
|
||||
pr_err("%s: Unable to map xtal base\n", __func__);
|
||||
return;
|
||||
}
|
||||
|
||||
meson_clk_register_clks(&meson8b_xtal_conf, 1, clk_base);
|
||||
iounmap(clk_base);
|
||||
|
||||
/* Generic clocks and PLLs */
|
||||
clk_base = of_iomap(np, 1);
|
||||
if (!clk_base) {
|
||||
pr_err("%s: Unable to map clk base\n", __func__);
|
||||
return;
|
||||
}
|
||||
|
||||
meson_clk_register_clks(meson8b_clk_confs,
|
||||
ARRAY_SIZE(meson8b_clk_confs),
|
||||
clk_base);
|
||||
}
|
||||
CLK_OF_DECLARE(meson8b_clock, "amlogic,meson8b-clkc", meson8b_clkc_init);
|
||||
|
|
@ -12,3 +12,5 @@ obj-$(CONFIG_MACH_MMP2_DT) += clk-of-mmp2.o
|
|||
obj-$(CONFIG_CPU_PXA168) += clk-pxa168.o
|
||||
obj-$(CONFIG_CPU_PXA910) += clk-pxa910.o
|
||||
obj-$(CONFIG_CPU_MMP2) += clk-mmp2.o
|
||||
|
||||
obj-y += clk-of-pxa1928.o
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ static void clk_apbc_unprepare(struct clk_hw *hw)
|
|||
spin_unlock_irqrestore(apbc->lock, flags);
|
||||
}
|
||||
|
||||
struct clk_ops clk_apbc_ops = {
|
||||
static struct clk_ops clk_apbc_ops = {
|
||||
.prepare = clk_apbc_prepare,
|
||||
.unprepare = clk_apbc_unprepare,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ static void clk_apmu_disable(struct clk_hw *hw)
|
|||
spin_unlock_irqrestore(apmu->lock, flags);
|
||||
}
|
||||
|
||||
struct clk_ops clk_apmu_ops = {
|
||||
static struct clk_ops clk_apmu_ops = {
|
||||
.enable = clk_apmu_enable,
|
||||
.disable = clk_apmu_disable,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -63,10 +63,8 @@ static struct mmp_clk_factor_masks uart_factor_masks = {
|
|||
};
|
||||
|
||||
static struct mmp_clk_factor_tbl uart_factor_tbl[] = {
|
||||
{.num = 14634, .den = 2165}, /*14.745MHZ */
|
||||
{.num = 8125, .den = 1536}, /*14.745MHZ */
|
||||
{.num = 3521, .den = 689}, /*19.23MHZ */
|
||||
{.num = 9679, .den = 5728}, /*58.9824MHZ */
|
||||
{.num = 15850, .den = 9451}, /*59.429MHZ */
|
||||
};
|
||||
|
||||
static const char *uart_parent[] = {"uart_pll", "vctcxo"};
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@
|
|||
#define APBC_TWSI4 0x7c
|
||||
#define APBC_TWSI5 0x80
|
||||
#define APBC_KPC 0x18
|
||||
#define APBC_TIMER 0x24
|
||||
#define APBC_UART0 0x2c
|
||||
#define APBC_UART1 0x30
|
||||
#define APBC_UART2 0x34
|
||||
|
|
@ -98,10 +99,8 @@ static struct mmp_clk_factor_masks uart_factor_masks = {
|
|||
};
|
||||
|
||||
static struct mmp_clk_factor_tbl uart_factor_tbl[] = {
|
||||
{.num = 14634, .den = 2165}, /*14.745MHZ */
|
||||
{.num = 8125, .den = 1536}, /*14.745MHZ */
|
||||
{.num = 3521, .den = 689}, /*19.23MHZ */
|
||||
{.num = 9679, .den = 5728}, /*58.9824MHZ */
|
||||
{.num = 15850, .den = 9451}, /*59.429MHZ */
|
||||
};
|
||||
|
||||
static void mmp2_pll_init(struct mmp2_clk_unit *pxa_unit)
|
||||
|
|
@ -134,6 +133,9 @@ static DEFINE_SPINLOCK(ssp2_lock);
|
|||
static DEFINE_SPINLOCK(ssp3_lock);
|
||||
static const char *ssp_parent_names[] = {"vctcxo_4", "vctcxo_2", "vctcxo", "pll1_16"};
|
||||
|
||||
static DEFINE_SPINLOCK(timer_lock);
|
||||
static const char *timer_parent_names[] = {"clk32", "vctcxo_2", "vctcxo_4", "vctcxo"};
|
||||
|
||||
static DEFINE_SPINLOCK(reset_lock);
|
||||
|
||||
static struct mmp_param_mux_clk apbc_mux_clks[] = {
|
||||
|
|
@ -145,6 +147,7 @@ static struct mmp_param_mux_clk apbc_mux_clks[] = {
|
|||
{0, "ssp1_mux", ssp_parent_names, ARRAY_SIZE(ssp_parent_names), CLK_SET_RATE_PARENT, APBC_SSP1, 4, 3, 0, &ssp1_lock},
|
||||
{0, "ssp2_mux", ssp_parent_names, ARRAY_SIZE(ssp_parent_names), CLK_SET_RATE_PARENT, APBC_SSP2, 4, 3, 0, &ssp2_lock},
|
||||
{0, "ssp3_mux", ssp_parent_names, ARRAY_SIZE(ssp_parent_names), CLK_SET_RATE_PARENT, APBC_SSP3, 4, 3, 0, &ssp3_lock},
|
||||
{0, "timer_mux", timer_parent_names, ARRAY_SIZE(timer_parent_names), CLK_SET_RATE_PARENT, APBC_TIMER, 4, 3, 0, &timer_lock},
|
||||
};
|
||||
|
||||
static struct mmp_param_gate_clk apbc_gate_clks[] = {
|
||||
|
|
@ -170,6 +173,7 @@ static struct mmp_param_gate_clk apbc_gate_clks[] = {
|
|||
{MMP2_CLK_SSP1, "ssp1_clk", "ssp1_mux", CLK_SET_RATE_PARENT, APBC_SSP1, 0x7, 0x3, 0x0, 0, &ssp1_lock},
|
||||
{MMP2_CLK_SSP2, "ssp2_clk", "ssp2_mux", CLK_SET_RATE_PARENT, APBC_SSP2, 0x7, 0x3, 0x0, 0, &ssp2_lock},
|
||||
{MMP2_CLK_SSP3, "ssp3_clk", "ssp3_mux", CLK_SET_RATE_PARENT, APBC_SSP3, 0x7, 0x3, 0x0, 0, &ssp3_lock},
|
||||
{MMP2_CLK_TIMER, "timer_clk", "timer_mux", CLK_SET_RATE_PARENT, APBC_TIMER, 0x7, 0x3, 0x0, 0, &timer_lock},
|
||||
};
|
||||
|
||||
static void mmp2_apb_periph_clk_init(struct mmp2_clk_unit *pxa_unit)
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@
|
|||
#define APBC_PWM1 0x10
|
||||
#define APBC_PWM2 0x14
|
||||
#define APBC_PWM3 0x18
|
||||
#define APBC_TIMER 0x34
|
||||
#define APBC_SSP0 0x81c
|
||||
#define APBC_SSP1 0x820
|
||||
#define APBC_SSP2 0x84c
|
||||
|
|
@ -58,6 +59,7 @@ static struct mmp_param_fixed_rate_clk fixed_rate_clks[] = {
|
|||
{PXA168_CLK_CLK32, "clk32", NULL, CLK_IS_ROOT, 32768},
|
||||
{PXA168_CLK_VCTCXO, "vctcxo", NULL, CLK_IS_ROOT, 26000000},
|
||||
{PXA168_CLK_PLL1, "pll1", NULL, CLK_IS_ROOT, 624000000},
|
||||
{PXA168_CLK_USB_PLL, "usb_pll", NULL, CLK_IS_ROOT, 480000000},
|
||||
};
|
||||
|
||||
static struct mmp_param_fixed_factor_clk fixed_factor_clks[] = {
|
||||
|
|
@ -70,6 +72,7 @@ static struct mmp_param_fixed_factor_clk fixed_factor_clks[] = {
|
|||
{PXA168_CLK_PLL1_24, "pll1_24", "pll1_12", 1, 2, 0},
|
||||
{PXA168_CLK_PLL1_48, "pll1_48", "pll1_24", 1, 2, 0},
|
||||
{PXA168_CLK_PLL1_96, "pll1_96", "pll1_48", 1, 2, 0},
|
||||
{PXA168_CLK_PLL1_192, "pll1_192", "pll1_96", 1, 2, 0},
|
||||
{PXA168_CLK_PLL1_13, "pll1_13", "pll1", 1, 13, 0},
|
||||
{PXA168_CLK_PLL1_13_1_5, "pll1_13_1_5", "pll1_13", 2, 3, 0},
|
||||
{PXA168_CLK_PLL1_2_1_5, "pll1_2_1_5", "pll1_2", 2, 3, 0},
|
||||
|
|
@ -119,6 +122,9 @@ static DEFINE_SPINLOCK(ssp3_lock);
|
|||
static DEFINE_SPINLOCK(ssp4_lock);
|
||||
static const char *ssp_parent_names[] = {"pll1_96", "pll1_48", "pll1_24", "pll1_12"};
|
||||
|
||||
static DEFINE_SPINLOCK(timer_lock);
|
||||
static const char *timer_parent_names[] = {"pll1_48", "clk32", "pll1_96", "pll1_192"};
|
||||
|
||||
static DEFINE_SPINLOCK(reset_lock);
|
||||
|
||||
static struct mmp_param_mux_clk apbc_mux_clks[] = {
|
||||
|
|
@ -130,6 +136,7 @@ static struct mmp_param_mux_clk apbc_mux_clks[] = {
|
|||
{0, "ssp2_mux", ssp_parent_names, ARRAY_SIZE(ssp_parent_names), CLK_SET_RATE_PARENT, APBC_SSP2, 4, 3, 0, &ssp2_lock},
|
||||
{0, "ssp3_mux", ssp_parent_names, ARRAY_SIZE(ssp_parent_names), CLK_SET_RATE_PARENT, APBC_SSP3, 4, 3, 0, &ssp3_lock},
|
||||
{0, "ssp4_mux", ssp_parent_names, ARRAY_SIZE(ssp_parent_names), CLK_SET_RATE_PARENT, APBC_SSP4, 4, 3, 0, &ssp4_lock},
|
||||
{0, "timer_mux", timer_parent_names, ARRAY_SIZE(timer_parent_names), CLK_SET_RATE_PARENT, APBC_TIMER, 4, 3, 0, &timer_lock},
|
||||
};
|
||||
|
||||
static struct mmp_param_gate_clk apbc_gate_clks[] = {
|
||||
|
|
@ -151,6 +158,7 @@ static struct mmp_param_gate_clk apbc_gate_clks[] = {
|
|||
{PXA168_CLK_SSP2, "ssp2_clk", "ssp2_mux", CLK_SET_RATE_PARENT, APBC_SSP2, 0x3, 0x3, 0x0, 0, &ssp2_lock},
|
||||
{PXA168_CLK_SSP3, "ssp3_clk", "ssp3_mux", CLK_SET_RATE_PARENT, APBC_SSP3, 0x3, 0x3, 0x0, 0, &ssp3_lock},
|
||||
{PXA168_CLK_SSP4, "ssp4_clk", "ssp4_mux", CLK_SET_RATE_PARENT, APBC_SSP4, 0x3, 0x3, 0x0, 0, &ssp4_lock},
|
||||
{PXA168_CLK_TIMER, "timer_clk", "timer_mux", CLK_SET_RATE_PARENT, APBC_TIMER, 0x3, 0x3, 0x0, 0, &timer_lock},
|
||||
};
|
||||
|
||||
static void pxa168_apb_periph_clk_init(struct pxa168_clk_unit *pxa_unit)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,265 @@
|
|||
/*
|
||||
* pxa1928 clock framework source file
|
||||
*
|
||||
* Copyright (C) 2015 Linaro, Ltd.
|
||||
* Rob Herring <robh@kernel.org>
|
||||
*
|
||||
* Based on drivers/clk/mmp/clk-of-mmp2.c:
|
||||
* Copyright (C) 2012 Marvell
|
||||
* Chao Xie <xiechao.mail@gmail.com>
|
||||
*
|
||||
* This file is licensed under the terms of the GNU General Public
|
||||
* License version 2. This program is licensed "as is" without any
|
||||
* warranty of any kind, whether express or implied.
|
||||
*/
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/of_address.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/spinlock.h>
|
||||
|
||||
#include <dt-bindings/clock/marvell,pxa1928.h>
|
||||
|
||||
#include "clk.h"
|
||||
#include "reset.h"
|
||||
|
||||
#define MPMU_UART_PLL 0x14
|
||||
|
||||
struct pxa1928_clk_unit {
|
||||
struct mmp_clk_unit unit;
|
||||
void __iomem *mpmu_base;
|
||||
void __iomem *apmu_base;
|
||||
void __iomem *apbc_base;
|
||||
void __iomem *apbcp_base;
|
||||
};
|
||||
|
||||
static struct mmp_param_fixed_rate_clk fixed_rate_clks[] = {
|
||||
{0, "clk32", NULL, CLK_IS_ROOT, 32768},
|
||||
{0, "vctcxo", NULL, CLK_IS_ROOT, 26000000},
|
||||
{0, "pll1_624", NULL, CLK_IS_ROOT, 624000000},
|
||||
{0, "pll5p", NULL, CLK_IS_ROOT, 832000000},
|
||||
{0, "pll5", NULL, CLK_IS_ROOT, 1248000000},
|
||||
{0, "usb_pll", NULL, CLK_IS_ROOT, 480000000},
|
||||
};
|
||||
|
||||
static struct mmp_param_fixed_factor_clk fixed_factor_clks[] = {
|
||||
{0, "pll1_d2", "pll1_624", 1, 2, 0},
|
||||
{0, "pll1_d9", "pll1_624", 1, 9, 0},
|
||||
{0, "pll1_d12", "pll1_624", 1, 12, 0},
|
||||
{0, "pll1_d16", "pll1_624", 1, 16, 0},
|
||||
{0, "pll1_d20", "pll1_624", 1, 20, 0},
|
||||
{0, "pll1_416", "pll1_624", 2, 3, 0},
|
||||
{0, "vctcxo_d2", "vctcxo", 1, 2, 0},
|
||||
{0, "vctcxo_d4", "vctcxo", 1, 4, 0},
|
||||
};
|
||||
|
||||
static struct mmp_clk_factor_masks uart_factor_masks = {
|
||||
.factor = 2,
|
||||
.num_mask = 0x1fff,
|
||||
.den_mask = 0x1fff,
|
||||
.num_shift = 16,
|
||||
.den_shift = 0,
|
||||
};
|
||||
|
||||
static struct mmp_clk_factor_tbl uart_factor_tbl[] = {
|
||||
{.num = 832, .den = 234}, /*58.5MHZ */
|
||||
{.num = 1, .den = 1}, /*26MHZ */
|
||||
};
|
||||
|
||||
static void pxa1928_pll_init(struct pxa1928_clk_unit *pxa_unit)
|
||||
{
|
||||
struct clk *clk;
|
||||
struct mmp_clk_unit *unit = &pxa_unit->unit;
|
||||
|
||||
mmp_register_fixed_rate_clks(unit, fixed_rate_clks,
|
||||
ARRAY_SIZE(fixed_rate_clks));
|
||||
|
||||
mmp_register_fixed_factor_clks(unit, fixed_factor_clks,
|
||||
ARRAY_SIZE(fixed_factor_clks));
|
||||
|
||||
clk = mmp_clk_register_factor("uart_pll", "pll1_416",
|
||||
CLK_SET_RATE_PARENT,
|
||||
pxa_unit->mpmu_base + MPMU_UART_PLL,
|
||||
&uart_factor_masks, uart_factor_tbl,
|
||||
ARRAY_SIZE(uart_factor_tbl), NULL);
|
||||
}
|
||||
|
||||
static DEFINE_SPINLOCK(uart0_lock);
|
||||
static DEFINE_SPINLOCK(uart1_lock);
|
||||
static DEFINE_SPINLOCK(uart2_lock);
|
||||
static DEFINE_SPINLOCK(uart3_lock);
|
||||
static const char *uart_parent_names[] = {"uart_pll", "vctcxo"};
|
||||
|
||||
static DEFINE_SPINLOCK(ssp0_lock);
|
||||
static DEFINE_SPINLOCK(ssp1_lock);
|
||||
static const char *ssp_parent_names[] = {"vctcxo_d4", "vctcxo_d2", "vctcxo", "pll1_d12"};
|
||||
|
||||
static DEFINE_SPINLOCK(reset_lock);
|
||||
|
||||
static struct mmp_param_mux_clk apbc_mux_clks[] = {
|
||||
{0, "uart0_mux", uart_parent_names, ARRAY_SIZE(uart_parent_names), CLK_SET_RATE_PARENT, PXA1928_CLK_UART0 * 4, 4, 3, 0, &uart0_lock},
|
||||
{0, "uart1_mux", uart_parent_names, ARRAY_SIZE(uart_parent_names), CLK_SET_RATE_PARENT, PXA1928_CLK_UART1 * 4, 4, 3, 0, &uart1_lock},
|
||||
{0, "uart2_mux", uart_parent_names, ARRAY_SIZE(uart_parent_names), CLK_SET_RATE_PARENT, PXA1928_CLK_UART2 * 4, 4, 3, 0, &uart2_lock},
|
||||
{0, "uart3_mux", uart_parent_names, ARRAY_SIZE(uart_parent_names), CLK_SET_RATE_PARENT, PXA1928_CLK_UART3 * 4, 4, 3, 0, &uart3_lock},
|
||||
{0, "ssp0_mux", ssp_parent_names, ARRAY_SIZE(ssp_parent_names), CLK_SET_RATE_PARENT, PXA1928_CLK_SSP0 * 4, 4, 3, 0, &ssp0_lock},
|
||||
{0, "ssp1_mux", ssp_parent_names, ARRAY_SIZE(ssp_parent_names), CLK_SET_RATE_PARENT, PXA1928_CLK_SSP1 * 4, 4, 3, 0, &ssp1_lock},
|
||||
};
|
||||
|
||||
static struct mmp_param_gate_clk apbc_gate_clks[] = {
|
||||
{PXA1928_CLK_TWSI0, "twsi0_clk", "vctcxo", CLK_SET_RATE_PARENT, PXA1928_CLK_TWSI0 * 4, 0x3, 0x3, 0x0, 0, &reset_lock},
|
||||
{PXA1928_CLK_TWSI1, "twsi1_clk", "vctcxo", CLK_SET_RATE_PARENT, PXA1928_CLK_TWSI1 * 4, 0x3, 0x3, 0x0, 0, &reset_lock},
|
||||
{PXA1928_CLK_TWSI2, "twsi2_clk", "vctcxo", CLK_SET_RATE_PARENT, PXA1928_CLK_TWSI2 * 4, 0x3, 0x3, 0x0, 0, &reset_lock},
|
||||
{PXA1928_CLK_TWSI3, "twsi3_clk", "vctcxo", CLK_SET_RATE_PARENT, PXA1928_CLK_TWSI3 * 4, 0x3, 0x3, 0x0, 0, &reset_lock},
|
||||
{PXA1928_CLK_TWSI4, "twsi4_clk", "vctcxo", CLK_SET_RATE_PARENT, PXA1928_CLK_TWSI4 * 4, 0x3, 0x3, 0x0, 0, &reset_lock},
|
||||
{PXA1928_CLK_TWSI5, "twsi5_clk", "vctcxo", CLK_SET_RATE_PARENT, PXA1928_CLK_TWSI5 * 4, 0x3, 0x3, 0x0, 0, &reset_lock},
|
||||
{PXA1928_CLK_GPIO, "gpio_clk", "vctcxo", CLK_SET_RATE_PARENT, PXA1928_CLK_GPIO * 4, 0x3, 0x3, 0x0, 0, &reset_lock},
|
||||
{PXA1928_CLK_KPC, "kpc_clk", "clk32", CLK_SET_RATE_PARENT, PXA1928_CLK_KPC * 4, 0x3, 0x3, 0x0, MMP_CLK_GATE_NEED_DELAY, NULL},
|
||||
{PXA1928_CLK_RTC, "rtc_clk", "clk32", CLK_SET_RATE_PARENT, PXA1928_CLK_RTC * 4, 0x83, 0x83, 0x0, MMP_CLK_GATE_NEED_DELAY, NULL},
|
||||
{PXA1928_CLK_PWM0, "pwm0_clk", "vctcxo", CLK_SET_RATE_PARENT, PXA1928_CLK_PWM0 * 4, 0x3, 0x3, 0x0, 0, &reset_lock},
|
||||
{PXA1928_CLK_PWM1, "pwm1_clk", "vctcxo", CLK_SET_RATE_PARENT, PXA1928_CLK_PWM1 * 4, 0x3, 0x3, 0x0, 0, &reset_lock},
|
||||
{PXA1928_CLK_PWM2, "pwm2_clk", "vctcxo", CLK_SET_RATE_PARENT, PXA1928_CLK_PWM2 * 4, 0x3, 0x3, 0x0, 0, &reset_lock},
|
||||
{PXA1928_CLK_PWM3, "pwm3_clk", "vctcxo", CLK_SET_RATE_PARENT, PXA1928_CLK_PWM3 * 4, 0x3, 0x3, 0x0, 0, &reset_lock},
|
||||
/* The gate clocks has mux parent. */
|
||||
{PXA1928_CLK_UART0, "uart0_clk", "uart0_mux", CLK_SET_RATE_PARENT, PXA1928_CLK_UART0 * 4, 0x3, 0x3, 0x0, 0, &uart0_lock},
|
||||
{PXA1928_CLK_UART1, "uart1_clk", "uart1_mux", CLK_SET_RATE_PARENT, PXA1928_CLK_UART1 * 4, 0x3, 0x3, 0x0, 0, &uart1_lock},
|
||||
{PXA1928_CLK_UART2, "uart2_clk", "uart2_mux", CLK_SET_RATE_PARENT, PXA1928_CLK_UART2 * 4, 0x3, 0x3, 0x0, 0, &uart2_lock},
|
||||
{PXA1928_CLK_UART3, "uart3_clk", "uart3_mux", CLK_SET_RATE_PARENT, PXA1928_CLK_UART3 * 4, 0x3, 0x3, 0x0, 0, &uart3_lock},
|
||||
{PXA1928_CLK_SSP0, "ssp0_clk", "ssp0_mux", CLK_SET_RATE_PARENT, PXA1928_CLK_SSP0 * 4, 0x3, 0x3, 0x0, 0, &ssp0_lock},
|
||||
{PXA1928_CLK_SSP1, "ssp1_clk", "ssp1_mux", CLK_SET_RATE_PARENT, PXA1928_CLK_SSP1 * 4, 0x3, 0x3, 0x0, 0, &ssp1_lock},
|
||||
};
|
||||
|
||||
static void pxa1928_apb_periph_clk_init(struct pxa1928_clk_unit *pxa_unit)
|
||||
{
|
||||
struct mmp_clk_unit *unit = &pxa_unit->unit;
|
||||
|
||||
mmp_register_mux_clks(unit, apbc_mux_clks, pxa_unit->apbc_base,
|
||||
ARRAY_SIZE(apbc_mux_clks));
|
||||
|
||||
mmp_register_gate_clks(unit, apbc_gate_clks, pxa_unit->apbc_base,
|
||||
ARRAY_SIZE(apbc_gate_clks));
|
||||
}
|
||||
|
||||
static DEFINE_SPINLOCK(sdh0_lock);
|
||||
static DEFINE_SPINLOCK(sdh1_lock);
|
||||
static DEFINE_SPINLOCK(sdh2_lock);
|
||||
static DEFINE_SPINLOCK(sdh3_lock);
|
||||
static DEFINE_SPINLOCK(sdh4_lock);
|
||||
static const char *sdh_parent_names[] = {"pll1_624", "pll5p", "pll5", "pll1_416"};
|
||||
|
||||
static DEFINE_SPINLOCK(usb_lock);
|
||||
|
||||
static struct mmp_param_mux_clk apmu_mux_clks[] = {
|
||||
{0, "sdh_mux", sdh_parent_names, ARRAY_SIZE(sdh_parent_names), CLK_SET_RATE_PARENT, PXA1928_CLK_SDH0 * 4, 8, 2, 0, &sdh0_lock},
|
||||
};
|
||||
|
||||
static struct mmp_param_div_clk apmu_div_clks[] = {
|
||||
{0, "sdh_div", "sdh_mux", 0, PXA1928_CLK_SDH0 * 4, 10, 4, CLK_DIVIDER_ONE_BASED, &sdh0_lock},
|
||||
};
|
||||
|
||||
static struct mmp_param_gate_clk apmu_gate_clks[] = {
|
||||
{PXA1928_CLK_USB, "usb_clk", "usb_pll", 0, PXA1928_CLK_USB * 4, 0x9, 0x9, 0x0, 0, &usb_lock},
|
||||
{PXA1928_CLK_HSIC, "hsic_clk", "usb_pll", 0, PXA1928_CLK_HSIC * 4, 0x9, 0x9, 0x0, 0, &usb_lock},
|
||||
/* The gate clocks has mux parent. */
|
||||
{PXA1928_CLK_SDH0, "sdh0_clk", "sdh_div", CLK_SET_RATE_PARENT, PXA1928_CLK_SDH0 * 4, 0x1b, 0x1b, 0x0, 0, &sdh0_lock},
|
||||
{PXA1928_CLK_SDH1, "sdh1_clk", "sdh_div", CLK_SET_RATE_PARENT, PXA1928_CLK_SDH1 * 4, 0x1b, 0x1b, 0x0, 0, &sdh1_lock},
|
||||
{PXA1928_CLK_SDH2, "sdh2_clk", "sdh_div", CLK_SET_RATE_PARENT, PXA1928_CLK_SDH2 * 4, 0x1b, 0x1b, 0x0, 0, &sdh2_lock},
|
||||
{PXA1928_CLK_SDH3, "sdh3_clk", "sdh_div", CLK_SET_RATE_PARENT, PXA1928_CLK_SDH3 * 4, 0x1b, 0x1b, 0x0, 0, &sdh3_lock},
|
||||
{PXA1928_CLK_SDH4, "sdh4_clk", "sdh_div", CLK_SET_RATE_PARENT, PXA1928_CLK_SDH4 * 4, 0x1b, 0x1b, 0x0, 0, &sdh4_lock},
|
||||
};
|
||||
|
||||
static void pxa1928_axi_periph_clk_init(struct pxa1928_clk_unit *pxa_unit)
|
||||
{
|
||||
struct mmp_clk_unit *unit = &pxa_unit->unit;
|
||||
|
||||
mmp_register_mux_clks(unit, apmu_mux_clks, pxa_unit->apmu_base,
|
||||
ARRAY_SIZE(apmu_mux_clks));
|
||||
|
||||
mmp_register_div_clks(unit, apmu_div_clks, pxa_unit->apmu_base,
|
||||
ARRAY_SIZE(apmu_div_clks));
|
||||
|
||||
mmp_register_gate_clks(unit, apmu_gate_clks, pxa_unit->apmu_base,
|
||||
ARRAY_SIZE(apmu_gate_clks));
|
||||
}
|
||||
|
||||
static void pxa1928_clk_reset_init(struct device_node *np,
|
||||
struct pxa1928_clk_unit *pxa_unit)
|
||||
{
|
||||
struct mmp_clk_reset_cell *cells;
|
||||
int i, base, nr_resets;
|
||||
|
||||
nr_resets = ARRAY_SIZE(apbc_gate_clks);
|
||||
cells = kcalloc(nr_resets, sizeof(*cells), GFP_KERNEL);
|
||||
if (!cells)
|
||||
return;
|
||||
|
||||
base = 0;
|
||||
for (i = 0; i < nr_resets; i++) {
|
||||
cells[base + i].clk_id = apbc_gate_clks[i].id;
|
||||
cells[base + i].reg =
|
||||
pxa_unit->apbc_base + apbc_gate_clks[i].offset;
|
||||
cells[base + i].flags = 0;
|
||||
cells[base + i].lock = apbc_gate_clks[i].lock;
|
||||
cells[base + i].bits = 0x4;
|
||||
}
|
||||
|
||||
mmp_clk_reset_register(np, cells, nr_resets);
|
||||
}
|
||||
|
||||
static void __init pxa1928_mpmu_clk_init(struct device_node *np)
|
||||
{
|
||||
struct pxa1928_clk_unit *pxa_unit;
|
||||
|
||||
pxa_unit = kzalloc(sizeof(*pxa_unit), GFP_KERNEL);
|
||||
if (!pxa_unit)
|
||||
return;
|
||||
|
||||
pxa_unit->mpmu_base = of_iomap(np, 0);
|
||||
if (!pxa_unit->mpmu_base) {
|
||||
pr_err("failed to map mpmu registers\n");
|
||||
return;
|
||||
}
|
||||
|
||||
pxa1928_pll_init(pxa_unit);
|
||||
}
|
||||
CLK_OF_DECLARE(pxa1928_mpmu_clk, "marvell,pxa1928-mpmu", pxa1928_mpmu_clk_init);
|
||||
|
||||
static void __init pxa1928_apmu_clk_init(struct device_node *np)
|
||||
{
|
||||
struct pxa1928_clk_unit *pxa_unit;
|
||||
|
||||
pxa_unit = kzalloc(sizeof(*pxa_unit), GFP_KERNEL);
|
||||
if (!pxa_unit)
|
||||
return;
|
||||
|
||||
pxa_unit->apmu_base = of_iomap(np, 0);
|
||||
if (!pxa_unit->apmu_base) {
|
||||
pr_err("failed to map apmu registers\n");
|
||||
return;
|
||||
}
|
||||
|
||||
mmp_clk_init(np, &pxa_unit->unit, PXA1928_APMU_NR_CLKS);
|
||||
|
||||
pxa1928_axi_periph_clk_init(pxa_unit);
|
||||
}
|
||||
CLK_OF_DECLARE(pxa1928_apmu_clk, "marvell,pxa1928-apmu", pxa1928_apmu_clk_init);
|
||||
|
||||
static void __init pxa1928_apbc_clk_init(struct device_node *np)
|
||||
{
|
||||
struct pxa1928_clk_unit *pxa_unit;
|
||||
|
||||
pxa_unit = kzalloc(sizeof(*pxa_unit), GFP_KERNEL);
|
||||
if (!pxa_unit)
|
||||
return;
|
||||
|
||||
pxa_unit->apbc_base = of_iomap(np, 0);
|
||||
if (!pxa_unit->apbc_base) {
|
||||
pr_err("failed to map apbc registers\n");
|
||||
return;
|
||||
}
|
||||
|
||||
mmp_clk_init(np, &pxa_unit->unit, PXA1928_APBC_NR_CLKS);
|
||||
|
||||
pxa1928_apb_periph_clk_init(pxa_unit);
|
||||
pxa1928_clk_reset_init(np, pxa_unit);
|
||||
}
|
||||
CLK_OF_DECLARE(pxa1928_apbc_clk, "marvell,pxa1928-apbc", pxa1928_apbc_clk_init);
|
||||
|
|
@ -35,6 +35,8 @@
|
|||
#define APBC_SSP0 0x1c
|
||||
#define APBC_SSP1 0x20
|
||||
#define APBC_SSP2 0x4c
|
||||
#define APBC_TIMER0 0x30
|
||||
#define APBC_TIMER1 0x44
|
||||
#define APBCP_TWSI1 0x28
|
||||
#define APBCP_UART2 0x1c
|
||||
#define APMU_SDH0 0x54
|
||||
|
|
@ -57,6 +59,7 @@ static struct mmp_param_fixed_rate_clk fixed_rate_clks[] = {
|
|||
{PXA910_CLK_CLK32, "clk32", NULL, CLK_IS_ROOT, 32768},
|
||||
{PXA910_CLK_VCTCXO, "vctcxo", NULL, CLK_IS_ROOT, 26000000},
|
||||
{PXA910_CLK_PLL1, "pll1", NULL, CLK_IS_ROOT, 624000000},
|
||||
{PXA910_CLK_USB_PLL, "usb_pll", NULL, CLK_IS_ROOT, 480000000},
|
||||
};
|
||||
|
||||
static struct mmp_param_fixed_factor_clk fixed_factor_clks[] = {
|
||||
|
|
@ -69,6 +72,7 @@ static struct mmp_param_fixed_factor_clk fixed_factor_clks[] = {
|
|||
{PXA910_CLK_PLL1_24, "pll1_24", "pll1_12", 1, 2, 0},
|
||||
{PXA910_CLK_PLL1_48, "pll1_48", "pll1_24", 1, 2, 0},
|
||||
{PXA910_CLK_PLL1_96, "pll1_96", "pll1_48", 1, 2, 0},
|
||||
{PXA910_CLK_PLL1_192, "pll1_192", "pll1_96", 1, 2, 0},
|
||||
{PXA910_CLK_PLL1_13, "pll1_13", "pll1", 1, 13, 0},
|
||||
{PXA910_CLK_PLL1_13_1_5, "pll1_13_1_5", "pll1_13", 2, 3, 0},
|
||||
{PXA910_CLK_PLL1_2_1_5, "pll1_2_1_5", "pll1_2", 2, 3, 0},
|
||||
|
|
@ -115,6 +119,10 @@ static DEFINE_SPINLOCK(ssp0_lock);
|
|||
static DEFINE_SPINLOCK(ssp1_lock);
|
||||
static const char *ssp_parent_names[] = {"pll1_96", "pll1_48", "pll1_24", "pll1_12"};
|
||||
|
||||
static DEFINE_SPINLOCK(timer0_lock);
|
||||
static DEFINE_SPINLOCK(timer1_lock);
|
||||
static const char *timer_parent_names[] = {"pll1_48", "clk32", "pll1_96"};
|
||||
|
||||
static DEFINE_SPINLOCK(reset_lock);
|
||||
|
||||
static struct mmp_param_mux_clk apbc_mux_clks[] = {
|
||||
|
|
@ -122,6 +130,8 @@ static struct mmp_param_mux_clk apbc_mux_clks[] = {
|
|||
{0, "uart1_mux", uart_parent_names, ARRAY_SIZE(uart_parent_names), CLK_SET_RATE_PARENT, APBC_UART1, 4, 3, 0, &uart1_lock},
|
||||
{0, "ssp0_mux", ssp_parent_names, ARRAY_SIZE(ssp_parent_names), CLK_SET_RATE_PARENT, APBC_SSP0, 4, 3, 0, &ssp0_lock},
|
||||
{0, "ssp1_mux", ssp_parent_names, ARRAY_SIZE(ssp_parent_names), CLK_SET_RATE_PARENT, APBC_SSP1, 4, 3, 0, &ssp1_lock},
|
||||
{0, "timer0_mux", timer_parent_names, ARRAY_SIZE(timer_parent_names), CLK_SET_RATE_PARENT, APBC_TIMER0, 4, 3, 0, &timer0_lock},
|
||||
{0, "timer1_mux", timer_parent_names, ARRAY_SIZE(timer_parent_names), CLK_SET_RATE_PARENT, APBC_TIMER1, 4, 3, 0, &timer1_lock},
|
||||
};
|
||||
|
||||
static struct mmp_param_mux_clk apbcp_mux_clks[] = {
|
||||
|
|
@ -142,6 +152,8 @@ static struct mmp_param_gate_clk apbc_gate_clks[] = {
|
|||
{PXA910_CLK_UART1, "uart1_clk", "uart1_mux", CLK_SET_RATE_PARENT, APBC_UART1, 0x3, 0x3, 0x0, 0, &uart1_lock},
|
||||
{PXA910_CLK_SSP0, "ssp0_clk", "ssp0_mux", CLK_SET_RATE_PARENT, APBC_SSP0, 0x3, 0x3, 0x0, 0, &ssp0_lock},
|
||||
{PXA910_CLK_SSP1, "ssp1_clk", "ssp1_mux", CLK_SET_RATE_PARENT, APBC_SSP1, 0x3, 0x3, 0x0, 0, &ssp1_lock},
|
||||
{PXA910_CLK_TIMER0, "timer0_clk", "timer0_mux", CLK_SET_RATE_PARENT, APBC_TIMER0, 0x3, 0x3, 0x0, 0, &timer0_lock},
|
||||
{PXA910_CLK_TIMER1, "timer1_clk", "timer1_mux", CLK_SET_RATE_PARENT, APBC_TIMER1, 0x3, 0x3, 0x0, 0, &timer1_lock},
|
||||
};
|
||||
|
||||
static struct mmp_param_gate_clk apbcp_gate_clks[] = {
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue