tegra124_clk_pll.c revision 317013
122208Sdavidn/*- 222208Sdavidn * Copyright (c) 2016 Michal Meloun <mmel@FreeBSD.org> 322208Sdavidn * All rights reserved. 422208Sdavidn * 522208Sdavidn * Redistribution and use in source and binary forms, with or without 622208Sdavidn * modification, are permitted provided that the following conditions 722208Sdavidn * are met: 822208Sdavidn * 1. Redistributions of source code must retain the above copyright 922208Sdavidn * notice, this list of conditions and the following disclaimer. 1022208Sdavidn * 2. Redistributions in binary form must reproduce the above copyright 1122208Sdavidn * notice, this list of conditions and the following disclaimer in the 1222208Sdavidn * documentation and/or other materials provided with the distribution. 1322208Sdavidn * 1422208Sdavidn * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1522208Sdavidn * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1622208Sdavidn * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1722208Sdavidn * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 1822208Sdavidn * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 1922208Sdavidn * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2022208Sdavidn * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2122208Sdavidn * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2222208Sdavidn * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2322208Sdavidn * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2422208Sdavidn * SUCH DAMAGE. 2522208Sdavidn */ 26216582Scharnier 27216582Scharnier#include <sys/cdefs.h> 2831331Scharnier__FBSDID("$FreeBSD: stable/11/sys/arm/nvidia/tegra124/tegra124_clk_pll.c 317013 2017-04-16 08:21:14Z mmel $"); 2991214Sbde 3022208Sdavidn#include <sys/param.h> 3122208Sdavidn#include <sys/systm.h> 3291214Sbde#include <sys/bus.h> 3331331Scharnier#include <sys/lock.h> 3422208Sdavidn#include <sys/mutex.h> 3522208Sdavidn#include <sys/rman.h> 3622208Sdavidn 3722208Sdavidn#include <machine/bus.h> 3822208Sdavidn 3922208Sdavidn#include <dev/extres/clk/clk.h> 40144716Sstefanf 4122208Sdavidn#include <gnu/dts/include/dt-bindings/clock/tegra124-car.h> 4222208Sdavidn#include "tegra124_car.h" 4322208Sdavidn 4422208Sdavidn/* #define TEGRA_PLL_DEBUG */ 4522208Sdavidn#ifdef TEGRA_PLL_DEBUG 4622208Sdavidn#define dprintf(...) printf(__VA_ARGS__) 4722208Sdavidn#else 4822208Sdavidn#define dprintf(...) 4922208Sdavidn#endif 5022208Sdavidn 5122208Sdavidn/* All PLLs. */ 5222208Sdavidnenum pll_type { 5322208Sdavidn PLL_M, 5422208Sdavidn PLL_X, 5522208Sdavidn PLL_C, 5622208Sdavidn PLL_C2, 5722208Sdavidn PLL_C3, 5822208Sdavidn PLL_C4, 5922208Sdavidn PLL_P, 6090301Simp PLL_A, 6190301Simp PLL_U, 6290301Simp PLL_D, 6390301Simp PLL_D2, 6490301Simp PLL_DP, 6590301Simp PLL_E, 6690301Simp PLL_REFE}; 6790301Simp 6890301Simp/* Common base register bits. */ 6922208Sdavidn#define PLL_BASE_BYPASS (1U << 31) 7022208Sdavidn#define PLL_BASE_ENABLE (1 << 30) 7122208Sdavidn#define PLL_BASE_REFDISABLE (1 << 29) 7222208Sdavidn#define PLL_BASE_LOCK (1 << 27) 7322208Sdavidn#define PLL_BASE_DIVM_SHIFT 0 7422208Sdavidn#define PLL_BASE_DIVN_SHIFT 8 7522208Sdavidn 7622208Sdavidn#define PLLRE_MISC_LOCK (1 << 24) 7722208Sdavidn 7822208Sdavidn#define PLL_MISC_LOCK_ENABLE (1 << 18) 79216582Scharnier#define PLLC_MISC_LOCK_ENABLE (1 << 24) 8022208Sdavidn#define PLLDU_MISC_LOCK_ENABLE (1 << 22) 8122208Sdavidn#define PLLRE_MISC_LOCK_ENABLE (1 << 30) 8222208Sdavidn#define PLLSS_MISC_LOCK_ENABLE (1 << 30) 8322208Sdavidn 8422208Sdavidn#define PLLC_IDDQ_BIT 26 8522208Sdavidn#define PLLX_IDDQ_BIT 3 8622208Sdavidn#define PLLRE_IDDQ_BIT 16 8722208Sdavidn#define PLLSS_IDDQ_BIT 19 8822208Sdavidn 8922208Sdavidn#define PLL_LOCK_TIMEOUT 5000 9022208Sdavidn 9122208Sdavidn/* Post divider <-> register value mapping. */ 9222208Sdavidnstruct pdiv_table { 9322208Sdavidn uint32_t divider; /* real divider */ 9422208Sdavidn uint32_t value; /* register value */ 9590301Simp}; 9622208Sdavidn 9722208Sdavidn/* Bits definition of M, N and P fields. */ 9822208Sdavidnstruct mnp_bits { 9922208Sdavidn uint32_t m_width; 10022208Sdavidn uint32_t n_width; 10122208Sdavidn uint32_t p_width; 10222208Sdavidn uint32_t p_shift; 10322208Sdavidn}; 10422208Sdavidn 10522208Sdavidnstruct clk_pll_def { 10622208Sdavidn struct clknode_init_def clkdef; 10790301Simp enum pll_type type; 10822208Sdavidn uint32_t base_reg; 10922208Sdavidn uint32_t misc_reg; 11022208Sdavidn uint32_t lock_mask; 11122208Sdavidn uint32_t lock_enable; 11222208Sdavidn uint32_t iddq_reg; 11322208Sdavidn uint32_t iddq_mask; 11422208Sdavidn uint32_t flags; 11522208Sdavidn struct pdiv_table *pdiv_table; 11622208Sdavidn struct mnp_bits mnp_bits; 11722208Sdavidn}; 11822208Sdavidn 11922208Sdavidn#define PLL(_id, cname, pname) \ 12022208Sdavidn .clkdef.id = _id, \ 12122208Sdavidn .clkdef.name = cname, \ 12222208Sdavidn .clkdef.parent_names = (const char *[]){pname}, \ 12322208Sdavidn .clkdef.parent_cnt = 1, \ 12422208Sdavidn .clkdef.flags = CLK_NODE_STATIC_STRINGS 12522208Sdavidn 12622208Sdavidn/* Tegra K1 PLLs 12722208Sdavidn PLLM: Clock source for EMC 2x clock 12822208Sdavidn PLLX: Clock source for the fast CPU cluster and the shadow CPU 12922208Sdavidn PLLC: Clock source for general use 13022208Sdavidn PLLC2: Clock source for engine scaling 13122208Sdavidn PLLC3: Clock source for engine scaling 13222208Sdavidn PLLC4: Clock source for ISP/VI units 13322208Sdavidn PLLP: Clock source for most peripherals 13490301Simp PLLA: Audio clock sources: (11.2896 MHz, 12.288 MHz, 24.576 MHz) 13522208Sdavidn PLLU: Clock source for USB PHY, provides 12/60/480 MHz 13622208Sdavidn PLLD: Clock sources for the DSI and display subsystem 13722208Sdavidn PLLD2: Clock sources for the DSI and display subsystem 13822208Sdavidn refPLLe: 13922208Sdavidn PLLE: generate the 100 MHz reference clock for USB 3.0 (spread spectrum) 14022208Sdavidn PLLDP: Clock source for eDP/LVDS (spread spectrum) 14122208Sdavidn 14222208Sdavidn DFLLCPU: DFLL clock source for the fast CPU cluster 14322208Sdavidn GPCPLL: Clock source for the GPU 14422208Sdavidn*/ 14522208Sdavidn 14622208Sdavidnstatic struct pdiv_table pllm_map[] = { 14722208Sdavidn {1, 0}, 14822208Sdavidn {2, 1}, 14922208Sdavidn {0, 0} 15022208Sdavidn}; 15122208Sdavidn 15222208Sdavidnstatic struct pdiv_table pllxc_map[] = { 15322208Sdavidn { 1, 0}, 15422208Sdavidn { 2, 1}, 15522208Sdavidn { 3, 2}, 15622208Sdavidn { 4, 3}, 15722208Sdavidn { 5, 4}, 15822208Sdavidn { 6, 5}, 15922208Sdavidn { 8, 6}, 16022208Sdavidn {10, 7}, 16122208Sdavidn {12, 8}, 16222208Sdavidn {16, 9}, 16322208Sdavidn {12, 10}, 16422208Sdavidn {16, 11}, 16522208Sdavidn {20, 12}, 16622208Sdavidn {24, 13}, 16722208Sdavidn {32, 14}, 16822208Sdavidn { 0, 0} 16922208Sdavidn}; 17022208Sdavidn 17122208Sdavidnstatic struct pdiv_table pllc_map[] = { 17222208Sdavidn { 1, 0}, 17322208Sdavidn { 2, 1}, 17422208Sdavidn { 3, 2}, 17522208Sdavidn { 4, 3}, 17622208Sdavidn { 6, 4}, 17722208Sdavidn { 8, 5}, 17822208Sdavidn {12, 6}, 17922208Sdavidn {16, 7}, 18022208Sdavidn { 0, 0} 18122208Sdavidn}; 18222208Sdavidn 18322208Sdavidnstatic struct pdiv_table pll12g_ssd_esd_map[] = { 18422208Sdavidn { 1, 0}, 18522208Sdavidn { 2, 1}, 18622208Sdavidn { 3, 2}, 18722208Sdavidn { 4, 3}, 18822208Sdavidn { 5, 4}, 18922208Sdavidn { 6, 5}, 19022208Sdavidn { 8, 6}, 19122208Sdavidn {10, 7}, 19222208Sdavidn {12, 8}, 19322208Sdavidn {16, 9}, 19422208Sdavidn {12, 10}, 19522208Sdavidn {16, 11}, 19622208Sdavidn {20, 12}, 19722208Sdavidn {24, 13}, 19822208Sdavidn {32, 14}, 19922208Sdavidn { 0, 0} 20022208Sdavidn}; 20122208Sdavidn 20222208Sdavidnstatic struct pdiv_table pllu_map[] = { 20322208Sdavidn {1, 1}, 20422208Sdavidn {2, 0}, 20522208Sdavidn {0, 0} 20622208Sdavidn}; 20722208Sdavidn 20822208Sdavidnstatic struct pdiv_table pllrefe_map[] = { 20929003Sdavidn {1, 0}, 21022208Sdavidn {2, 1}, 21122208Sdavidn {3, 2}, 21222208Sdavidn {4, 3}, 21322208Sdavidn {5, 4}, 21422208Sdavidn {6, 5}, 21522208Sdavidn {0, 0}, 21622208Sdavidn}; 21722208Sdavidn 21822208Sdavidnstatic struct clk_pll_def pll_clks[] = { 21922208Sdavidn/* PLLM: 880 MHz Clock source for EMC 2x clock */ 22022208Sdavidn { 22122208Sdavidn PLL(TEGRA124_CLK_PLL_M, "pllM_out0", "osc_div_clk"), 22222208Sdavidn .type = PLL_M, 22322208Sdavidn .base_reg = PLLM_BASE, 22422208Sdavidn .misc_reg = PLLM_MISC, 22522208Sdavidn .lock_mask = PLL_BASE_LOCK, 22622208Sdavidn .lock_enable = PLL_MISC_LOCK_ENABLE, 22722208Sdavidn .pdiv_table = pllm_map, 22822208Sdavidn .mnp_bits = {8, 8, 1, 20}, 22922208Sdavidn }, 23022208Sdavidn/* PLLX: 1GHz Clock source for the fast CPU cluster and the shadow CPU */ 23122208Sdavidn { 23222208Sdavidn PLL(TEGRA124_CLK_PLL_X, "pllX_out", "osc_div_clk"), 23322208Sdavidn .type = PLL_X, 23422208Sdavidn .base_reg = PLLX_BASE, 23522208Sdavidn .misc_reg = PLLX_MISC, 23622208Sdavidn .lock_mask = PLL_BASE_LOCK, 23722208Sdavidn .lock_enable = PLL_MISC_LOCK_ENABLE, 23822208Sdavidn .iddq_reg = PLLX_MISC3, 23922208Sdavidn .iddq_mask = 1 << PLLX_IDDQ_BIT, 24090301Simp .pdiv_table = pllxc_map, 24122208Sdavidn .mnp_bits = {8, 8, 4, 20}, 24222208Sdavidn }, 24322208Sdavidn/* PLLC: 600 MHz Clock source for general use */ 24422208Sdavidn { 24522208Sdavidn PLL(TEGRA124_CLK_PLL_C, "pllC_out0", "osc_div_clk"), 24622208Sdavidn .type = PLL_C, 24722208Sdavidn .base_reg = PLLC_BASE, 24822208Sdavidn .misc_reg = PLLC_MISC, 24922208Sdavidn .lock_mask = PLL_BASE_LOCK, 25022208Sdavidn .lock_enable = PLLC_MISC_LOCK_ENABLE, 25122208Sdavidn .iddq_reg = PLLC_MISC, 25222208Sdavidn .iddq_mask = 1 << PLLC_IDDQ_BIT, 25322208Sdavidn .pdiv_table = pllc_map, 25422208Sdavidn .mnp_bits = {8, 8, 4, 20}, 25522208Sdavidn }, 25622208Sdavidn/* PLLC2: 600 MHz Clock source for engine scaling */ 25722208Sdavidn { 25822208Sdavidn PLL(TEGRA124_CLK_PLL_C2, "pllC2_out0", "osc_div_clk"), 25922208Sdavidn .type = PLL_C2, 26022208Sdavidn .base_reg = PLLC2_BASE, 26122208Sdavidn .misc_reg = PLLC2_MISC, 26222208Sdavidn .lock_mask = PLL_BASE_LOCK, 26322208Sdavidn .lock_enable = PLL_MISC_LOCK_ENABLE, 26422208Sdavidn .pdiv_table = pllc_map, 26522208Sdavidn .mnp_bits = {2, 8, 3, 20}, 26622208Sdavidn }, 26722208Sdavidn/* PLLC3: 600 MHz Clock source for engine scaling */ 26822208Sdavidn { 26922208Sdavidn PLL(TEGRA124_CLK_PLL_C3, "pllC3_out0", "osc_div_clk"), 27022208Sdavidn .type = PLL_C3, 27122208Sdavidn .base_reg = PLLC3_BASE, 27222208Sdavidn .misc_reg = PLLC3_MISC, 27322208Sdavidn .lock_mask = PLL_BASE_LOCK, 27490301Simp .lock_enable = PLL_MISC_LOCK_ENABLE, 27522208Sdavidn .pdiv_table = pllc_map, 27622208Sdavidn .mnp_bits = {2, 8, 3, 20}, 27722208Sdavidn }, 27822208Sdavidn/* PLLC4: 600 MHz Clock source for ISP/VI units */ 27922208Sdavidn { 28022208Sdavidn PLL(TEGRA124_CLK_PLL_C4, "pllC4_out0", "pllC4_src"), 28122208Sdavidn .type = PLL_C4, 28222208Sdavidn .base_reg = PLLC4_BASE, 28322208Sdavidn .misc_reg = PLLC4_MISC, 28422208Sdavidn .lock_mask = PLL_BASE_LOCK, 28522208Sdavidn .lock_enable = PLLSS_MISC_LOCK_ENABLE, 28622208Sdavidn .iddq_reg = PLLC4_BASE, 28722208Sdavidn .iddq_mask = 1 << PLLSS_IDDQ_BIT, 28822208Sdavidn .pdiv_table = pll12g_ssd_esd_map, 28922208Sdavidn .mnp_bits = {8, 8, 4, 20}, 29022208Sdavidn }, 29122208Sdavidn/* PLLP: 408 MHz Clock source for most peripherals */ 29222208Sdavidn { 29322208Sdavidn PLL(TEGRA124_CLK_PLL_P, "pllP_out0", "osc_div_clk"), 29422208Sdavidn .type = PLL_P, 29522208Sdavidn .base_reg = PLLP_BASE, 29622208Sdavidn .misc_reg = PLLP_MISC, 29722208Sdavidn .lock_mask = PLL_BASE_LOCK, 29822208Sdavidn .lock_enable = PLL_MISC_LOCK_ENABLE, 299108470Sschweikh .mnp_bits = {5, 10, 3, 20}, 30022208Sdavidn }, 30122208Sdavidn/* PLLA: Audio clock sources: (11.2896 MHz, 12.288 MHz, 24.576 MHz) */ 30222208Sdavidn { 30390301Simp PLL(TEGRA124_CLK_PLL_A, "pllA_out", "pllP_out1"), 30422208Sdavidn .type = PLL_A, 30522208Sdavidn .base_reg = PLLA_BASE, 30622208Sdavidn .misc_reg = PLLA_MISC, 30722208Sdavidn .lock_mask = PLL_BASE_LOCK, 30822208Sdavidn .lock_enable = PLL_MISC_LOCK_ENABLE, 30922208Sdavidn .mnp_bits = {5, 10, 3, 20}, 31022208Sdavidn }, 31122208Sdavidn/* PLLU: 480 MHz Clock source for USB PHY, provides 12/60/480 MHz */ 31222208Sdavidn { 31322208Sdavidn PLL(TEGRA124_CLK_PLL_U, "pllU_out", "osc_div_clk"), 31422208Sdavidn .type = PLL_U, 31522208Sdavidn .base_reg = PLLU_BASE, 31622208Sdavidn .misc_reg = PLLU_MISC, 31722208Sdavidn .lock_mask = PLL_BASE_LOCK, 31890301Simp .lock_enable = PLLDU_MISC_LOCK_ENABLE, 31922208Sdavidn .pdiv_table = pllu_map, 32022208Sdavidn .mnp_bits = {5, 10, 1, 20}, 32122208Sdavidn }, 32222208Sdavidn/* PLLD: 600 MHz Clock sources for the DSI and display subsystem */ 32322208Sdavidn { 32422208Sdavidn PLL(TEGRA124_CLK_PLL_D, "pllD_out", "osc_div_clk"), 32522208Sdavidn .type = PLL_D, 32622208Sdavidn .base_reg = PLLD_BASE, 32722208Sdavidn .misc_reg = PLLD_MISC, 32822208Sdavidn .lock_mask = PLL_BASE_LOCK, 32922208Sdavidn .lock_enable = PLL_MISC_LOCK_ENABLE, 33022208Sdavidn .mnp_bits = {5, 11, 3, 20}, 33122208Sdavidn }, 33222208Sdavidn/* PLLD2: 600 MHz Clock sources for the DSI and display subsystem */ 33322208Sdavidn { 33422208Sdavidn PLL(TEGRA124_CLK_PLL_D2, "pllD2_out", "pllD2_src"), 33522208Sdavidn .type = PLL_D2, 33622208Sdavidn .base_reg = PLLD2_BASE, 33722208Sdavidn .misc_reg = PLLD2_MISC, 33822208Sdavidn .lock_mask = PLL_BASE_LOCK, 33922208Sdavidn .lock_enable = PLLSS_MISC_LOCK_ENABLE, 34022208Sdavidn .iddq_reg = PLLD2_BASE, 34122208Sdavidn .iddq_mask = 1 << PLLSS_IDDQ_BIT, 34222208Sdavidn .pdiv_table = pll12g_ssd_esd_map, 34322208Sdavidn .mnp_bits = {8, 8, 4, 20}, 34422208Sdavidn }, 34522208Sdavidn/* refPLLe: */ 34622208Sdavidn { 34722208Sdavidn PLL(0, "pllREFE_out", "osc_div_clk"), 34822208Sdavidn .type = PLL_REFE, 34922208Sdavidn .base_reg = PLLRE_BASE, 35022208Sdavidn .misc_reg = PLLRE_MISC, 35122208Sdavidn .lock_mask = PLLRE_MISC_LOCK, 35222208Sdavidn .lock_enable = PLLRE_MISC_LOCK_ENABLE, 35322208Sdavidn .iddq_reg = PLLRE_MISC, 35422208Sdavidn .iddq_mask = 1 << PLLRE_IDDQ_BIT, 35522208Sdavidn .pdiv_table = pllrefe_map, 35622208Sdavidn .mnp_bits = {8, 8, 4, 16}, 357126952Sbde }, 35822208Sdavidn/* PLLE: generate the 100 MHz reference clock for USB 3.0 (spread spectrum) */ 35922208Sdavidn { 36022208Sdavidn PLL(TEGRA124_CLK_PLL_E, "pllE_out0", "pllE_src"), 36122208Sdavidn .type = PLL_E, 36222208Sdavidn .base_reg = PLLE_BASE, 36322208Sdavidn .misc_reg = PLLE_MISC, 36422208Sdavidn .lock_mask = PLLE_MISC_LOCK, 36522208Sdavidn .lock_enable = PLLE_MISC_LOCK_ENABLE, 36622208Sdavidn .mnp_bits = {8, 8, 4, 24}, 36722208Sdavidn }, 36822208Sdavidn/* PLLDP: 600 MHz Clock source for eDP/LVDS (spread spectrum) */ 36922208Sdavidn { 37022208Sdavidn PLL(0, "pllDP_out0", "pllDP_src"), 37122208Sdavidn .type = PLL_DP, 37222208Sdavidn .base_reg = PLLDP_BASE, 37322208Sdavidn .misc_reg = PLLDP_MISC, 37422208Sdavidn .lock_mask = PLL_BASE_LOCK, 37522208Sdavidn .lock_enable = PLLSS_MISC_LOCK_ENABLE, 37622208Sdavidn .iddq_reg = PLLDP_BASE, 37722208Sdavidn .iddq_mask = 1 << PLLSS_IDDQ_BIT, 37822208Sdavidn .pdiv_table = pll12g_ssd_esd_map, 37922208Sdavidn .mnp_bits = {8, 8, 4, 20}, 38022208Sdavidn }, 38122208Sdavidn}; 38222208Sdavidn 38322208Sdavidnstatic int tegra124_pll_init(struct clknode *clk, device_t dev); 38422208Sdavidnstatic int tegra124_pll_set_gate(struct clknode *clk, bool enable); 38522208Sdavidnstatic int tegra124_pll_recalc(struct clknode *clk, uint64_t *freq); 38622208Sdavidnstatic int tegra124_pll_set_freq(struct clknode *clknode, uint64_t fin, 38790301Simp uint64_t *fout, int flags, int *stop); 38822208Sdavidnstruct pll_sc { 38922208Sdavidn device_t clkdev; 39022208Sdavidn enum pll_type type; 39122208Sdavidn uint32_t base_reg; 39222208Sdavidn uint32_t misc_reg; 39322208Sdavidn uint32_t lock_mask; 39422208Sdavidn uint32_t lock_enable; 39522208Sdavidn uint32_t iddq_reg; 39622208Sdavidn uint32_t iddq_mask; 39722208Sdavidn uint32_t flags; 39822208Sdavidn struct pdiv_table *pdiv_table; 39922208Sdavidn struct mnp_bits mnp_bits; 40022208Sdavidn}; 40122208Sdavidn 40222208Sdavidnstatic clknode_method_t tegra124_pll_methods[] = { 40322208Sdavidn /* Device interface */ 40422208Sdavidn CLKNODEMETHOD(clknode_init, tegra124_pll_init), 40522208Sdavidn CLKNODEMETHOD(clknode_set_gate, tegra124_pll_set_gate), 40622208Sdavidn CLKNODEMETHOD(clknode_recalc_freq, tegra124_pll_recalc), 40722208Sdavidn CLKNODEMETHOD(clknode_set_freq, tegra124_pll_set_freq), 40822208Sdavidn CLKNODEMETHOD_END 40922208Sdavidn}; 41022208SdavidnDEFINE_CLASS_1(tegra124_pll, tegra124_pll_class, tegra124_pll_methods, 41122208Sdavidn sizeof(struct pll_sc), clknode_class); 41222208Sdavidn 41322208Sdavidnstatic int 41422208Sdavidnpll_enable(struct pll_sc *sc) 41522208Sdavidn{ 41622208Sdavidn uint32_t reg; 41722208Sdavidn 41822208Sdavidn 41922208Sdavidn RD4(sc, sc->base_reg, ®); 42022208Sdavidn if (sc->type != PLL_E) 42122208Sdavidn reg &= ~PLL_BASE_BYPASS; 42222208Sdavidn reg |= PLL_BASE_ENABLE; 42322208Sdavidn WR4(sc, sc->base_reg, reg); 42422208Sdavidn return (0); 42522208Sdavidn} 42622208Sdavidn 42722208Sdavidnstatic int 42822208Sdavidnpll_disable(struct pll_sc *sc) 42922208Sdavidn{ 43022208Sdavidn uint32_t reg; 43122208Sdavidn 43222208Sdavidn RD4(sc, sc->base_reg, ®); 43322208Sdavidn if (sc->type != PLL_E) 43422208Sdavidn reg |= PLL_BASE_BYPASS; 43522208Sdavidn reg &= ~PLL_BASE_ENABLE; 43622208Sdavidn WR4(sc, sc->base_reg, reg); 43722208Sdavidn return (0); 43822208Sdavidn} 43922208Sdavidn 44090301Simpstatic uint32_t 44122208Sdavidnpdiv_to_reg(struct pll_sc *sc, uint32_t p_div) 44222208Sdavidn{ 44322208Sdavidn struct pdiv_table *tbl; 44422208Sdavidn 44522208Sdavidn tbl = sc->pdiv_table; 44622208Sdavidn if (tbl == NULL) 44722208Sdavidn return (ffs(p_div) - 1); 44822208Sdavidn 44922208Sdavidn while (tbl->divider != 0) { 45022208Sdavidn if (p_div <= tbl->divider) 45122208Sdavidn return (tbl->value); 45222208Sdavidn tbl++; 45322208Sdavidn } 45422491Sdavidn return (0xFFFFFFFF); 45522491Sdavidn} 45622491Sdavidn 45722208Sdavidnstatic uint32_t 45822491Sdavidnreg_to_pdiv(struct pll_sc *sc, uint32_t reg) 45922491Sdavidn{ 46022491Sdavidn struct pdiv_table *tbl; 46122491Sdavidn 46222208Sdavidn tbl = sc->pdiv_table; 46322491Sdavidn if (tbl == NULL) 46422491Sdavidn return (1 << reg); 46522208Sdavidn 46622491Sdavidn while (tbl->divider) { 46722491Sdavidn if (reg == tbl->value) 46822491Sdavidn return (tbl->divider); 46922491Sdavidn tbl++; 47022491Sdavidn } 47122491Sdavidn return (0); 47222208Sdavidn} 47322491Sdavidn 47422491Sdavidnstatic uint32_t 47522491Sdavidnget_masked(uint32_t val, uint32_t shift, uint32_t width) 47622208Sdavidn{ 47722491Sdavidn 47822491Sdavidn return ((val >> shift) & ((1 << width) - 1)); 47922491Sdavidn} 48022491Sdavidn 48122208Sdavidnstatic uint32_t 48222208Sdavidnset_masked(uint32_t val, uint32_t v, uint32_t shift, uint32_t width) 48322208Sdavidn{ 48422208Sdavidn 48522208Sdavidn val &= ~(((1 << width) - 1) << shift); 48622208Sdavidn val |= (v & ((1 << width) - 1)) << shift; 48722208Sdavidn return (val); 48822208Sdavidn} 489 490static void 491get_divisors(struct pll_sc *sc, uint32_t *m, uint32_t *n, uint32_t *p) 492{ 493 uint32_t val; 494 struct mnp_bits *mnp_bits; 495 496 mnp_bits = &sc->mnp_bits; 497 RD4(sc, sc->base_reg, &val); 498 *m = get_masked(val, PLL_BASE_DIVM_SHIFT, mnp_bits->m_width); 499 *n = get_masked(val, PLL_BASE_DIVN_SHIFT, mnp_bits->n_width); 500 *p = get_masked(val, mnp_bits->p_shift, mnp_bits->p_width); 501} 502 503static uint32_t 504set_divisors(struct pll_sc *sc, uint32_t val, uint32_t m, uint32_t n, 505 uint32_t p) 506{ 507 struct mnp_bits *mnp_bits; 508 509 mnp_bits = &sc->mnp_bits; 510 val = set_masked(val, m, PLL_BASE_DIVM_SHIFT, mnp_bits->m_width); 511 val = set_masked(val, n, PLL_BASE_DIVN_SHIFT, mnp_bits->n_width); 512 val = set_masked(val, p, mnp_bits->p_shift, mnp_bits->p_width); 513 return (val); 514} 515 516static bool 517is_locked(struct pll_sc *sc) 518{ 519 uint32_t reg; 520 521 switch (sc->type) { 522 case PLL_REFE: 523 RD4(sc, sc->misc_reg, ®); 524 reg &= PLLRE_MISC_LOCK; 525 break; 526 527 case PLL_E: 528 RD4(sc, sc->misc_reg, ®); 529 reg &= PLLE_MISC_LOCK; 530 break; 531 532 default: 533 RD4(sc, sc->base_reg, ®); 534 reg &= PLL_BASE_LOCK; 535 break; 536 } 537 return (reg != 0); 538} 539 540static int 541wait_for_lock(struct pll_sc *sc) 542{ 543 int i; 544 545 for (i = PLL_LOCK_TIMEOUT / 10; i > 0; i--) { 546 if (is_locked(sc)) 547 break; 548 DELAY(10); 549 } 550 if (i <= 0) { 551 printf("PLL lock timeout\n"); 552 return (ETIMEDOUT); 553 } 554 return (0); 555} 556 557static int 558plle_enable(struct pll_sc *sc) 559{ 560 uint32_t reg; 561 int rv; 562 struct mnp_bits *mnp_bits; 563 uint32_t pll_m = 1; 564 uint32_t pll_n = 200; 565 uint32_t pll_p = 13; 566 uint32_t pll_cml = 13; 567 568 mnp_bits = &sc->mnp_bits; 569 570 571 /* Disable lock override. */ 572 RD4(sc, sc->base_reg, ®); 573 reg &= ~PLLE_BASE_LOCK_OVERRIDE; 574 WR4(sc, sc->base_reg, reg); 575 576 RD4(sc, PLLE_AUX, ®); 577 reg |= PLLE_AUX_ENABLE_SWCTL; 578 reg &= ~PLLE_AUX_SEQ_ENABLE; 579 WR4(sc, PLLE_AUX, reg); 580 DELAY(10); 581 582 RD4(sc, sc->misc_reg, ®); 583 reg |= PLLE_MISC_LOCK_ENABLE; 584 reg |= PLLE_MISC_IDDQ_SWCTL; 585 reg &= ~PLLE_MISC_IDDQ_OVERRIDE_VALUE; 586 reg |= PLLE_MISC_PTS; 587 reg |= PLLE_MISC_VREG_BG_CTRL_MASK; 588 reg |= PLLE_MISC_VREG_CTRL_MASK; 589 WR4(sc, sc->misc_reg, reg); 590 DELAY(10); 591 592 RD4(sc, PLLE_SS_CNTL, ®); 593 reg |= PLLE_SS_CNTL_DISABLE; 594 WR4(sc, PLLE_SS_CNTL, reg); 595 596 RD4(sc, sc->base_reg, ®); 597 reg = set_divisors(sc, reg, pll_m, pll_n, pll_p); 598 reg &= ~(PLLE_BASE_DIVCML_MASK << PLLE_BASE_DIVCML_SHIFT); 599 reg |= pll_cml << PLLE_BASE_DIVCML_SHIFT; 600 WR4(sc, sc->base_reg, reg); 601 DELAY(10); 602 603 pll_enable(sc); 604 rv = wait_for_lock(sc); 605 if (rv != 0) 606 return (rv); 607 608 RD4(sc, PLLE_SS_CNTL, ®); 609 reg &= ~PLLE_SS_CNTL_SSCCENTER; 610 reg &= ~PLLE_SS_CNTL_SSCINVERT; 611 reg &= ~PLLE_SS_CNTL_COEFFICIENTS_MASK; 612 reg |= PLLE_SS_CNTL_COEFFICIENTS_VAL; 613 WR4(sc, PLLE_SS_CNTL, reg); 614 reg &= ~PLLE_SS_CNTL_SSCBYP; 615 reg &= ~PLLE_SS_CNTL_BYPASS_SS; 616 WR4(sc, PLLE_SS_CNTL, reg); 617 DELAY(10); 618 619 reg &= ~PLLE_SS_CNTL_INTERP_RESET; 620 WR4(sc, PLLE_SS_CNTL, reg); 621 DELAY(10); 622 623 /* HW control of brick pll. */ 624 RD4(sc, sc->misc_reg, ®); 625 reg &= ~PLLE_MISC_IDDQ_SWCTL; 626 WR4(sc, sc->misc_reg, reg); 627 628 RD4(sc, PLLE_AUX, ®); 629 reg |= PLLE_AUX_USE_LOCKDET; 630 reg |= PLLE_AUX_SEQ_START_STATE; 631 reg &= ~PLLE_AUX_ENABLE_SWCTL; 632 reg &= ~PLLE_AUX_SS_SWCTL; 633 WR4(sc, PLLE_AUX, reg); 634 reg |= PLLE_AUX_SEQ_START_STATE; 635 DELAY(10); 636 reg |= PLLE_AUX_SEQ_ENABLE; 637 WR4(sc, PLLE_AUX, reg); 638 639 RD4(sc, XUSBIO_PLL_CFG0, ®); 640 reg |= XUSBIO_PLL_CFG0_PADPLL_USE_LOCKDET; 641 reg |= XUSBIO_PLL_CFG0_SEQ_START_STATE; 642 reg &= ~XUSBIO_PLL_CFG0_CLK_ENABLE_SWCTL; 643 reg &= ~XUSBIO_PLL_CFG0_PADPLL_RESET_SWCTL; 644 WR4(sc, XUSBIO_PLL_CFG0, reg); 645 DELAY(10); 646 647 reg |= XUSBIO_PLL_CFG0_SEQ_ENABLE; 648 WR4(sc, XUSBIO_PLL_CFG0, reg); 649 650 651 /* Enable HW control and unreset SATA PLL. */ 652 RD4(sc, SATA_PLL_CFG0, ®); 653 reg &= ~SATA_PLL_CFG0_PADPLL_RESET_SWCTL; 654 reg &= ~SATA_PLL_CFG0_PADPLL_RESET_OVERRIDE_VALUE; 655 reg |= SATA_PLL_CFG0_PADPLL_USE_LOCKDET; 656 reg &= ~SATA_PLL_CFG0_SEQ_IN_SWCTL; 657 reg &= ~SATA_PLL_CFG0_SEQ_RESET_INPUT_VALUE; 658 reg &= ~SATA_PLL_CFG0_SEQ_LANE_PD_INPUT_VALUE; 659 reg &= ~SATA_PLL_CFG0_SEQ_PADPLL_PD_INPUT_VALUE; 660 reg &= ~SATA_PLL_CFG0_SEQ_ENABLE; 661 reg |= SATA_PLL_CFG0_SEQ_START_STATE; 662 WR4(sc, SATA_PLL_CFG0, reg); 663 DELAY(10); 664 reg |= SATA_PLL_CFG0_SEQ_ENABLE; 665 WR4(sc, SATA_PLL_CFG0, reg); 666 667 /* Enable HW control of PCIe PLL. */ 668 RD4(sc, PCIE_PLL_CFG0, ®); 669 reg |= PCIE_PLL_CFG0_SEQ_ENABLE; 670 WR4(sc, PCIE_PLL_CFG0, reg); 671 672 return (0); 673} 674 675static int 676tegra124_pll_set_gate(struct clknode *clknode, bool enable) 677{ 678 int rv; 679 struct pll_sc *sc; 680 681 sc = clknode_get_softc(clknode); 682 if (enable == 0) { 683 rv = pll_disable(sc); 684 return(rv); 685 } 686 687 if (sc->type == PLL_E) 688 rv = plle_enable(sc); 689 else 690 rv = pll_enable(sc); 691 return (rv); 692} 693 694static int 695pll_set_std(struct pll_sc *sc, uint64_t fin, uint64_t *fout, int flags, 696 uint32_t m, uint32_t n, uint32_t p) 697{ 698 uint32_t reg; 699 struct mnp_bits *mnp_bits; 700 int rv; 701 702 mnp_bits = &sc->mnp_bits; 703 if (m >= (1 << mnp_bits->m_width)) 704 return (ERANGE); 705 if (n >= (1 << mnp_bits->n_width)) 706 return (ERANGE); 707 if (pdiv_to_reg(sc, p) >= (1 << mnp_bits->p_width)) 708 return (ERANGE); 709 710 if (flags & CLK_SET_DRYRUN) { 711 if (((flags & (CLK_SET_ROUND_UP | CLK_SET_ROUND_DOWN)) == 0) && 712 (*fout != (((fin / m) * n) /p))) 713 return (ERANGE); 714 715 *fout = ((fin / m) * n) /p; 716 717 return (0); 718 } 719 720 pll_disable(sc); 721 722 /* take pll out of IDDQ */ 723 if (sc->iddq_reg != 0) 724 MD4(sc, sc->iddq_reg, sc->iddq_mask, 0); 725 726 RD4(sc, sc->base_reg, ®); 727 reg = set_masked(reg, m, PLL_BASE_DIVM_SHIFT, mnp_bits->m_width); 728 reg = set_masked(reg, n, PLL_BASE_DIVN_SHIFT, mnp_bits->n_width); 729 reg = set_masked(reg, pdiv_to_reg(sc, p), mnp_bits->p_shift, 730 mnp_bits->p_width); 731 WR4(sc, sc->base_reg, reg); 732 733 /* Enable PLL. */ 734 RD4(sc, sc->base_reg, ®); 735 reg |= PLL_BASE_ENABLE; 736 WR4(sc, sc->base_reg, reg); 737 738 /* Enable lock detection. */ 739 RD4(sc, sc->misc_reg, ®); 740 reg |= sc->lock_enable; 741 WR4(sc, sc->misc_reg, reg); 742 743 rv = wait_for_lock(sc); 744 if (rv != 0) { 745 /* Disable PLL */ 746 RD4(sc, sc->base_reg, ®); 747 reg &= ~PLL_BASE_ENABLE; 748 WR4(sc, sc->base_reg, reg); 749 return (rv); 750 } 751 RD4(sc, sc->misc_reg, ®); 752 753 pll_enable(sc); 754 *fout = ((fin / m) * n) / p; 755 return 0; 756} 757 758static int 759plla_set_freq(struct pll_sc *sc, uint64_t fin, uint64_t *fout, int flags) 760{ 761 uint32_t m, n, p; 762 763 p = 1; 764 m = 5; 765 n = (*fout * p * m + fin / 2)/ fin; 766 dprintf("%s: m: %d, n: %d, p: %d\n", __func__, m, n, p); 767 return (pll_set_std(sc, fin, fout, flags, m, n, p)); 768} 769 770static int 771pllc_set_freq(struct pll_sc *sc, uint64_t fin, uint64_t *fout, int flags) 772{ 773 uint32_t m, n, p; 774 775 p = 2; 776 m = 1; 777 n = (*fout * p * m + fin / 2)/ fin; 778 dprintf("%s: m: %d, n: %d, p: %d\n", __func__, m, n, p); 779 return (pll_set_std( sc, fin, fout, flags, m, n, p)); 780} 781 782/* 783 * PLLD2 is used as source for pixel clock for HDMI. 784 * We must be able to set it frequency very flexibly and 785 * precisely (within 5% tolerance limit allowed by HDMI specs). 786 * 787 * For this reason, it is necessary to search the full state space. 788 * Fortunately, thanks to early cycle terminations, performance 789 * is within acceptable limits. 790 */ 791#define PLLD2_PFD_MIN 12000000 /* 12 MHz */ 792#define PLLD2_PFD_MAX 38000000 /* 38 MHz */ 793#define PLLD2_VCO_MIN 600000000 /* 600 MHz */ 794#define PLLD2_VCO_MAX 1200000000 /* 1.2 GHz */ 795 796static int 797plld2_set_freq(struct pll_sc *sc, uint64_t fin, uint64_t *fout, int flags) 798{ 799 uint32_t m, n, p; 800 uint32_t best_m, best_n, best_p; 801 uint64_t vco, pfd; 802 int64_t err, best_err; 803 struct mnp_bits *mnp_bits; 804 struct pdiv_table *tbl; 805 int p_idx, rv; 806 807 mnp_bits = &sc->mnp_bits; 808 tbl = sc->pdiv_table; 809 best_err = INT64_MAX; 810 811 for (p_idx = 0; tbl[p_idx].divider != 0; p_idx++) { 812 p = tbl[p_idx].divider; 813 814 /* Check constraints */ 815 vco = *fout * p; 816 if (vco < PLLD2_VCO_MIN) 817 continue; 818 if (vco > PLLD2_VCO_MAX) 819 break; 820 821 for (m = 1; m < (1 << mnp_bits->m_width); m++) { 822 n = (*fout * p * m + fin / 2) / fin; 823 824 /* Check constraints */ 825 if (n == 0) 826 continue; 827 if (n >= (1 << mnp_bits->n_width)) 828 break; 829 vco = (fin * n) / m; 830 if (vco > PLLD2_VCO_MAX || vco < PLLD2_VCO_MIN) 831 continue; 832 pfd = fin / m; 833 if (pfd > PLLD2_PFD_MAX || vco < PLLD2_PFD_MIN) 834 continue; 835 836 /* Constraints passed, save best result */ 837 err = *fout - vco / p; 838 if (err < 0) 839 err = -err; 840 if (err < best_err) { 841 best_err = err; 842 best_p = p; 843 best_m = m; 844 best_n = n; 845 } 846 if (err == 0) 847 goto done; 848 } 849 } 850done: 851 /* 852 * HDMI specification allows 5% pixel clock tolerance, 853 * we will by a slightly stricter 854 */ 855 if (best_err > ((*fout * 100) / 4)) 856 return (ERANGE); 857 858 if (flags & CLK_SET_DRYRUN) 859 return (0); 860 rv = pll_set_std(sc, fin, fout, flags, best_m, best_n, best_p); 861 /* XXXX Panic for rv == ERANGE ? */ 862 return (rv); 863} 864 865static int 866pllrefe_set_freq(struct pll_sc *sc, uint64_t fin, uint64_t *fout, int flags) 867{ 868 uint32_t m, n, p; 869 870 m = 1; 871 p = 1; 872 n = *fout * p * m / fin; 873 dprintf("%s: m: %d, n: %d, p: %d\n", __func__, m, n, p); 874 return (pll_set_std(sc, fin, fout, flags, m, n, p)); 875} 876 877static int 878pllx_set_freq(struct pll_sc *sc, uint64_t fin, uint64_t *fout, int flags) 879{ 880 uint32_t reg; 881 uint32_t m, n, p; 882 struct mnp_bits *mnp_bits; 883 int rv; 884 885 mnp_bits = &sc->mnp_bits; 886 887 p = 1; 888 m = 1; 889 n = (*fout * p * m + fin / 2)/ fin; 890 dprintf("%s: m: %d, n: %d, p: %d\n", __func__, m, n, p); 891 892 if (m >= (1 << mnp_bits->m_width)) 893 return (ERANGE); 894 if (n >= (1 << mnp_bits->n_width)) 895 return (ERANGE); 896 if (pdiv_to_reg(sc, p) >= (1 << mnp_bits->p_width)) 897 return (ERANGE); 898 899 if (flags & CLK_SET_DRYRUN) { 900 if (((flags & (CLK_SET_ROUND_UP | CLK_SET_ROUND_DOWN)) == 0) && 901 (*fout != (((fin / m) * n) /p))) 902 return (ERANGE); 903 *fout = ((fin / m) * n) /p; 904 return (0); 905 } 906 907 /* PLLX doesn't have bypass, disable it first. */ 908 RD4(sc, sc->base_reg, ®); 909 reg &= ~PLL_BASE_ENABLE; 910 WR4(sc, sc->base_reg, reg); 911 912 /* Set PLL. */ 913 RD4(sc, sc->base_reg, ®); 914 reg = set_masked(reg, m, PLL_BASE_DIVM_SHIFT, mnp_bits->m_width); 915 reg = set_masked(reg, n, PLL_BASE_DIVN_SHIFT, mnp_bits->n_width); 916 reg = set_masked(reg, pdiv_to_reg(sc, p), mnp_bits->p_shift, 917 mnp_bits->p_width); 918 WR4(sc, sc->base_reg, reg); 919 RD4(sc, sc->base_reg, ®); 920 DELAY(100); 921 922 /* Enable lock detection. */ 923 RD4(sc, sc->misc_reg, ®); 924 reg |= sc->lock_enable; 925 WR4(sc, sc->misc_reg, reg); 926 927 /* Enable PLL. */ 928 RD4(sc, sc->base_reg, ®); 929 reg |= PLL_BASE_ENABLE; 930 WR4(sc, sc->base_reg, reg); 931 932 rv = wait_for_lock(sc); 933 if (rv != 0) { 934 /* Disable PLL */ 935 RD4(sc, sc->base_reg, ®); 936 reg &= ~PLL_BASE_ENABLE; 937 WR4(sc, sc->base_reg, reg); 938 return (rv); 939 } 940 RD4(sc, sc->misc_reg, ®); 941 942 *fout = ((fin / m) * n) / p; 943 return (0); 944} 945 946static int 947tegra124_pll_set_freq(struct clknode *clknode, uint64_t fin, uint64_t *fout, 948 int flags, int *stop) 949{ 950 *stop = 1; 951 int rv; 952 struct pll_sc *sc; 953 954 sc = clknode_get_softc(clknode); 955 dprintf("%s: %s requested freq: %llu, input freq: %llu\n", __func__, 956 clknode_get_name(clknode), *fout, fin); 957 switch (sc->type) { 958 case PLL_A: 959 rv = plla_set_freq(sc, fin, fout, flags); 960 break; 961 case PLL_C: 962 rv = pllc_set_freq(sc, fin, fout, flags); 963 break; 964 case PLL_D2: 965 rv = plld2_set_freq(sc, fin, fout, flags); 966 break; 967 968 case PLL_REFE: 969 rv = pllrefe_set_freq(sc, fin, fout, flags); 970 break; 971 972 case PLL_X: 973 rv = pllx_set_freq(sc, fin, fout, flags); 974 break; 975 976 case PLL_U: 977 if (*fout == 480000000) /* PLLU is fixed to 480 MHz */ 978 rv = 0; 979 else 980 rv = ERANGE; 981 break; 982 default: 983 rv = ENXIO; 984 break; 985 } 986 987 return (rv); 988} 989 990 991static int 992tegra124_pll_init(struct clknode *clk, device_t dev) 993{ 994 struct pll_sc *sc; 995 uint32_t reg; 996 997 sc = clknode_get_softc(clk); 998 999 /* If PLL is enabled, enable lock detect too. */ 1000 RD4(sc, sc->base_reg, ®); 1001 if (reg & PLL_BASE_ENABLE) { 1002 RD4(sc, sc->misc_reg, ®); 1003 reg |= sc->lock_enable; 1004 WR4(sc, sc->misc_reg, reg); 1005 } 1006 if (sc->type == PLL_REFE) { 1007 RD4(sc, sc->misc_reg, ®); 1008 reg &= ~(1 << 29); /* Diasble lock override */ 1009 WR4(sc, sc->misc_reg, reg); 1010 } 1011 1012 clknode_init_parent_idx(clk, 0); 1013 return(0); 1014} 1015 1016static int 1017tegra124_pll_recalc(struct clknode *clk, uint64_t *freq) 1018{ 1019 struct pll_sc *sc; 1020 uint32_t m, n, p, pr; 1021 uint32_t reg, misc_reg; 1022 int locked; 1023 1024 sc = clknode_get_softc(clk); 1025 1026 RD4(sc, sc->base_reg, ®); 1027 RD4(sc, sc->misc_reg, &misc_reg); 1028 1029 get_divisors(sc, &m, &n, &pr); 1030 if (sc->type != PLL_E) 1031 p = reg_to_pdiv(sc, pr); 1032 else 1033 p = 2 * (pr - 1); 1034 locked = is_locked(sc); 1035 1036 dprintf("%s: %s (0x%08x, 0x%08x) - m: %d, n: %d, p: %d (%d): " 1037 "e: %d, r: %d, o: %d - %s\n", __func__, 1038 clknode_get_name(clk), reg, misc_reg, m, n, p, pr, 1039 (reg >> 30) & 1, (reg >> 29) & 1, (reg >> 28) & 1, 1040 locked ? "locked" : "unlocked"); 1041 1042 if ((m == 0) || (n == 0) || (p == 0)) { 1043 *freq = 0; 1044 return (EINVAL); 1045 } 1046 *freq = ((*freq / m) * n) / p; 1047 return (0); 1048} 1049 1050static int 1051pll_register(struct clkdom *clkdom, struct clk_pll_def *clkdef) 1052{ 1053 struct clknode *clk; 1054 struct pll_sc *sc; 1055 1056 clk = clknode_create(clkdom, &tegra124_pll_class, &clkdef->clkdef); 1057 if (clk == NULL) 1058 return (ENXIO); 1059 1060 sc = clknode_get_softc(clk); 1061 sc->clkdev = clknode_get_device(clk); 1062 sc->type = clkdef->type; 1063 sc->base_reg = clkdef->base_reg; 1064 sc->misc_reg = clkdef->misc_reg; 1065 sc->lock_mask = clkdef->lock_mask; 1066 sc->lock_enable = clkdef->lock_enable; 1067 sc->iddq_reg = clkdef->iddq_reg; 1068 sc->iddq_mask = clkdef->iddq_mask; 1069 sc->flags = clkdef->flags; 1070 sc->pdiv_table = clkdef->pdiv_table; 1071 sc->mnp_bits = clkdef->mnp_bits; 1072 clknode_register(clkdom, clk); 1073 return (0); 1074} 1075 1076static void config_utmi_pll(struct tegra124_car_softc *sc) 1077{ 1078 uint32_t reg; 1079 /* 1080 * XXX Simplified UTMIP settings for 12MHz base clock. 1081 */ 1082#define ENABLE_DELAY_COUNT 0x02 1083#define STABLE_COUNT 0x2F 1084#define ACTIVE_DELAY_COUNT 0x04 1085#define XTAL_FREQ_COUNT 0x76 1086 1087 CLKDEV_READ_4(sc->dev, UTMIP_PLL_CFG2, ®); 1088 reg &= ~UTMIP_PLL_CFG2_STABLE_COUNT(~0); 1089 reg |= UTMIP_PLL_CFG2_STABLE_COUNT(STABLE_COUNT); 1090 reg &= ~UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(~0); 1091 reg |= UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(ACTIVE_DELAY_COUNT); 1092 reg &= ~UTMIP_PLL_CFG2_FORCE_PD_SAMP_A_POWERDOWN; 1093 reg &= ~UTMIP_PLL_CFG2_FORCE_PD_SAMP_B_POWERDOWN; 1094 reg &= ~UTMIP_PLL_CFG2_FORCE_PD_SAMP_C_POWERDOWN; 1095 CLKDEV_WRITE_4(sc->dev, UTMIP_PLL_CFG2, reg); 1096 1097 CLKDEV_READ_4(sc->dev, UTMIP_PLL_CFG1, ®); 1098 reg &= ~UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(~0); 1099 reg |= UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(ENABLE_DELAY_COUNT); 1100 reg &= ~UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(~0); 1101 reg |= UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(XTAL_FREQ_COUNT); 1102 reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERDOWN; 1103 reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ACTIVE_POWERDOWN; 1104 reg &= ~UTMIP_PLL_CFG1_FORCE_PLLU_POWERUP; 1105 reg &= ~UTMIP_PLL_CFG1_FORCE_PLLU_POWERDOWN; 1106 CLKDEV_WRITE_4(sc->dev, UTMIP_PLL_CFG1, reg); 1107 1108 /* Prepare UTMIP requencer. */ 1109 CLKDEV_READ_4(sc->dev, UTMIPLL_HW_PWRDN_CFG0, ®); 1110 reg |= UTMIPLL_HW_PWRDN_CFG0_USE_LOCKDET; 1111 reg &= ~UTMIPLL_HW_PWRDN_CFG0_CLK_ENABLE_SWCTL; 1112 reg |= UTMIPLL_HW_PWRDN_CFG0_SEQ_START_STATE; 1113 CLKDEV_WRITE_4(sc->dev, UTMIPLL_HW_PWRDN_CFG0, reg); 1114 1115 /* Powerup UTMIP. */ 1116 CLKDEV_READ_4(sc->dev, UTMIP_PLL_CFG1, ®); 1117 reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERUP; 1118 reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERDOWN; 1119 CLKDEV_WRITE_4(sc->dev, UTMIP_PLL_CFG1, reg); 1120 DELAY(10); 1121 1122 /* SW override for UTMIPLL */ 1123 CLKDEV_READ_4(sc->dev, UTMIPLL_HW_PWRDN_CFG0, ®); 1124 reg |= UTMIPLL_HW_PWRDN_CFG0_IDDQ_SWCTL; 1125 reg &= ~UTMIPLL_HW_PWRDN_CFG0_IDDQ_OVERRIDE; 1126 CLKDEV_WRITE_4(sc->dev, UTMIPLL_HW_PWRDN_CFG0, reg); 1127 DELAY(10); 1128 1129 /* HW control of UTMIPLL. */ 1130 CLKDEV_READ_4(sc->dev, UTMIPLL_HW_PWRDN_CFG0, ®); 1131 reg |= UTMIPLL_HW_PWRDN_CFG0_SEQ_ENABLE; 1132 CLKDEV_WRITE_4(sc->dev, UTMIPLL_HW_PWRDN_CFG0, reg); 1133} 1134 1135void 1136tegra124_init_plls(struct tegra124_car_softc *sc) 1137{ 1138 int i, rv; 1139 1140 for (i = 0; i < nitems(pll_clks); i++) { 1141 rv = pll_register(sc->clkdom, pll_clks + i); 1142 if (rv != 0) 1143 panic("pll_register failed"); 1144 } 1145 config_utmi_pll(sc); 1146 1147} 1148