1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * PRCC clock implementation for ux500 platform. 4 * 5 * Copyright (C) 2012 ST-Ericsson SA 6 * Author: Ulf Hansson <ulf.hansson@linaro.org> 7 */ 8 9 #include <linux/clk-provider.h> 10 #include <linux/slab.h> 11 #include <linux/io.h> 12 #include <linux/err.h> 13 #include <linux/types.h> 14 15 #include "clk.h" 16 17 #define PRCC_PCKEN 0x000 18 #define PRCC_PCKDIS 0x004 19 #define PRCC_KCKEN 0x008 20 #define PRCC_KCKDIS 0x00C 21 #define PRCC_PCKSR 0x010 22 #define PRCC_KCKSR 0x014 23 24 #define to_clk_prcc(_hw) container_of(_hw, struct clk_prcc, hw) 25 26 struct clk_prcc { 27 struct clk_hw hw; 28 void __iomem *base; 29 u32 cg_sel; 30 int is_enabled; 31 }; 32 33 /* PRCC clock operations. */ 34 35 static int clk_prcc_pclk_enable(struct clk_hw *hw) 36 { 37 struct clk_prcc *clk = to_clk_prcc(hw); 38 39 writel(clk->cg_sel, (clk->base + PRCC_PCKEN)); 40 while (!(readl(clk->base + PRCC_PCKSR) & clk->cg_sel)) 41 cpu_relax(); 42 43 clk->is_enabled = 1; 44 return 0; 45 } 46 47 static void clk_prcc_pclk_disable(struct clk_hw *hw) 48 { 49 struct clk_prcc *clk = to_clk_prcc(hw); 50 51 writel(clk->cg_sel, (clk->base + PRCC_PCKDIS)); 52 clk->is_enabled = 0; 53 } 54 55 static int clk_prcc_kclk_enable(struct clk_hw *hw) 56 { 57 struct clk_prcc *clk = to_clk_prcc(hw); 58 59 writel(clk->cg_sel, (clk->base + PRCC_KCKEN)); 60 while (!(readl(clk->base + PRCC_KCKSR) & clk->cg_sel)) 61 cpu_relax(); 62 63 clk->is_enabled = 1; 64 return 0; 65 } 66 67 static void clk_prcc_kclk_disable(struct clk_hw *hw) 68 { 69 struct clk_prcc *clk = to_clk_prcc(hw); 70 71 writel(clk->cg_sel, (clk->base + PRCC_KCKDIS)); 72 clk->is_enabled = 0; 73 } 74 75 static int clk_prcc_is_enabled(struct clk_hw *hw) 76 { 77 struct clk_prcc *clk = to_clk_prcc(hw); 78 return clk->is_enabled; 79 } 80 81 static const struct clk_ops clk_prcc_pclk_ops = { 82 .enable = clk_prcc_pclk_enable, 83 .disable = clk_prcc_pclk_disable, 84 .is_enabled = clk_prcc_is_enabled, 85 }; 86 87 static const struct clk_ops clk_prcc_kclk_ops = { 88 .enable = clk_prcc_kclk_enable, 89 .disable = clk_prcc_kclk_disable, 90 .is_enabled = clk_prcc_is_enabled, 91 }; 92 93 static struct clk *clk_reg_prcc(const char *name, 94 const char *parent_name, 95 resource_size_t phy_base, 96 u32 cg_sel, 97 unsigned long flags, 98 const struct clk_ops *clk_prcc_ops) 99 { 100 struct clk_prcc *clk; 101 struct clk_init_data clk_prcc_init; 102 struct clk *clk_reg; 103 104 if (!name) { 105 pr_err("clk_prcc: %s invalid arguments passed\n", __func__); 106 return ERR_PTR(-EINVAL); 107 } 108 109 clk = kzalloc(sizeof(*clk), GFP_KERNEL); 110 if (!clk) 111 return ERR_PTR(-ENOMEM); 112 113 clk->base = ioremap(phy_base, SZ_4K); 114 if (!clk->base) 115 goto free_clk; 116 117 clk->cg_sel = cg_sel; 118 clk->is_enabled = 1; 119 120 clk_prcc_init.name = name; 121 clk_prcc_init.ops = clk_prcc_ops; 122 clk_prcc_init.flags = flags; 123 clk_prcc_init.parent_names = (parent_name ? &parent_name : NULL); 124 clk_prcc_init.num_parents = (parent_name ? 1 : 0); 125 clk->hw.init = &clk_prcc_init; 126 127 clk_reg = clk_register(NULL, &clk->hw); 128 if (IS_ERR_OR_NULL(clk_reg)) 129 goto unmap_clk; 130 131 return clk_reg; 132 133 unmap_clk: 134 iounmap(clk->base); 135 free_clk: 136 kfree(clk); 137 pr_err("clk_prcc: %s failed to register clk\n", __func__); 138 return ERR_PTR(-ENOMEM); 139 } 140 141 struct clk *clk_reg_prcc_pclk(const char *name, 142 const char *parent_name, 143 resource_size_t phy_base, 144 u32 cg_sel, 145 unsigned long flags) 146 { 147 return clk_reg_prcc(name, parent_name, phy_base, cg_sel, flags, 148 &clk_prcc_pclk_ops); 149 } 150 151 struct clk *clk_reg_prcc_kclk(const char *name, 152 const char *parent_name, 153 resource_size_t phy_base, 154 u32 cg_sel, 155 unsigned long flags) 156 { 157 return clk_reg_prcc(name, parent_name, phy_base, cg_sel, flags, 158 &clk_prcc_kclk_ops); 159 } 160