1/* 2 * Copyright (c) 2010 3 * Ben Gray <ben.r.gray@gmail.com>. 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by Ben Gray. 17 * 4. The name of the company nor the name of the author may be used to 18 * endorse or promote products derived from this software without specific 19 * prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY BEN GRAY ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL BEN GRAY BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 27 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 28 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 30 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33/** 34 * Power, Reset and Clock Managment Module 35 * 36 * This is a very simple driver wrapper around the PRCM set of registers in 37 * the OMAP3 chip. It allows you to turn on and off things like the functional 38 * and interface clocks to the various on-chip modules. 39 * 40 */ 41#include <sys/cdefs.h> 42__FBSDID("$FreeBSD: releng/10.2/sys/arm/ti/ti_prcm.c 259329 2013-12-13 20:43:11Z ian $"); 43 44#include <sys/param.h> 45#include <sys/systm.h> 46#include <sys/kernel.h> 47#include <sys/module.h> 48#include <sys/bus.h> 49#include <sys/resource.h> 50#include <sys/rman.h> 51#include <sys/lock.h> 52#include <sys/mutex.h> 53 54#include <machine/bus.h> 55#include <machine/cpu.h> 56#include <machine/cpufunc.h> 57#include <machine/resource.h> 58#include <machine/intr.h> 59 60#include <arm/ti/ti_prcm.h> 61 62/** 63 * ti_clk_devmap - Array of clock devices, should be defined one per SoC 64 * 65 * This array is typically defined in one of the targeted *_prcm_clk.c 66 * files and is specific to the given SoC platform. Each entry in the array 67 * corresponds to an individual clock device. 68 */ 69extern struct ti_clock_dev ti_clk_devmap[]; 70 71/** 72 * ti_prcm_clk_dev - returns a pointer to the clock device with given id 73 * @clk: the ID of the clock device to get 74 * 75 * Simply iterates through the clk_devmap global array and returns a pointer 76 * to the clock device if found. 77 * 78 * LOCKING: 79 * None 80 * 81 * RETURNS: 82 * The pointer to the clock device on success, on failure NULL is returned. 83 */ 84static struct ti_clock_dev * 85ti_prcm_clk_dev(clk_ident_t clk) 86{ 87 struct ti_clock_dev *clk_dev; 88 89 /* Find the clock within the devmap - it's a bit inefficent having a for 90 * loop for this, but this function should only called when a driver is 91 * being activated so IMHO not a big issue. 92 */ 93 clk_dev = &(ti_clk_devmap[0]); 94 while (clk_dev->id != INVALID_CLK_IDENT) { 95 if (clk_dev->id == clk) { 96 return (clk_dev); 97 } 98 clk_dev++; 99 } 100 101 /* Sanity check we managed to find the clock */ 102 printf("ti_prcm: Failed to find clock device (%d)\n", clk); 103 return (NULL); 104} 105 106/** 107 * ti_prcm_clk_valid - enables a clock for a particular module 108 * @clk: identifier for the module to enable, see ti_prcm.h for a list 109 * of possible modules. 110 * Example: OMAP3_MODULE_MMC1_ICLK or OMAP3_MODULE_GPTIMER10_FCLK. 111 * 112 * This function can enable either a functional or interface clock. 113 * 114 * The real work done to enable the clock is really done in the callback 115 * function associated with the clock, this function is simply a wrapper 116 * around that. 117 * 118 * LOCKING: 119 * Internally locks the driver context. 120 * 121 * RETURNS: 122 * Returns 0 on success or positive error code on failure. 123 */ 124int 125ti_prcm_clk_valid(clk_ident_t clk) 126{ 127 int ret = 0; 128 129 if (ti_prcm_clk_dev(clk) == NULL) 130 ret = EINVAL; 131 132 return (ret); 133} 134 135 136/** 137 * ti_prcm_clk_enable - enables a clock for a particular module 138 * @clk: identifier for the module to enable, see ti_prcm.h for a list 139 * of possible modules. 140 * Example: OMAP3_MODULE_MMC1_ICLK or OMAP3_MODULE_GPTIMER10_FCLK. 141 * 142 * This function can enable either a functional or interface clock. 143 * 144 * The real work done to enable the clock is really done in the callback 145 * function associated with the clock, this function is simply a wrapper 146 * around that. 147 * 148 * LOCKING: 149 * Internally locks the driver context. 150 * 151 * RETURNS: 152 * Returns 0 on success or positive error code on failure. 153 */ 154int 155ti_prcm_clk_enable(clk_ident_t clk) 156{ 157 struct ti_clock_dev *clk_dev; 158 int ret; 159 160 /* Find the clock within the devmap - it's a bit inefficent having a for 161 * loop for this, but this function should only called when a driver is 162 * being activated so IMHO not a big issue. 163 */ 164 clk_dev = ti_prcm_clk_dev(clk); 165 166 /* Sanity check we managed to find the clock */ 167 if (clk_dev == NULL) 168 return (EINVAL); 169 170 /* Activate the clock */ 171 if (clk_dev->clk_activate) 172 ret = clk_dev->clk_activate(clk_dev); 173 else 174 ret = EINVAL; 175 176 return (ret); 177} 178 179 180/** 181 * ti_prcm_clk_disable - disables a clock for a particular module 182 * @clk: identifier for the module to enable, see ti_prcm.h for a list 183 * of possible modules. 184 * Example: OMAP3_MODULE_MMC1_ICLK or OMAP3_MODULE_GPTIMER10_FCLK. 185 * 186 * This function can enable either a functional or interface clock. 187 * 188 * The real work done to enable the clock is really done in the callback 189 * function associated with the clock, this function is simply a wrapper 190 * around that. 191 * 192 * LOCKING: 193 * Internally locks the driver context. 194 * 195 * RETURNS: 196 * Returns 0 on success or positive error code on failure. 197 */ 198int 199ti_prcm_clk_disable(clk_ident_t clk) 200{ 201 struct ti_clock_dev *clk_dev; 202 int ret; 203 204 /* Find the clock within the devmap - it's a bit inefficent having a for 205 * loop for this, but this function should only called when a driver is 206 * being activated so IMHO not a big issue. 207 */ 208 clk_dev = ti_prcm_clk_dev(clk); 209 210 /* Sanity check we managed to find the clock */ 211 if (clk_dev == NULL) 212 return (EINVAL); 213 214 /* Activate the clock */ 215 if (clk_dev->clk_deactivate) 216 ret = clk_dev->clk_deactivate(clk_dev); 217 else 218 ret = EINVAL; 219 220 return (ret); 221} 222 223/** 224 * ti_prcm_clk_set_source - sets the source 225 * @clk: identifier for the module to enable, see ti_prcm.h for a list 226 * of possible modules. 227 * Example: OMAP3_MODULE_MMC1_ICLK or OMAP3_MODULE_GPTIMER10_FCLK. 228 * 229 * This function can enable either a functional or interface clock. 230 * 231 * The real work done to enable the clock is really done in the callback 232 * function associated with the clock, this function is simply a wrapper 233 * around that. 234 * 235 * LOCKING: 236 * Internally locks the driver context. 237 * 238 * RETURNS: 239 * Returns 0 on success or positive error code on failure. 240 */ 241int 242ti_prcm_clk_set_source(clk_ident_t clk, clk_src_t clksrc) 243{ 244 struct ti_clock_dev *clk_dev; 245 int ret; 246 247 /* Find the clock within the devmap - it's a bit inefficent having a for 248 * loop for this, but this function should only called when a driver is 249 * being activated so IMHO not a big issue. 250 */ 251 clk_dev = ti_prcm_clk_dev(clk); 252 253 /* Sanity check we managed to find the clock */ 254 if (clk_dev == NULL) 255 return (EINVAL); 256 257 /* Activate the clock */ 258 if (clk_dev->clk_set_source) 259 ret = clk_dev->clk_set_source(clk_dev, clksrc); 260 else 261 ret = EINVAL; 262 263 return (ret); 264} 265 266 267/** 268 * ti_prcm_clk_get_source_freq - gets the source clock frequency 269 * @clk: identifier for the module to enable, see ti_prcm.h for a list 270 * of possible modules. 271 * @freq: pointer to an integer that upon return will contain the src freq 272 * 273 * This function returns the frequency of the source clock. 274 * 275 * The real work done to enable the clock is really done in the callback 276 * function associated with the clock, this function is simply a wrapper 277 * around that. 278 * 279 * LOCKING: 280 * Internally locks the driver context. 281 * 282 * RETURNS: 283 * Returns 0 on success or positive error code on failure. 284 */ 285int 286ti_prcm_clk_get_source_freq(clk_ident_t clk, unsigned int *freq) 287{ 288 struct ti_clock_dev *clk_dev; 289 int ret; 290 291 /* Find the clock within the devmap - it's a bit inefficent having a for 292 * loop for this, but this function should only called when a driver is 293 * being activated so IMHO not a big issue. 294 */ 295 clk_dev = ti_prcm_clk_dev(clk); 296 297 /* Sanity check we managed to find the clock */ 298 if (clk_dev == NULL) 299 return (EINVAL); 300 301 /* Get the source frequency of the clock */ 302 if (clk_dev->clk_get_source_freq) 303 ret = clk_dev->clk_get_source_freq(clk_dev, freq); 304 else 305 ret = EINVAL; 306 307 return (ret); 308} 309