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