1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 2011 5 * Ben Gray <ben.r.gray@gmail.com>. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. The name of the company nor the name of the author may be used to 17 * endorse or promote products derived from this software without specific 18 * prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY BEN GRAY ``AS IS'' AND ANY EXPRESS OR 21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 23 * IN NO EVENT SHALL BEN GRAY BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 26 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 28 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 29 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __FBSDID("$FreeBSD$"); 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/module.h> 39 #include <sys/bus.h> 40 #include <sys/resource.h> 41 #include <sys/rman.h> 42 #include <sys/lock.h> 43 #include <sys/malloc.h> 44 45 #include <machine/bus.h> 46 #include <machine/resource.h> 47 #include <machine/intr.h> 48 49 #include <arm/arm/mpcore_timervar.h> 50 #include <arm/ti/tivar.h> 51 #include <arm/ti/ti_prcm.h> 52 #include <arm/ti/omap4/omap4_reg.h> 53 54 #include <dev/ofw/openfirm.h> 55 #include <dev/ofw/ofw_bus.h> 56 #include <dev/ofw/ofw_bus_subr.h> 57 58 /* 59 * This file defines the clock configuration for the OMAP4xxx series of 60 * devices. 61 * 62 * How This is Suppose to Work 63 * =========================== 64 * - There is a top level omap_prcm module that defines all OMAP SoC drivers 65 * should use to enable/disable the system clocks regardless of the version 66 * of OMAP device they are running on. This top level PRCM module is just 67 * a thin shim to chip specific functions that perform the donkey work of 68 * configuring the clock - this file is the 'donkey' for OMAP44xx devices. 69 * 70 * - The key bit in this file is the omap_clk_devmap array, it's 71 * used by the omap_prcm driver to determine what clocks are valid and which 72 * functions to call to manipulate them. 73 * 74 * - In essence you just need to define some callbacks for each of the 75 * clocks and then you're done. 76 * 77 * - The other thing that is worth noting is that when the omap_prcm device 78 * is registered you typically pass in some memory ranges which are the 79 * SYS_MEMORY resources. These resources are in turn allocated using 80 * bus_allocate_resources(...) and the resource handles are passed to all 81 * individual clock callback handlers. 82 * 83 * 84 * 85 * OMAP4 devices are different from the previous OMAP3 devices in that there 86 * is no longer a separate functional and interface clock for each module, 87 * instead there is typically an interface clock that spans many modules. 88 */ 89 90 #define FREQ_96MHZ 96000000 91 #define FREQ_64MHZ 64000000 92 #define FREQ_48MHZ 48000000 93 #define FREQ_32KHZ 32000 94 95 #define PRM_INSTANCE 1 96 #define CM1_INSTANCE 2 97 #define CM2_INSTANCE 3 98 99 /** 100 * Address offsets from the PRM memory region to the top level clock control 101 * registers. 102 */ 103 #define CKGEN_PRM_OFFSET 0x00000100UL 104 #define MPU_PRM_OFFSET 0x00000300UL 105 #define DSP_PRM_OFFSET 0x00000400UL 106 #define ABE_PRM_OFFSET 0x00000500UL 107 #define ALWAYS_ON_PRM_OFFSET 0x00000600UL 108 #define CORE_PRM_OFFSET 0x00000700UL 109 #define IVAHD_PRM_OFFSET 0x00000F00UL 110 #define CAM_PRM_OFFSET 0x00001000UL 111 #define DSS_PRM_OFFSET 0x00001100UL 112 #define SGX_PRM_OFFSET 0x00001200UL 113 #define L3INIT_PRM_OFFSET 0x00001300UL 114 #define L4PER_PRM_OFFSET 0x00001400UL 115 #define WKUP_PRM_OFFSET 0x00001700UL 116 #define WKUP_CM_OFFSET 0x00001800UL 117 #define EMU_PRM_OFFSET 0x00001900UL 118 #define EMU_CM_OFFSET 0x00001A00UL 119 #define DEVICE_PRM_OFFSET 0x00001B00UL 120 #define INSTR_PRM_OFFSET 0x00001F00UL 121 122 #define CM_ABE_DSS_SYS_CLKSEL_OFFSET (CKGEN_PRM_OFFSET + 0x0000UL) 123 #define CM_L4_WKUP_CLKSELL_OFFSET (CKGEN_PRM_OFFSET + 0x0008UL) 124 #define CM_ABE_PLL_REF_CLKSEL_OFFSET (CKGEN_PRM_OFFSET + 0x000CUL) 125 #define CM_SYS_CLKSEL_OFFSET (CKGEN_PRM_OFFSET + 0x0010UL) 126 127 /** 128 * Address offsets from the CM1 memory region to the top level clock control 129 * registers. 130 */ 131 #define CKGEN_CM1_OFFSET 0x00000100UL 132 #define MPU_CM1_OFFSET 0x00000300UL 133 #define DSP_CM1_OFFSET 0x00000400UL 134 #define ABE_CM1_OFFSET 0x00000500UL 135 #define RESTORE_CM1_OFFSET 0x00000E00UL 136 #define INSTR_CM1_OFFSET 0x00000F00UL 137 138 #define CM_CLKSEL_DPLL_MPU (CKGEN_CM1_OFFSET + 0x006CUL) 139 140 /** 141 * Address offsets from the CM2 memory region to the top level clock control 142 * registers. 143 */ 144 #define INTRCONN_SOCKET_CM2_OFFSET 0x00000000UL 145 #define CKGEN_CM2_OFFSET 0x00000100UL 146 #define ALWAYS_ON_CM2_OFFSET 0x00000600UL 147 #define CORE_CM2_OFFSET 0x00000700UL 148 #define IVAHD_CM2_OFFSET 0x00000F00UL 149 #define CAM_CM2_OFFSET 0x00001000UL 150 #define DSS_CM2_OFFSET 0x00001100UL 151 #define SGX_CM2_OFFSET 0x00001200UL 152 #define L3INIT_CM2_OFFSET 0x00001300UL 153 #define L4PER_CM2_OFFSET 0x00001400UL 154 #define RESTORE_CM2_OFFSET 0x00001E00UL 155 #define INSTR_CM2_OFFSET 0x00001F00UL 156 157 #define CLKCTRL_MODULEMODE_MASK 0x00000003UL 158 #define CLKCTRL_MODULEMODE_DISABLE 0x00000000UL 159 #define CLKCTRL_MODULEMODE_AUTO 0x00000001UL 160 #define CLKCTRL_MODULEMODE_ENABLE 0x00000001UL 161 162 #define CLKCTRL_IDLEST_MASK 0x00030000UL 163 #define CLKCTRL_IDLEST_ENABLED 0x00000000UL 164 #define CLKCTRL_IDLEST_WAKING 0x00010000UL 165 #define CLKCTRL_IDLEST_IDLE 0x00020000UL 166 #define CLKCTRL_IDLEST_DISABLED 0x00030000UL 167 168 static struct ofw_compat_data compat_data[] = { 169 {"ti,omap4-cm1", (uintptr_t)CM1_INSTANCE}, 170 {"ti,omap4-cm2", (uintptr_t)CM2_INSTANCE}, 171 {"ti,omap4-prm", (uintptr_t)PRM_INSTANCE}, 172 {NULL, (uintptr_t)0}, 173 }; 174 175 struct omap4_prcm_softc { 176 struct resource *sc_res; 177 int sc_rid; 178 int sc_instance; 179 int attach_done; 180 }; 181 182 static int omap4_clk_generic_activate(struct ti_clock_dev *clkdev); 183 static int omap4_clk_generic_deactivate(struct ti_clock_dev *clkdev); 184 static int omap4_clk_generic_accessible(struct ti_clock_dev *clkdev); 185 static int omap4_clk_generic_set_source(struct ti_clock_dev *clkdev, clk_src_t clksrc); 186 static int omap4_clk_generic_get_source_freq(struct ti_clock_dev *clkdev, unsigned int *freq); 187 188 static int omap4_clk_gptimer_set_source(struct ti_clock_dev *clkdev, clk_src_t clksrc); 189 static int omap4_clk_gptimer_get_source_freq(struct ti_clock_dev *clkdev, unsigned int *freq); 190 191 static int omap4_clk_hsmmc_set_source(struct ti_clock_dev *clkdev, clk_src_t clksrc); 192 static int omap4_clk_hsmmc_get_source_freq(struct ti_clock_dev *clkdev, unsigned int *freq); 193 194 static int omap4_clk_hsusbhost_set_source(struct ti_clock_dev *clkdev, clk_src_t clksrc); 195 static int omap4_clk_hsusbhost_activate(struct ti_clock_dev *clkdev); 196 static int omap4_clk_hsusbhost_deactivate(struct ti_clock_dev *clkdev); 197 static int omap4_clk_hsusbhost_accessible(struct ti_clock_dev *clkdev); 198 199 static int omap4_clk_get_sysclk_freq(struct ti_clock_dev *clkdev, unsigned int *freq); 200 static int omap4_clk_get_arm_fclk_freq(struct ti_clock_dev *clkdev, unsigned int *freq); 201 202 /** 203 * omap_clk_devmap - Array of clock devices available on OMAP4xxx devices 204 * 205 * This map only defines which clocks are valid and the callback functions 206 * for clock activate, deactivate, etc. It is used by the top level omap_prcm 207 * driver. 208 * 209 * The actual details of the clocks (config registers, bit fields, sources, 210 * etc) are in the private g_omap3_clk_details array below. 211 * 212 */ 213 214 #define OMAP4_GENERIC_CLOCK_DEV(i) \ 215 { .id = (i), \ 216 .clk_activate = omap4_clk_generic_activate, \ 217 .clk_deactivate = omap4_clk_generic_deactivate, \ 218 .clk_set_source = omap4_clk_generic_set_source, \ 219 .clk_accessible = omap4_clk_generic_accessible, \ 220 .clk_get_source_freq = omap4_clk_generic_get_source_freq, \ 221 .clk_set_source_freq = NULL \ 222 } 223 224 #define OMAP4_GPTIMER_CLOCK_DEV(i) \ 225 { .id = (i), \ 226 .clk_activate = omap4_clk_generic_activate, \ 227 .clk_deactivate = omap4_clk_generic_deactivate, \ 228 .clk_set_source = omap4_clk_gptimer_set_source, \ 229 .clk_accessible = omap4_clk_generic_accessible, \ 230 .clk_get_source_freq = omap4_clk_gptimer_get_source_freq, \ 231 .clk_set_source_freq = NULL \ 232 } 233 234 #define OMAP4_HSMMC_CLOCK_DEV(i) \ 235 { .id = (i), \ 236 .clk_activate = omap4_clk_generic_activate, \ 237 .clk_deactivate = omap4_clk_generic_deactivate, \ 238 .clk_set_source = omap4_clk_hsmmc_set_source, \ 239 .clk_accessible = omap4_clk_generic_accessible, \ 240 .clk_get_source_freq = omap4_clk_hsmmc_get_source_freq, \ 241 .clk_set_source_freq = NULL \ 242 } 243 244 #define OMAP4_HSUSBHOST_CLOCK_DEV(i) \ 245 { .id = (i), \ 246 .clk_activate = omap4_clk_hsusbhost_activate, \ 247 .clk_deactivate = omap4_clk_hsusbhost_deactivate, \ 248 .clk_set_source = omap4_clk_hsusbhost_set_source, \ 249 .clk_accessible = omap4_clk_hsusbhost_accessible, \ 250 .clk_get_source_freq = NULL, \ 251 .clk_set_source_freq = NULL \ 252 } 253 254 255 struct ti_clock_dev ti_omap4_clk_devmap[] = { 256 257 /* System clocks */ 258 { .id = SYS_CLK, 259 .clk_activate = NULL, 260 .clk_deactivate = NULL, 261 .clk_set_source = NULL, 262 .clk_accessible = NULL, 263 .clk_get_source_freq = omap4_clk_get_sysclk_freq, 264 .clk_set_source_freq = NULL, 265 }, 266 /* MPU (ARM) core clocks */ 267 { .id = MPU_CLK, 268 .clk_activate = NULL, 269 .clk_deactivate = NULL, 270 .clk_set_source = NULL, 271 .clk_accessible = NULL, 272 .clk_get_source_freq = omap4_clk_get_arm_fclk_freq, 273 .clk_set_source_freq = NULL, 274 }, 275 276 277 /* UART device clocks */ 278 OMAP4_GENERIC_CLOCK_DEV(UART1_CLK), 279 OMAP4_GENERIC_CLOCK_DEV(UART2_CLK), 280 OMAP4_GENERIC_CLOCK_DEV(UART3_CLK), 281 OMAP4_GENERIC_CLOCK_DEV(UART4_CLK), 282 283 /* Timer device source clocks */ 284 OMAP4_GPTIMER_CLOCK_DEV(TIMER1_CLK), 285 OMAP4_GPTIMER_CLOCK_DEV(TIMER2_CLK), 286 OMAP4_GPTIMER_CLOCK_DEV(TIMER3_CLK), 287 OMAP4_GPTIMER_CLOCK_DEV(TIMER4_CLK), 288 OMAP4_GPTIMER_CLOCK_DEV(TIMER5_CLK), 289 OMAP4_GPTIMER_CLOCK_DEV(TIMER6_CLK), 290 OMAP4_GPTIMER_CLOCK_DEV(TIMER7_CLK), 291 OMAP4_GPTIMER_CLOCK_DEV(TIMER8_CLK), 292 OMAP4_GPTIMER_CLOCK_DEV(TIMER9_CLK), 293 OMAP4_GPTIMER_CLOCK_DEV(TIMER10_CLK), 294 OMAP4_GPTIMER_CLOCK_DEV(TIMER11_CLK), 295 296 /* MMC device clocks (MMC1 and MMC2 can have different input clocks) */ 297 OMAP4_HSMMC_CLOCK_DEV(MMC1_CLK), 298 OMAP4_HSMMC_CLOCK_DEV(MMC2_CLK), 299 OMAP4_GENERIC_CLOCK_DEV(MMC3_CLK), 300 OMAP4_GENERIC_CLOCK_DEV(MMC4_CLK), 301 OMAP4_GENERIC_CLOCK_DEV(MMC5_CLK), 302 303 /* USB HS (high speed TLL, EHCI and OHCI) */ 304 OMAP4_HSUSBHOST_CLOCK_DEV(USBTLL_CLK), 305 OMAP4_HSUSBHOST_CLOCK_DEV(USBHSHOST_CLK), 306 OMAP4_HSUSBHOST_CLOCK_DEV(USBFSHOST_CLK), 307 OMAP4_HSUSBHOST_CLOCK_DEV(USBP1_PHY_CLK), 308 OMAP4_HSUSBHOST_CLOCK_DEV(USBP2_PHY_CLK), 309 OMAP4_HSUSBHOST_CLOCK_DEV(USBP1_UTMI_CLK), 310 OMAP4_HSUSBHOST_CLOCK_DEV(USBP2_UTMI_CLK), 311 OMAP4_HSUSBHOST_CLOCK_DEV(USBP1_HSIC_CLK), 312 OMAP4_HSUSBHOST_CLOCK_DEV(USBP2_HSIC_CLK), 313 314 /* GPIO */ 315 OMAP4_GENERIC_CLOCK_DEV(GPIO1_CLK), 316 OMAP4_GENERIC_CLOCK_DEV(GPIO2_CLK), 317 OMAP4_GENERIC_CLOCK_DEV(GPIO3_CLK), 318 OMAP4_GENERIC_CLOCK_DEV(GPIO4_CLK), 319 OMAP4_GENERIC_CLOCK_DEV(GPIO5_CLK), 320 OMAP4_GENERIC_CLOCK_DEV(GPIO6_CLK), 321 322 /* sDMA */ 323 OMAP4_GENERIC_CLOCK_DEV(SDMA_CLK), 324 325 /* I2C */ 326 OMAP4_GENERIC_CLOCK_DEV(I2C1_CLK), 327 OMAP4_GENERIC_CLOCK_DEV(I2C2_CLK), 328 OMAP4_GENERIC_CLOCK_DEV(I2C3_CLK), 329 OMAP4_GENERIC_CLOCK_DEV(I2C4_CLK), 330 331 { INVALID_CLK_IDENT, NULL, NULL, NULL, NULL } 332 }; 333 334 /** 335 * omap4_clk_details - Stores details for all the different clocks supported 336 * 337 * Whenever an operation on a clock is being performed (activated, deactivated, 338 * etc) this array is looked up to find the correct register and bit(s) we 339 * should be modifying. 340 * 341 */ 342 struct omap4_clk_details { 343 clk_ident_t id; 344 345 uint32_t instance; 346 uint32_t clksel_reg; 347 348 int32_t src_freq; 349 350 uint32_t enable_mode; 351 }; 352 353 #define OMAP4_GENERIC_CLOCK_DETAILS(i, f, di, r, e) \ 354 { .id = (i), \ 355 .instance = (di), \ 356 .clksel_reg = (r), \ 357 .src_freq = (f), \ 358 .enable_mode = (e), \ 359 } 360 361 static struct omap4_clk_details g_omap4_clk_details[] = { 362 363 /* UART */ 364 OMAP4_GENERIC_CLOCK_DETAILS(UART1_CLK, FREQ_48MHZ, CM2_INSTANCE, 365 (L4PER_CM2_OFFSET + 0x0140), CLKCTRL_MODULEMODE_ENABLE), 366 OMAP4_GENERIC_CLOCK_DETAILS(UART2_CLK, FREQ_48MHZ, CM2_INSTANCE, 367 (L4PER_CM2_OFFSET + 0x0148), CLKCTRL_MODULEMODE_ENABLE), 368 OMAP4_GENERIC_CLOCK_DETAILS(UART3_CLK, FREQ_48MHZ, CM2_INSTANCE, 369 (L4PER_CM2_OFFSET + 0x0150), CLKCTRL_MODULEMODE_ENABLE), 370 OMAP4_GENERIC_CLOCK_DETAILS(UART4_CLK, FREQ_48MHZ, CM2_INSTANCE, 371 (L4PER_CM2_OFFSET + 0x0158), CLKCTRL_MODULEMODE_ENABLE), 372 373 /* General purpose timers */ 374 OMAP4_GENERIC_CLOCK_DETAILS(TIMER1_CLK, -1, PRM_INSTANCE, 375 (WKUP_CM_OFFSET + 0x040), CLKCTRL_MODULEMODE_ENABLE), 376 OMAP4_GENERIC_CLOCK_DETAILS(TIMER2_CLK, -1, CM2_INSTANCE, 377 (L4PER_CM2_OFFSET + 0x038), CLKCTRL_MODULEMODE_ENABLE), 378 OMAP4_GENERIC_CLOCK_DETAILS(TIMER3_CLK, -1, CM2_INSTANCE, 379 (L4PER_CM2_OFFSET + 0x040), CLKCTRL_MODULEMODE_ENABLE), 380 OMAP4_GENERIC_CLOCK_DETAILS(TIMER4_CLK, -1, CM2_INSTANCE, 381 (L4PER_CM2_OFFSET + 0x048), CLKCTRL_MODULEMODE_ENABLE), 382 OMAP4_GENERIC_CLOCK_DETAILS(TIMER5_CLK, -1, CM1_INSTANCE, 383 (ABE_CM1_OFFSET + 0x068), CLKCTRL_MODULEMODE_ENABLE), 384 OMAP4_GENERIC_CLOCK_DETAILS(TIMER6_CLK, -1, CM1_INSTANCE, 385 (ABE_CM1_OFFSET + 0x070), CLKCTRL_MODULEMODE_ENABLE), 386 OMAP4_GENERIC_CLOCK_DETAILS(TIMER7_CLK, -1, CM1_INSTANCE, 387 (ABE_CM1_OFFSET + 0x078), CLKCTRL_MODULEMODE_ENABLE), 388 OMAP4_GENERIC_CLOCK_DETAILS(TIMER8_CLK, -1, CM1_INSTANCE, 389 (ABE_CM1_OFFSET + 0x080), CLKCTRL_MODULEMODE_ENABLE), 390 OMAP4_GENERIC_CLOCK_DETAILS(TIMER9_CLK, -1, CM2_INSTANCE, 391 (L4PER_CM2_OFFSET + 0x050), CLKCTRL_MODULEMODE_ENABLE), 392 OMAP4_GENERIC_CLOCK_DETAILS(TIMER10_CLK, -1, CM2_INSTANCE, 393 (L4PER_CM2_OFFSET + 0x028), CLKCTRL_MODULEMODE_ENABLE), 394 OMAP4_GENERIC_CLOCK_DETAILS(TIMER11_CLK, -1, CM2_INSTANCE, 395 (L4PER_CM2_OFFSET + 0x030), CLKCTRL_MODULEMODE_ENABLE), 396 397 /* HSMMC (MMC1 and MMC2 can have different input clocks) */ 398 OMAP4_GENERIC_CLOCK_DETAILS(MMC1_CLK, -1, CM2_INSTANCE, 399 (L3INIT_CM2_OFFSET + 0x028), /*CLKCTRL_MODULEMODE_ENABLE*/2), 400 OMAP4_GENERIC_CLOCK_DETAILS(MMC2_CLK, -1, CM2_INSTANCE, 401 (L3INIT_CM2_OFFSET + 0x030), /*CLKCTRL_MODULEMODE_ENABLE*/2), 402 OMAP4_GENERIC_CLOCK_DETAILS(MMC3_CLK, FREQ_48MHZ, CM2_INSTANCE, 403 (L4PER_CM2_OFFSET + 0x120), /*CLKCTRL_MODULEMODE_ENABLE*/2), 404 OMAP4_GENERIC_CLOCK_DETAILS(MMC4_CLK, FREQ_48MHZ, CM2_INSTANCE, 405 (L4PER_CM2_OFFSET + 0x128), /*CLKCTRL_MODULEMODE_ENABLE*/2), 406 OMAP4_GENERIC_CLOCK_DETAILS(MMC5_CLK, FREQ_48MHZ, CM2_INSTANCE, 407 (L4PER_CM2_OFFSET + 0x160), /*CLKCTRL_MODULEMODE_ENABLE*/1), 408 409 /* GPIO modules */ 410 OMAP4_GENERIC_CLOCK_DETAILS(GPIO1_CLK, -1, PRM_INSTANCE, 411 (WKUP_CM_OFFSET + 0x038), CLKCTRL_MODULEMODE_AUTO), 412 OMAP4_GENERIC_CLOCK_DETAILS(GPIO2_CLK, -1, CM2_INSTANCE, 413 (L4PER_CM2_OFFSET + 0x060), CLKCTRL_MODULEMODE_AUTO), 414 OMAP4_GENERIC_CLOCK_DETAILS(GPIO3_CLK, -1, CM2_INSTANCE, 415 (L4PER_CM2_OFFSET + 0x068), CLKCTRL_MODULEMODE_AUTO), 416 OMAP4_GENERIC_CLOCK_DETAILS(GPIO4_CLK, -1, CM2_INSTANCE, 417 (L4PER_CM2_OFFSET + 0x070), CLKCTRL_MODULEMODE_AUTO), 418 OMAP4_GENERIC_CLOCK_DETAILS(GPIO5_CLK, -1, CM2_INSTANCE, 419 (L4PER_CM2_OFFSET + 0x078), CLKCTRL_MODULEMODE_AUTO), 420 OMAP4_GENERIC_CLOCK_DETAILS(GPIO6_CLK, -1, CM2_INSTANCE, 421 (L4PER_CM2_OFFSET + 0x080), CLKCTRL_MODULEMODE_AUTO), 422 423 /* sDMA block */ 424 OMAP4_GENERIC_CLOCK_DETAILS(SDMA_CLK, -1, CM2_INSTANCE, 425 (CORE_CM2_OFFSET + 0x300), CLKCTRL_MODULEMODE_AUTO), 426 427 /* I2C modules */ 428 OMAP4_GENERIC_CLOCK_DETAILS(I2C1_CLK, -1, CM2_INSTANCE, 429 (L4PER_CM2_OFFSET + 0x0A0), CLKCTRL_MODULEMODE_ENABLE), 430 OMAP4_GENERIC_CLOCK_DETAILS(I2C2_CLK, -1, CM2_INSTANCE, 431 (L4PER_CM2_OFFSET + 0x0A8), CLKCTRL_MODULEMODE_ENABLE), 432 OMAP4_GENERIC_CLOCK_DETAILS(I2C3_CLK, -1, CM2_INSTANCE, 433 (L4PER_CM2_OFFSET + 0x0B0), CLKCTRL_MODULEMODE_ENABLE), 434 OMAP4_GENERIC_CLOCK_DETAILS(I2C4_CLK, -1, CM2_INSTANCE, 435 (L4PER_CM2_OFFSET + 0x0B8), CLKCTRL_MODULEMODE_ENABLE), 436 437 { INVALID_CLK_IDENT, 0, 0, 0, 0 }, 438 }; 439 440 /** 441 * MAX_MODULE_ENABLE_WAIT - the number of loops to wait for the module to come 442 * alive. 443 * 444 */ 445 #define MAX_MODULE_ENABLE_WAIT 100 446 447 /** 448 * ARRAY_SIZE - Macro to return the number of elements in a static const array. 449 * 450 */ 451 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0])) 452 453 /** 454 * omap4_clk_details - writes a 32-bit value to one of the timer registers 455 * @timer: Timer device context 456 * @off: The offset of a register from the timer register address range 457 * @val: The value to write into the register 458 * 459 * 460 * RETURNS: 461 * nothing 462 */ 463 static struct omap4_clk_details* 464 omap4_clk_details(clk_ident_t id) 465 { 466 struct omap4_clk_details *walker; 467 468 for (walker = g_omap4_clk_details; walker->id != INVALID_CLK_IDENT; walker++) { 469 if (id == walker->id) 470 return (walker); 471 } 472 473 return NULL; 474 } 475 476 static struct omap4_prcm_softc * 477 omap4_prcm_get_instance_softc(int module_instance) 478 { 479 int i, maxunit; 480 devclass_t prcm_devclass; 481 device_t dev; 482 struct omap4_prcm_softc *sc; 483 484 prcm_devclass = devclass_find("omap4_prcm"); 485 maxunit = devclass_get_maxunit(prcm_devclass); 486 487 for (i = 0; i < maxunit; i++) { 488 dev = devclass_get_device(prcm_devclass, i); 489 sc = device_get_softc(dev); 490 if (sc->sc_instance == module_instance) 491 return (sc); 492 } 493 494 return (NULL); 495 } 496 497 /** 498 * omap4_clk_generic_activate - checks if a module is accessible 499 * @module: identifier for the module to check, see omap3_prcm.h for a list 500 * of possible modules. 501 * Example: OMAP3_MODULE_MMC1 502 * 503 * 504 * 505 * LOCKING: 506 * Inherits the locks from the omap_prcm driver, no internal locking. 507 * 508 * RETURNS: 509 * Returns 0 on success or a positive error code on failure. 510 */ 511 static int 512 omap4_clk_generic_activate(struct ti_clock_dev *clkdev) 513 { 514 struct omap4_prcm_softc *sc; 515 struct omap4_clk_details* clk_details; 516 struct resource* clk_mem_res; 517 uint32_t clksel; 518 unsigned int i; 519 clk_details = omap4_clk_details(clkdev->id); 520 521 if (clk_details == NULL) 522 return (ENXIO); 523 524 sc = omap4_prcm_get_instance_softc(clk_details->instance); 525 if (sc == NULL) 526 return ENXIO; 527 528 clk_mem_res = sc->sc_res; 529 530 if (clk_mem_res == NULL) 531 return (EINVAL); 532 533 /* All the 'generic' clocks have a CLKCTRL register which is more or less 534 * generic - the have at least two fielda called MODULEMODE and IDLEST. 535 */ 536 clksel = bus_read_4(clk_mem_res, clk_details->clksel_reg); 537 clksel &= ~CLKCTRL_MODULEMODE_MASK; 538 clksel |= clk_details->enable_mode; 539 bus_write_4(clk_mem_res, clk_details->clksel_reg, clksel); 540 541 /* Now poll on the IDLEST register to tell us if the module has come up. 542 * TODO: We need to take into account the parent clocks. 543 */ 544 545 /* Try MAX_MODULE_ENABLE_WAIT number of times to check if enabled */ 546 for (i = 0; i < MAX_MODULE_ENABLE_WAIT; i++) { 547 clksel = bus_read_4(clk_mem_res, clk_details->clksel_reg); 548 if ((clksel & CLKCTRL_IDLEST_MASK) == CLKCTRL_IDLEST_ENABLED) 549 break; 550 DELAY(10); 551 } 552 553 /* Check the enabled state */ 554 if ((clksel & CLKCTRL_IDLEST_MASK) != CLKCTRL_IDLEST_ENABLED) { 555 printf("Error: failed to enable module with clock %d\n", clkdev->id); 556 printf("Error: 0x%08x => 0x%08x\n", clk_details->clksel_reg, clksel); 557 return (ETIMEDOUT); 558 } 559 560 return (0); 561 } 562 563 /** 564 * omap4_clk_generic_deactivate - checks if a module is accessible 565 * @module: identifier for the module to check, see omap3_prcm.h for a list 566 * of possible modules. 567 * Example: OMAP3_MODULE_MMC1 568 * 569 * 570 * 571 * LOCKING: 572 * Inherits the locks from the omap_prcm driver, no internal locking. 573 * 574 * RETURNS: 575 * Returns 0 on success or a positive error code on failure. 576 */ 577 static int 578 omap4_clk_generic_deactivate(struct ti_clock_dev *clkdev) 579 { 580 struct omap4_prcm_softc *sc; 581 struct omap4_clk_details* clk_details; 582 struct resource* clk_mem_res; 583 uint32_t clksel; 584 585 clk_details = omap4_clk_details(clkdev->id); 586 587 if (clk_details == NULL) 588 return (ENXIO); 589 590 sc = omap4_prcm_get_instance_softc(clk_details->instance); 591 if (sc == NULL) 592 return ENXIO; 593 594 clk_mem_res = sc->sc_res; 595 596 if (clk_mem_res == NULL) 597 return (EINVAL); 598 599 /* All the 'generic' clocks have a CLKCTRL register which is more or less 600 * generic - the have at least two fielda called MODULEMODE and IDLEST. 601 */ 602 clksel = bus_read_4(clk_mem_res, clk_details->clksel_reg); 603 clksel &= ~CLKCTRL_MODULEMODE_MASK; 604 clksel |= CLKCTRL_MODULEMODE_DISABLE; 605 bus_write_4(clk_mem_res, clk_details->clksel_reg, clksel); 606 607 return (0); 608 } 609 610 /** 611 * omap4_clk_generic_set_source - checks if a module is accessible 612 * @module: identifier for the module to check, see omap3_prcm.h for a list 613 * of possible modules. 614 * Example: OMAP3_MODULE_MMC1 615 * 616 * 617 * 618 * LOCKING: 619 * Inherits the locks from the omap_prcm driver, no internal locking. 620 * 621 * RETURNS: 622 * Returns 0 on success or a positive error code on failure. 623 */ 624 static int 625 omap4_clk_generic_set_source(struct ti_clock_dev *clkdev, 626 clk_src_t clksrc) 627 { 628 629 return (0); 630 } 631 632 /** 633 * omap4_clk_generic_accessible - checks if a module is accessible 634 * @module: identifier for the module to check, see omap3_prcm.h for a list 635 * of possible modules. 636 * Example: OMAP3_MODULE_MMC1 637 * 638 * 639 * 640 * LOCKING: 641 * Inherits the locks from the omap_prcm driver, no internal locking. 642 * 643 * RETURNS: 644 * Returns 0 on success or a negative error code on failure. 645 */ 646 static int 647 omap4_clk_generic_accessible(struct ti_clock_dev *clkdev) 648 { 649 struct omap4_prcm_softc *sc; 650 struct omap4_clk_details* clk_details; 651 struct resource* clk_mem_res; 652 uint32_t clksel; 653 654 clk_details = omap4_clk_details(clkdev->id); 655 656 if (clk_details == NULL) 657 return (ENXIO); 658 659 sc = omap4_prcm_get_instance_softc(clk_details->instance); 660 if (sc == NULL) 661 return ENXIO; 662 663 clk_mem_res = sc->sc_res; 664 665 if (clk_mem_res == NULL) 666 return (EINVAL); 667 668 clksel = bus_read_4(clk_mem_res, clk_details->clksel_reg); 669 670 /* Check the enabled state */ 671 if ((clksel & CLKCTRL_IDLEST_MASK) != CLKCTRL_IDLEST_ENABLED) 672 return (0); 673 674 return (1); 675 } 676 677 /** 678 * omap4_clk_generic_get_source_freq - checks if a module is accessible 679 * @module: identifier for the module to check, see omap3_prcm.h for a list 680 * of possible modules. 681 * Example: OMAP3_MODULE_MMC1 682 * 683 * 684 * 685 * LOCKING: 686 * Inherits the locks from the omap_prcm driver, no internal locking. 687 * 688 * RETURNS: 689 * Returns 0 on success or a negative error code on failure. 690 */ 691 static int 692 omap4_clk_generic_get_source_freq(struct ti_clock_dev *clkdev, 693 unsigned int *freq 694 ) 695 { 696 struct omap4_clk_details* clk_details = omap4_clk_details(clkdev->id); 697 698 if (clk_details == NULL) 699 return (ENXIO); 700 701 /* Simply return the stored frequency */ 702 if (freq) 703 *freq = (unsigned int)clk_details->src_freq; 704 705 return (0); 706 } 707 708 709 /** 710 * omap4_clk_gptimer_set_source - checks if a module is accessible 711 * @module: identifier for the module to check, see omap3_prcm.h for a list 712 * of possible modules. 713 * Example: OMAP3_MODULE_MMC1 714 * 715 * 716 * 717 * LOCKING: 718 * Inherits the locks from the omap_prcm driver, no internal locking. 719 * 720 * RETURNS: 721 * Returns 0 on success or a negative error code on failure. 722 */ 723 static int 724 omap4_clk_gptimer_set_source(struct ti_clock_dev *clkdev, 725 clk_src_t clksrc) 726 { 727 struct omap4_prcm_softc *sc; 728 struct omap4_clk_details* clk_details; 729 struct resource* clk_mem_res; 730 731 clk_details = omap4_clk_details(clkdev->id); 732 733 if (clk_details == NULL) 734 return (ENXIO); 735 736 sc = omap4_prcm_get_instance_softc(clk_details->instance); 737 if (sc == NULL) 738 return ENXIO; 739 740 clk_mem_res = sc->sc_res; 741 742 if (clk_mem_res == NULL) 743 return (EINVAL); 744 745 /* TODO: Implement */ 746 747 return (0); 748 } 749 750 /** 751 * omap4_clk_gptimer_get_source_freq - checks if a module is accessible 752 * @module: identifier for the module to check, see omap3_prcm.h for a list 753 * of possible modules. 754 * Example: OMAP3_MODULE_MMC1 755 * 756 * 757 * 758 * LOCKING: 759 * Inherits the locks from the omap_prcm driver, no internal locking. 760 * 761 * RETURNS: 762 * Returns 0 on success or a negative error code on failure. 763 */ 764 static int 765 omap4_clk_gptimer_get_source_freq(struct ti_clock_dev *clkdev, 766 unsigned int *freq 767 ) 768 { 769 struct omap4_prcm_softc *sc; 770 struct omap4_clk_details* clk_details; 771 struct resource* clk_mem_res; 772 uint32_t clksel; 773 unsigned int src_freq; 774 775 clk_details = omap4_clk_details(clkdev->id); 776 777 if (clk_details == NULL) 778 return (ENXIO); 779 780 sc = omap4_prcm_get_instance_softc(clk_details->instance); 781 if (sc == NULL) 782 return ENXIO; 783 784 clk_mem_res = sc->sc_res; 785 786 if (clk_mem_res == NULL) 787 return (EINVAL); 788 789 /* Need to read the CLKSEL field to determine the clock source */ 790 clksel = bus_read_4(clk_mem_res, clk_details->clksel_reg); 791 if (clksel & (0x1UL << 24)) 792 src_freq = FREQ_32KHZ; 793 else 794 omap4_clk_get_sysclk_freq(NULL, &src_freq); 795 796 /* Return the frequency */ 797 if (freq) 798 *freq = src_freq; 799 800 return (0); 801 } 802 803 /** 804 * omap4_clk_hsmmc_set_source - sets the source clock (freq) 805 * @clkdev: pointer to the clockdev structure (id field will contain clock id) 806 * 807 * The MMC 1 and 2 clocks can be source from either a 64MHz or 96MHz clock. 808 * 809 * LOCKING: 810 * Inherits the locks from the omap_prcm driver, no internal locking. 811 * 812 * RETURNS: 813 * Returns 0 on success or a negative error code on failure. 814 */ 815 static int 816 omap4_clk_hsmmc_set_source(struct ti_clock_dev *clkdev, 817 clk_src_t clksrc) 818 { 819 struct omap4_prcm_softc *sc; 820 struct omap4_clk_details* clk_details; 821 struct resource* clk_mem_res; 822 uint32_t clksel; 823 824 clk_details = omap4_clk_details(clkdev->id); 825 826 if (clk_details == NULL) 827 return (ENXIO); 828 829 830 sc = omap4_prcm_get_instance_softc(clk_details->instance); 831 if (sc == NULL) 832 return ENXIO; 833 834 clk_mem_res = sc->sc_res; 835 836 if (clk_mem_res == NULL) 837 return (EINVAL); 838 839 /* For MMC modules 3, 4 & 5 you can't change the freq, it's always 48MHz */ 840 if ((clkdev->id == MMC3_CLK) || (clkdev->id == MMC4_CLK) || 841 (clkdev->id == MMC5_CLK)) { 842 if (clksrc != F48MHZ_CLK) 843 return (EINVAL); 844 return 0; 845 } 846 847 848 clksel = bus_read_4(clk_mem_res, clk_details->clksel_reg); 849 850 /* Bit 24 is set if 96MHz clock or cleared for 64MHz clock */ 851 if (clksrc == F64MHZ_CLK) 852 clksel &= ~(0x1UL << 24); 853 else if (clksrc == F96MHZ_CLK) 854 clksel |= (0x1UL << 24); 855 else 856 return (EINVAL); 857 858 bus_write_4(clk_mem_res, clk_details->clksel_reg, clksel); 859 860 return (0); 861 } 862 863 /** 864 * omap4_clk_hsmmc_get_source_freq - checks if a module is accessible 865 * @clkdev: pointer to the clockdev structure (id field will contain clock id) 866 * 867 * 868 * 869 * LOCKING: 870 * Inherits the locks from the omap_prcm driver, no internal locking. 871 * 872 * RETURNS: 873 * Returns 0 on success or a negative error code on failure. 874 */ 875 static int 876 omap4_clk_hsmmc_get_source_freq(struct ti_clock_dev *clkdev, 877 unsigned int *freq 878 ) 879 { 880 struct omap4_prcm_softc *sc; 881 struct omap4_clk_details* clk_details; 882 struct resource* clk_mem_res; 883 uint32_t clksel; 884 unsigned int src_freq; 885 886 clk_details = omap4_clk_details(clkdev->id); 887 888 if (clk_details == NULL) 889 return (ENXIO); 890 891 sc = omap4_prcm_get_instance_softc(clk_details->instance); 892 if (sc == NULL) 893 return ENXIO; 894 895 clk_mem_res = sc->sc_res; 896 897 if (clk_mem_res == NULL) 898 return (EINVAL); 899 900 switch (clkdev->id) { 901 case MMC1_CLK: 902 case MMC2_CLK: 903 /* Need to read the CLKSEL field to determine the clock source */ 904 clksel = bus_read_4(clk_mem_res, clk_details->clksel_reg); 905 if (clksel & (0x1UL << 24)) 906 src_freq = FREQ_96MHZ; 907 else 908 src_freq = FREQ_64MHZ; 909 break; 910 case MMC3_CLK: 911 case MMC4_CLK: 912 case MMC5_CLK: 913 src_freq = FREQ_48MHZ; 914 break; 915 default: 916 return (EINVAL); 917 } 918 919 /* Return the frequency */ 920 if (freq) 921 *freq = src_freq; 922 923 return (0); 924 } 925 926 /** 927 * omap4_clk_get_sysclk_freq - gets the sysclk frequency 928 * @sc: pointer to the clk module/device context 929 * 930 * Read the clocking information from the power-control/boot-strap registers, 931 * and stored in two global variables. 932 * 933 * RETURNS: 934 * nothing, values are saved in global variables 935 */ 936 static int 937 omap4_clk_get_sysclk_freq(struct ti_clock_dev *clkdev, 938 unsigned int *freq) 939 { 940 uint32_t clksel; 941 uint32_t sysclk; 942 struct omap4_prcm_softc *sc; 943 944 sc = omap4_prcm_get_instance_softc(PRM_INSTANCE); 945 if (sc == NULL) 946 return ENXIO; 947 948 /* Read the input clock freq from the configuration register (CM_SYS_CLKSEL) */ 949 clksel = bus_read_4(sc->sc_res, CM_SYS_CLKSEL_OFFSET); 950 switch (clksel & 0x7) { 951 case 0x1: 952 /* 12Mhz */ 953 sysclk = 12000000; 954 break; 955 case 0x3: 956 /* 16.8Mhz */ 957 sysclk = 16800000; 958 break; 959 case 0x4: 960 /* 19.2Mhz */ 961 sysclk = 19200000; 962 break; 963 case 0x5: 964 /* 26Mhz */ 965 sysclk = 26000000; 966 break; 967 case 0x7: 968 /* 38.4Mhz */ 969 sysclk = 38400000; 970 break; 971 default: 972 panic("%s: Invalid clock freq", __func__); 973 } 974 975 /* Return the value */ 976 if (freq) 977 *freq = sysclk; 978 979 return (0); 980 } 981 982 /** 983 * omap4_clk_get_arm_fclk_freq - gets the MPU clock frequency 984 * @clkdev: ignored 985 * @freq: pointer which upon return will contain the freq in hz 986 * @mem_res: array of allocated memory resources 987 * 988 * Reads the frequency setting information registers and returns the value 989 * in the freq variable. 990 * 991 * RETURNS: 992 * returns 0 on success, a positive error code on failure. 993 */ 994 static int 995 omap4_clk_get_arm_fclk_freq(struct ti_clock_dev *clkdev, 996 unsigned int *freq) 997 { 998 uint32_t clksel; 999 uint32_t pll_mult, pll_div; 1000 uint32_t mpuclk, sysclk; 1001 struct omap4_prcm_softc *sc; 1002 1003 sc = omap4_prcm_get_instance_softc(CM1_INSTANCE); 1004 if (sc == NULL) 1005 return ENXIO; 1006 1007 /* Read the clksel register which contains the DPLL multiple and divide 1008 * values. These are applied to the sysclk. 1009 */ 1010 clksel = bus_read_4(sc->sc_res, CM_CLKSEL_DPLL_MPU); 1011 1012 pll_mult = ((clksel >> 8) & 0x7ff); 1013 pll_div = (clksel & 0x7f) + 1; 1014 1015 1016 /* Get the system clock freq */ 1017 omap4_clk_get_sysclk_freq(NULL, &sysclk); 1018 1019 1020 /* Calculate the MPU freq */ 1021 mpuclk = ((uint64_t)sysclk * pll_mult) / pll_div; 1022 1023 /* Return the value */ 1024 if (freq) 1025 *freq = mpuclk; 1026 1027 return (0); 1028 } 1029 1030 /** 1031 * omap4_clk_hsusbhost_activate - activates the USB clocks for the given module 1032 * @clkdev: pointer to the clock device structure. 1033 * @mem_res: array of memory resources allocated by the top level PRCM driver. 1034 * 1035 * The USB clocking setup seems to be a bit more tricky than the other modules, 1036 * to start with the clocking diagram for the HS host module shows 13 different 1037 * clocks. So to try and make it easier to follow the clocking activation 1038 * and deactivation is handled in its own set of callbacks. 1039 * 1040 * LOCKING: 1041 * Inherits the locks from the omap_prcm driver, no internal locking. 1042 * 1043 * RETURNS: 1044 * Returns 0 on success or a positive error code on failure. 1045 */ 1046 1047 struct dpll_param { 1048 unsigned int m; 1049 unsigned int n; 1050 unsigned int m2; 1051 unsigned int m3; 1052 unsigned int m4; 1053 unsigned int m5; 1054 unsigned int m6; 1055 unsigned int m7; 1056 }; 1057 /* USB parameters */ 1058 struct dpll_param usb_dpll_param[7] = { 1059 /* 12M values */ 1060 {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, 1061 /* 13M values */ 1062 {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, 1063 /* 16.8M values */ 1064 {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, 1065 /* 19.2M values */ 1066 {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, 1067 /* 26M values */ 1068 {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, 1069 /* 27M values */ 1070 {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, 1071 /* 38.4M values */ 1072 #ifdef CONFIG_OMAP4_SDC 1073 {0x32, 0x1, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0}, 1074 #else 1075 {0x32, 0x1, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0}, 1076 #endif 1077 }; 1078 static int 1079 omap4_clk_hsusbhost_activate(struct ti_clock_dev *clkdev) 1080 { 1081 struct omap4_prcm_softc *sc; 1082 struct resource* clk_mem_res; 1083 uint32_t clksel_reg_off; 1084 uint32_t clksel; 1085 unsigned int i; 1086 1087 sc = omap4_prcm_get_instance_softc(CM2_INSTANCE); 1088 if (sc == NULL) 1089 return ENXIO; 1090 1091 switch (clkdev->id) { 1092 case USBTLL_CLK: 1093 /* For the USBTLL module we need to enable the following clocks: 1094 * - INIT_L4_ICLK (will be enabled by bootloader) 1095 * - TLL_CH0_FCLK 1096 * - TLL_CH1_FCLK 1097 */ 1098 1099 /* We need the CM_L3INIT_HSUSBTLL_CLKCTRL register in CM2 register set */ 1100 clk_mem_res = sc->sc_res; 1101 clksel_reg_off = L3INIT_CM2_OFFSET + 0x68; 1102 1103 /* Enable the module and also enable the optional func clocks for 1104 * channels 0 & 1 (is this needed ?) 1105 */ 1106 clksel = bus_read_4(clk_mem_res, clksel_reg_off); 1107 clksel &= ~CLKCTRL_MODULEMODE_MASK; 1108 clksel |= CLKCTRL_MODULEMODE_ENABLE; 1109 1110 clksel |= (0x1 << 8); /* USB-HOST optional clock: USB_CH0_CLK */ 1111 clksel |= (0x1 << 9); /* USB-HOST optional clock: USB_CH1_CLK */ 1112 break; 1113 1114 case USBHSHOST_CLK: 1115 case USBP1_PHY_CLK: 1116 case USBP2_PHY_CLK: 1117 case USBP1_UTMI_CLK: 1118 case USBP2_UTMI_CLK: 1119 case USBP1_HSIC_CLK: 1120 case USBP2_HSIC_CLK: 1121 /* For the USB HS HOST module we need to enable the following clocks: 1122 * - INIT_L4_ICLK (will be enabled by bootloader) 1123 * - INIT_L3_ICLK (will be enabled by bootloader) 1124 * - INIT_48MC_FCLK 1125 * - UTMI_ROOT_GFCLK (UTMI only, create a new clock for that ?) 1126 * - UTMI_P1_FCLK (UTMI only, create a new clock for that ?) 1127 * - UTMI_P2_FCLK (UTMI only, create a new clock for that ?) 1128 * - HSIC_P1_60 (HSIC only, create a new clock for that ?) 1129 * - HSIC_P1_480 (HSIC only, create a new clock for that ?) 1130 * - HSIC_P2_60 (HSIC only, create a new clock for that ?) 1131 * - HSIC_P2_480 (HSIC only, create a new clock for that ?) 1132 */ 1133 1134 /* We need the CM_L3INIT_HSUSBHOST_CLKCTRL register in CM2 register set */ 1135 clk_mem_res = sc->sc_res; 1136 clksel_reg_off = L3INIT_CM2_OFFSET + 0x58; 1137 clksel = bus_read_4(clk_mem_res, clksel_reg_off); 1138 /* Enable the module and also enable the optional func clocks */ 1139 if (clkdev->id == USBHSHOST_CLK) { 1140 clksel &= ~CLKCTRL_MODULEMODE_MASK; 1141 clksel |= /*CLKCTRL_MODULEMODE_ENABLE*/2; 1142 1143 clksel |= (0x1 << 15); /* USB-HOST clock control: FUNC48MCLK */ 1144 } 1145 1146 else if (clkdev->id == USBP1_UTMI_CLK) 1147 clksel |= (0x1 << 8); /* UTMI_P1_CLK */ 1148 else if (clkdev->id == USBP2_UTMI_CLK) 1149 clksel |= (0x1 << 9); /* UTMI_P2_CLK */ 1150 1151 else if (clkdev->id == USBP1_HSIC_CLK) 1152 clksel |= (0x5 << 11); /* HSIC60M_P1_CLK + HSIC480M_P1_CLK */ 1153 else if (clkdev->id == USBP2_HSIC_CLK) 1154 clksel |= (0x5 << 12); /* HSIC60M_P2_CLK + HSIC480M_P2_CLK */ 1155 1156 break; 1157 1158 default: 1159 return (EINVAL); 1160 } 1161 1162 bus_write_4(clk_mem_res, clksel_reg_off, clksel); 1163 1164 /* Try MAX_MODULE_ENABLE_WAIT number of times to check if enabled */ 1165 for (i = 0; i < MAX_MODULE_ENABLE_WAIT; i++) { 1166 clksel = bus_read_4(clk_mem_res, clksel_reg_off); 1167 if ((clksel & CLKCTRL_IDLEST_MASK) == CLKCTRL_IDLEST_ENABLED) 1168 break; 1169 } 1170 1171 /* Check the enabled state */ 1172 if ((clksel & CLKCTRL_IDLEST_MASK) != CLKCTRL_IDLEST_ENABLED) { 1173 printf("Error: HERE failed to enable module with clock %d\n", clkdev->id); 1174 printf("Error: 0x%08x => 0x%08x\n", clksel_reg_off, clksel); 1175 return (ETIMEDOUT); 1176 } 1177 1178 return (0); 1179 } 1180 1181 /** 1182 * omap4_clk_generic_deactivate - checks if a module is accessible 1183 * @clkdev: pointer to the clock device structure. 1184 * @mem_res: array of memory resources allocated by the top level PRCM driver. 1185 * 1186 * 1187 * 1188 * LOCKING: 1189 * Inherits the locks from the omap_prcm driver, no internal locking. 1190 * 1191 * RETURNS: 1192 * Returns 0 on success or a positive error code on failure. 1193 */ 1194 static int 1195 omap4_clk_hsusbhost_deactivate(struct ti_clock_dev *clkdev) 1196 { 1197 struct omap4_prcm_softc *sc; 1198 struct resource* clk_mem_res; 1199 uint32_t clksel_reg_off; 1200 uint32_t clksel; 1201 1202 sc = omap4_prcm_get_instance_softc(CM2_INSTANCE); 1203 if (sc == NULL) 1204 return ENXIO; 1205 1206 switch (clkdev->id) { 1207 case USBTLL_CLK: 1208 /* We need the CM_L3INIT_HSUSBTLL_CLKCTRL register in CM2 register set */ 1209 clk_mem_res = sc->sc_res; 1210 clksel_reg_off = L3INIT_CM2_OFFSET + 0x68; 1211 1212 clksel = bus_read_4(clk_mem_res, clksel_reg_off); 1213 clksel &= ~CLKCTRL_MODULEMODE_MASK; 1214 clksel |= CLKCTRL_MODULEMODE_DISABLE; 1215 break; 1216 1217 case USBHSHOST_CLK: 1218 case USBP1_PHY_CLK: 1219 case USBP2_PHY_CLK: 1220 case USBP1_UTMI_CLK: 1221 case USBP2_UTMI_CLK: 1222 case USBP1_HSIC_CLK: 1223 case USBP2_HSIC_CLK: 1224 /* For the USB HS HOST module we need to enable the following clocks: 1225 * - INIT_L4_ICLK (will be enabled by bootloader) 1226 * - INIT_L3_ICLK (will be enabled by bootloader) 1227 * - INIT_48MC_FCLK 1228 * - UTMI_ROOT_GFCLK (UTMI only, create a new clock for that ?) 1229 * - UTMI_P1_FCLK (UTMI only, create a new clock for that ?) 1230 * - UTMI_P2_FCLK (UTMI only, create a new clock for that ?) 1231 * - HSIC_P1_60 (HSIC only, create a new clock for that ?) 1232 * - HSIC_P1_480 (HSIC only, create a new clock for that ?) 1233 * - HSIC_P2_60 (HSIC only, create a new clock for that ?) 1234 * - HSIC_P2_480 (HSIC only, create a new clock for that ?) 1235 */ 1236 1237 /* We need the CM_L3INIT_HSUSBHOST_CLKCTRL register in CM2 register set */ 1238 clk_mem_res = sc->sc_res; 1239 clksel_reg_off = L3INIT_CM2_OFFSET + 0x58; 1240 clksel = bus_read_4(clk_mem_res, clksel_reg_off); 1241 1242 /* Enable the module and also enable the optional func clocks */ 1243 if (clkdev->id == USBHSHOST_CLK) { 1244 clksel &= ~CLKCTRL_MODULEMODE_MASK; 1245 clksel |= CLKCTRL_MODULEMODE_DISABLE; 1246 1247 clksel &= ~(0x1 << 15); /* USB-HOST clock control: FUNC48MCLK */ 1248 } 1249 1250 else if (clkdev->id == USBP1_UTMI_CLK) 1251 clksel &= ~(0x1 << 8); /* UTMI_P1_CLK */ 1252 else if (clkdev->id == USBP2_UTMI_CLK) 1253 clksel &= ~(0x1 << 9); /* UTMI_P2_CLK */ 1254 1255 else if (clkdev->id == USBP1_HSIC_CLK) 1256 clksel &= ~(0x5 << 11); /* HSIC60M_P1_CLK + HSIC480M_P1_CLK */ 1257 else if (clkdev->id == USBP2_HSIC_CLK) 1258 clksel &= ~(0x5 << 12); /* HSIC60M_P2_CLK + HSIC480M_P2_CLK */ 1259 1260 break; 1261 1262 default: 1263 return (EINVAL); 1264 } 1265 1266 bus_write_4(clk_mem_res, clksel_reg_off, clksel); 1267 1268 return (0); 1269 } 1270 1271 /** 1272 * omap4_clk_hsusbhost_accessible - checks if a module is accessible 1273 * @clkdev: pointer to the clock device structure. 1274 * @mem_res: array of memory resources allocated by the top level PRCM driver. 1275 * 1276 * 1277 * 1278 * LOCKING: 1279 * Inherits the locks from the omap_prcm driver, no internal locking. 1280 * 1281 * RETURNS: 1282 * Returns 0 if module is not enable, 1 if module is enabled or a negative 1283 * error code on failure. 1284 */ 1285 static int 1286 omap4_clk_hsusbhost_accessible(struct ti_clock_dev *clkdev) 1287 { 1288 struct omap4_prcm_softc *sc; 1289 struct resource* clk_mem_res; 1290 uint32_t clksel_reg_off; 1291 uint32_t clksel; 1292 1293 sc = omap4_prcm_get_instance_softc(CM2_INSTANCE); 1294 if (sc == NULL) 1295 return ENXIO; 1296 1297 if (clkdev->id == USBTLL_CLK) { 1298 /* We need the CM_L3INIT_HSUSBTLL_CLKCTRL register in CM2 register set */ 1299 clk_mem_res = sc->sc_res; 1300 clksel_reg_off = L3INIT_CM2_OFFSET + 0x68; 1301 } 1302 else if (clkdev->id == USBHSHOST_CLK) { 1303 /* We need the CM_L3INIT_HSUSBHOST_CLKCTRL register in CM2 register set */ 1304 clk_mem_res = sc->sc_res; 1305 clksel_reg_off = L3INIT_CM2_OFFSET + 0x58; 1306 } 1307 else { 1308 return (EINVAL); 1309 } 1310 1311 clksel = bus_read_4(clk_mem_res, clksel_reg_off); 1312 1313 /* Check the enabled state */ 1314 if ((clksel & CLKCTRL_IDLEST_MASK) != CLKCTRL_IDLEST_ENABLED) 1315 return (0); 1316 1317 return (1); 1318 } 1319 1320 /** 1321 * omap4_clk_hsusbhost_set_source - sets the source clocks 1322 * @clkdev: pointer to the clock device structure. 1323 * @clksrc: the clock source ID for the given clock. 1324 * @mem_res: array of memory resources allocated by the top level PRCM driver. 1325 * 1326 * 1327 * 1328 * LOCKING: 1329 * Inherits the locks from the omap_prcm driver, no internal locking. 1330 * 1331 * RETURNS: 1332 * Returns 0 if successful otherwise a negative error code on failure. 1333 */ 1334 static int 1335 omap4_clk_hsusbhost_set_source(struct ti_clock_dev *clkdev, 1336 clk_src_t clksrc) 1337 { 1338 struct omap4_prcm_softc *sc; 1339 struct resource* clk_mem_res; 1340 uint32_t clksel_reg_off; 1341 uint32_t clksel; 1342 unsigned int bit; 1343 1344 sc = omap4_prcm_get_instance_softc(CM2_INSTANCE); 1345 if (sc == NULL) 1346 return ENXIO; 1347 1348 if (clkdev->id == USBP1_PHY_CLK) 1349 bit = 24; 1350 else if (clkdev->id != USBP2_PHY_CLK) 1351 bit = 25; 1352 else 1353 return (EINVAL); 1354 1355 /* We need the CM_L3INIT_HSUSBHOST_CLKCTRL register in CM2 register set */ 1356 clk_mem_res = sc->sc_res; 1357 clksel_reg_off = L3INIT_CM2_OFFSET + 0x58; 1358 clksel = bus_read_4(clk_mem_res, clksel_reg_off); 1359 1360 /* Set the clock source to either external or internal */ 1361 if (clksrc == EXT_CLK) 1362 clksel |= (0x1 << bit); 1363 else 1364 clksel &= ~(0x1 << bit); 1365 1366 bus_write_4(clk_mem_res, clksel_reg_off, clksel); 1367 1368 return (0); 1369 } 1370 1371 #define PRM_RSTCTRL 0x1b00 1372 #define PRM_RSTCTRL_RESET 0x2 1373 1374 static void 1375 omap4_prcm_reset(void) 1376 { 1377 struct omap4_prcm_softc *sc; 1378 1379 sc = omap4_prcm_get_instance_softc(PRM_INSTANCE); 1380 if (sc == NULL) 1381 return; 1382 1383 bus_write_4(sc->sc_res, PRM_RSTCTRL, 1384 bus_read_4(sc->sc_res, PRM_RSTCTRL) | PRM_RSTCTRL_RESET); 1385 bus_read_4(sc->sc_res, PRM_RSTCTRL); 1386 } 1387 1388 /** 1389 * omap4_prcm_probe - probe function for the driver 1390 * @dev: prcm device handle 1391 * 1392 * Simply sets the name of the driver module. 1393 * 1394 * LOCKING: 1395 * None 1396 * 1397 * RETURNS: 1398 * Always returns 0 1399 */ 1400 static int 1401 omap4_prcm_probe(device_t dev) 1402 { 1403 const struct ofw_compat_data *ocd; 1404 1405 if (!ofw_bus_status_okay(dev)) 1406 return (ENXIO); 1407 1408 ocd = ofw_bus_search_compatible(dev, compat_data); 1409 if ((int)ocd->ocd_data == 0) 1410 return (ENXIO); 1411 1412 switch ((int)ocd->ocd_data) { 1413 case PRM_INSTANCE: 1414 device_set_desc(dev, "TI OMAP Power, Reset and Clock Management (PRM)"); 1415 break; 1416 case CM1_INSTANCE: 1417 device_set_desc(dev, "TI OMAP Power, Reset and Clock Management (C1)"); 1418 break; 1419 case CM2_INSTANCE: 1420 device_set_desc(dev, "TI OMAP Power, Reset and Clock Management (C2)"); 1421 break; 1422 default: 1423 device_printf(dev, "unknown instance type: %d\n", (int)ocd->ocd_data); 1424 return (ENXIO); 1425 } 1426 1427 return (BUS_PROBE_DEFAULT); 1428 } 1429 1430 /** 1431 * omap_prcm_attach - attach function for the driver 1432 * @dev: prcm device handle 1433 * 1434 * Allocates and sets up the driver context, this simply entails creating a 1435 * bus mappings for the PRCM register set. 1436 * 1437 * LOCKING: 1438 * None 1439 * 1440 * RETURNS: 1441 * Always returns 0 1442 */ 1443 1444 extern uint32_t platform_arm_tmr_freq; 1445 1446 static int 1447 omap4_prcm_attach(device_t dev) 1448 { 1449 struct omap4_prcm_softc *sc; 1450 const struct ofw_compat_data *ocd; 1451 1452 sc = device_get_softc(dev); 1453 ocd = ofw_bus_search_compatible(dev, compat_data); 1454 sc->sc_instance = (int)ocd->ocd_data; 1455 1456 sc->sc_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->sc_rid, 1457 RF_ACTIVE); 1458 if (sc->sc_res == NULL) { 1459 device_printf(dev, "could not allocate resources\n"); 1460 return (ENXIO); 1461 } 1462 1463 ti_cpu_reset = omap4_prcm_reset; 1464 1465 return (0); 1466 } 1467 1468 static void 1469 omap4_prcm_new_pass(device_t dev) 1470 { 1471 struct omap4_prcm_softc *sc = device_get_softc(dev); 1472 unsigned int freq; 1473 1474 if (sc->attach_done || 1475 bus_current_pass < (BUS_PASS_TIMER + BUS_PASS_ORDER_EARLY)) { 1476 bus_generic_new_pass(dev); 1477 return; 1478 } 1479 sc->attach_done = 1; 1480 1481 /* 1482 * In order to determine ARM frequency we need both RPM and CM1 1483 * instances up and running. So wait until all CRM devices are 1484 * initialized. Should be replaced with proper clock framework 1485 */ 1486 if (device_get_unit(dev) == 2) { 1487 omap4_clk_get_arm_fclk_freq(NULL, &freq); 1488 arm_tmr_change_frequency(freq / 2); 1489 } 1490 1491 return; 1492 } 1493 1494 static device_method_t omap4_prcm_methods[] = { 1495 DEVMETHOD(device_probe, omap4_prcm_probe), 1496 DEVMETHOD(device_attach, omap4_prcm_attach), 1497 1498 /* Bus interface */ 1499 DEVMETHOD(bus_new_pass, omap4_prcm_new_pass), 1500 1501 {0, 0}, 1502 }; 1503 1504 static driver_t omap4_prcm_driver = { 1505 "omap4_prcm", 1506 omap4_prcm_methods, 1507 sizeof(struct omap4_prcm_softc), 1508 }; 1509 1510 static devclass_t omap4_prcm_devclass; 1511 1512 EARLY_DRIVER_MODULE(omap4_prcm, simplebus, omap4_prcm_driver, 1513 omap4_prcm_devclass, 0, 0, BUS_PASS_BUS + BUS_PASS_ORDER_MIDDLE); 1514 MODULE_VERSION(omap4_prcm, 1); 1515