1 /* 2 * OMAP clocks. 3 * 4 * Copyright (C) 2006-2008 Andrzej Zaborowski <balrog@zabor.org> 5 * 6 * Clocks data comes in part from arch/arm/mach-omap1/clock.h in Linux. 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation; either version 2 of 11 * the License, or (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License along 19 * with this program; if not, see <http://www.gnu.org/licenses/>. 20 */ 21 #include "hw/hw.h" 22 #include "hw/arm/omap.h" 23 24 struct clk { 25 const char *name; 26 const char *alias; 27 struct clk *parent; 28 struct clk *child1; 29 struct clk *sibling; 30 #define ALWAYS_ENABLED (1 << 0) 31 #define CLOCK_IN_OMAP310 (1 << 10) 32 #define CLOCK_IN_OMAP730 (1 << 11) 33 #define CLOCK_IN_OMAP1510 (1 << 12) 34 #define CLOCK_IN_OMAP16XX (1 << 13) 35 #define CLOCK_IN_OMAP242X (1 << 14) 36 #define CLOCK_IN_OMAP243X (1 << 15) 37 #define CLOCK_IN_OMAP343X (1 << 16) 38 uint32_t flags; 39 int id; 40 41 int running; /* Is currently ticking */ 42 int enabled; /* Is enabled, regardless of its input clk */ 43 unsigned long rate; /* Current rate (if .running) */ 44 unsigned int divisor; /* Rate relative to input (if .enabled) */ 45 unsigned int multiplier; /* Rate relative to input (if .enabled) */ 46 qemu_irq users[16]; /* Who to notify on change */ 47 int usecount; /* Automatically idle when unused */ 48 }; 49 50 static struct clk xtal_osc12m = { 51 .name = "xtal_osc_12m", 52 .rate = 12000000, 53 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310, 54 }; 55 56 static struct clk xtal_osc32k = { 57 .name = "xtal_osc_32k", 58 .rate = 32768, 59 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 | 60 CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 61 }; 62 63 static struct clk ck_ref = { 64 .name = "ck_ref", 65 .alias = "clkin", 66 .parent = &xtal_osc12m, 67 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 | 68 ALWAYS_ENABLED, 69 }; 70 71 /* If a dpll is disabled it becomes a bypass, child clocks don't stop */ 72 static struct clk dpll1 = { 73 .name = "dpll1", 74 .parent = &ck_ref, 75 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 | 76 ALWAYS_ENABLED, 77 }; 78 79 static struct clk dpll2 = { 80 .name = "dpll2", 81 .parent = &ck_ref, 82 .flags = CLOCK_IN_OMAP310 | ALWAYS_ENABLED, 83 }; 84 85 static struct clk dpll3 = { 86 .name = "dpll3", 87 .parent = &ck_ref, 88 .flags = CLOCK_IN_OMAP310 | ALWAYS_ENABLED, 89 }; 90 91 static struct clk dpll4 = { 92 .name = "dpll4", 93 .parent = &ck_ref, 94 .multiplier = 4, 95 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310, 96 }; 97 98 static struct clk apll = { 99 .name = "apll", 100 .parent = &ck_ref, 101 .multiplier = 48, 102 .divisor = 12, 103 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310, 104 }; 105 106 static struct clk ck_48m = { 107 .name = "ck_48m", 108 .parent = &dpll4, /* either dpll4 or apll */ 109 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310, 110 }; 111 112 static struct clk ck_dpll1out = { 113 .name = "ck_dpll1out", 114 .parent = &dpll1, 115 .flags = CLOCK_IN_OMAP16XX, 116 }; 117 118 static struct clk sossi_ck = { 119 .name = "ck_sossi", 120 .parent = &ck_dpll1out, 121 .flags = CLOCK_IN_OMAP16XX, 122 }; 123 124 static struct clk clkm1 = { 125 .name = "clkm1", 126 .alias = "ck_gen1", 127 .parent = &dpll1, 128 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 | 129 ALWAYS_ENABLED, 130 }; 131 132 static struct clk clkm2 = { 133 .name = "clkm2", 134 .alias = "ck_gen2", 135 .parent = &dpll1, 136 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 | 137 ALWAYS_ENABLED, 138 }; 139 140 static struct clk clkm3 = { 141 .name = "clkm3", 142 .alias = "ck_gen3", 143 .parent = &dpll1, /* either dpll1 or ck_ref */ 144 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 | 145 ALWAYS_ENABLED, 146 }; 147 148 static struct clk arm_ck = { 149 .name = "arm_ck", 150 .alias = "mpu_ck", 151 .parent = &clkm1, 152 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 | 153 ALWAYS_ENABLED, 154 }; 155 156 static struct clk armper_ck = { 157 .name = "armper_ck", 158 .alias = "mpuper_ck", 159 .parent = &clkm1, 160 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310, 161 }; 162 163 static struct clk arm_gpio_ck = { 164 .name = "arm_gpio_ck", 165 .alias = "mpu_gpio_ck", 166 .parent = &clkm1, 167 .divisor = 1, 168 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310, 169 }; 170 171 static struct clk armxor_ck = { 172 .name = "armxor_ck", 173 .alias = "mpuxor_ck", 174 .parent = &ck_ref, 175 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310, 176 }; 177 178 static struct clk armtim_ck = { 179 .name = "armtim_ck", 180 .alias = "mputim_ck", 181 .parent = &ck_ref, /* either CLKIN or DPLL1 */ 182 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310, 183 }; 184 185 static struct clk armwdt_ck = { 186 .name = "armwdt_ck", 187 .alias = "mpuwd_ck", 188 .parent = &clkm1, 189 .divisor = 14, 190 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 | 191 ALWAYS_ENABLED, 192 }; 193 194 static struct clk arminth_ck16xx = { 195 .name = "arminth_ck", 196 .parent = &arm_ck, 197 .flags = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED, 198 /* Note: On 16xx the frequency can be divided by 2 by programming 199 * ARM_CKCTL:ARM_INTHCK_SEL(14) to 1 200 * 201 * 1510 version is in TC clocks. 202 */ 203 }; 204 205 static struct clk dsp_ck = { 206 .name = "dsp_ck", 207 .parent = &clkm2, 208 .flags = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX, 209 }; 210 211 static struct clk dspmmu_ck = { 212 .name = "dspmmu_ck", 213 .parent = &clkm2, 214 .flags = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | 215 ALWAYS_ENABLED, 216 }; 217 218 static struct clk dspper_ck = { 219 .name = "dspper_ck", 220 .parent = &clkm2, 221 .flags = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX, 222 }; 223 224 static struct clk dspxor_ck = { 225 .name = "dspxor_ck", 226 .parent = &ck_ref, 227 .flags = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX, 228 }; 229 230 static struct clk dsptim_ck = { 231 .name = "dsptim_ck", 232 .parent = &ck_ref, 233 .flags = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX, 234 }; 235 236 static struct clk tc_ck = { 237 .name = "tc_ck", 238 .parent = &clkm3, 239 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | 240 CLOCK_IN_OMAP730 | CLOCK_IN_OMAP310 | 241 ALWAYS_ENABLED, 242 }; 243 244 static struct clk arminth_ck15xx = { 245 .name = "arminth_ck", 246 .parent = &tc_ck, 247 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310 | ALWAYS_ENABLED, 248 /* Note: On 1510 the frequency follows TC_CK 249 * 250 * 16xx version is in MPU clocks. 251 */ 252 }; 253 254 static struct clk tipb_ck = { 255 /* No-idle controlled by "tc_ck" */ 256 .name = "tipb_ck", 257 .parent = &tc_ck, 258 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310 | ALWAYS_ENABLED, 259 }; 260 261 static struct clk l3_ocpi_ck = { 262 /* No-idle controlled by "tc_ck" */ 263 .name = "l3_ocpi_ck", 264 .parent = &tc_ck, 265 .flags = CLOCK_IN_OMAP16XX, 266 }; 267 268 static struct clk tc1_ck = { 269 .name = "tc1_ck", 270 .parent = &tc_ck, 271 .flags = CLOCK_IN_OMAP16XX, 272 }; 273 274 static struct clk tc2_ck = { 275 .name = "tc2_ck", 276 .parent = &tc_ck, 277 .flags = CLOCK_IN_OMAP16XX, 278 }; 279 280 static struct clk dma_ck = { 281 /* No-idle controlled by "tc_ck" */ 282 .name = "dma_ck", 283 .parent = &tc_ck, 284 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 | 285 ALWAYS_ENABLED, 286 }; 287 288 static struct clk dma_lcdfree_ck = { 289 .name = "dma_lcdfree_ck", 290 .parent = &tc_ck, 291 .flags = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED, 292 }; 293 294 static struct clk api_ck = { 295 .name = "api_ck", 296 .alias = "mpui_ck", 297 .parent = &tc_ck, 298 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310, 299 }; 300 301 static struct clk lb_ck = { 302 .name = "lb_ck", 303 .parent = &tc_ck, 304 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310, 305 }; 306 307 static struct clk lbfree_ck = { 308 .name = "lbfree_ck", 309 .parent = &tc_ck, 310 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310, 311 }; 312 313 static struct clk hsab_ck = { 314 .name = "hsab_ck", 315 .parent = &tc_ck, 316 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310, 317 }; 318 319 static struct clk rhea1_ck = { 320 .name = "rhea1_ck", 321 .parent = &tc_ck, 322 .flags = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED, 323 }; 324 325 static struct clk rhea2_ck = { 326 .name = "rhea2_ck", 327 .parent = &tc_ck, 328 .flags = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED, 329 }; 330 331 static struct clk lcd_ck_16xx = { 332 .name = "lcd_ck", 333 .parent = &clkm3, 334 .flags = CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP730, 335 }; 336 337 static struct clk lcd_ck_1510 = { 338 .name = "lcd_ck", 339 .parent = &clkm3, 340 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310, 341 }; 342 343 static struct clk uart1_1510 = { 344 .name = "uart1_ck", 345 /* Direct from ULPD, no real parent */ 346 .parent = &armper_ck, /* either armper_ck or dpll4 */ 347 .rate = 12000000, 348 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310 | ALWAYS_ENABLED, 349 }; 350 351 static struct clk uart1_16xx = { 352 .name = "uart1_ck", 353 /* Direct from ULPD, no real parent */ 354 .parent = &armper_ck, 355 .rate = 48000000, 356 .flags = CLOCK_IN_OMAP16XX, 357 }; 358 359 static struct clk uart2_ck = { 360 .name = "uart2_ck", 361 /* Direct from ULPD, no real parent */ 362 .parent = &armper_ck, /* either armper_ck or dpll4 */ 363 .rate = 12000000, 364 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 | 365 ALWAYS_ENABLED, 366 }; 367 368 static struct clk uart3_1510 = { 369 .name = "uart3_ck", 370 /* Direct from ULPD, no real parent */ 371 .parent = &armper_ck, /* either armper_ck or dpll4 */ 372 .rate = 12000000, 373 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310 | ALWAYS_ENABLED, 374 }; 375 376 static struct clk uart3_16xx = { 377 .name = "uart3_ck", 378 /* Direct from ULPD, no real parent */ 379 .parent = &armper_ck, 380 .rate = 48000000, 381 .flags = CLOCK_IN_OMAP16XX, 382 }; 383 384 static struct clk usb_clk0 = { /* 6 MHz output on W4_USB_CLK0 */ 385 .name = "usb_clk0", 386 .alias = "usb.clko", 387 /* Direct from ULPD, no parent */ 388 .rate = 6000000, 389 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310, 390 }; 391 392 static struct clk usb_hhc_ck1510 = { 393 .name = "usb_hhc_ck", 394 /* Direct from ULPD, no parent */ 395 .rate = 48000000, /* Actually 2 clocks, 12MHz and 48MHz */ 396 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310, 397 }; 398 399 static struct clk usb_hhc_ck16xx = { 400 .name = "usb_hhc_ck", 401 /* Direct from ULPD, no parent */ 402 .rate = 48000000, 403 /* OTG_SYSCON_2.OTG_PADEN == 0 (not 1510-compatible) */ 404 .flags = CLOCK_IN_OMAP16XX, 405 }; 406 407 static struct clk usb_w2fc_mclk = { 408 .name = "usb_w2fc_mclk", 409 .alias = "usb_w2fc_ck", 410 .parent = &ck_48m, 411 .rate = 48000000, 412 .flags = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX, 413 }; 414 415 static struct clk mclk_1510 = { 416 .name = "mclk", 417 /* Direct from ULPD, no parent. May be enabled by ext hardware. */ 418 .rate = 12000000, 419 .flags = CLOCK_IN_OMAP1510, 420 }; 421 422 static struct clk bclk_310 = { 423 .name = "bt_mclk_out", /* Alias midi_mclk_out? */ 424 .parent = &armper_ck, 425 .flags = CLOCK_IN_OMAP310, 426 }; 427 428 static struct clk mclk_310 = { 429 .name = "com_mclk_out", 430 .parent = &armper_ck, 431 .flags = CLOCK_IN_OMAP310, 432 }; 433 434 static struct clk mclk_16xx = { 435 .name = "mclk", 436 /* Direct from ULPD, no parent. May be enabled by ext hardware. */ 437 .flags = CLOCK_IN_OMAP16XX, 438 }; 439 440 static struct clk bclk_1510 = { 441 .name = "bclk", 442 /* Direct from ULPD, no parent. May be enabled by ext hardware. */ 443 .rate = 12000000, 444 .flags = CLOCK_IN_OMAP1510, 445 }; 446 447 static struct clk bclk_16xx = { 448 .name = "bclk", 449 /* Direct from ULPD, no parent. May be enabled by ext hardware. */ 450 .flags = CLOCK_IN_OMAP16XX, 451 }; 452 453 static struct clk mmc1_ck = { 454 .name = "mmc_ck", 455 .id = 1, 456 /* Functional clock is direct from ULPD, interface clock is ARMPER */ 457 .parent = &armper_ck, /* either armper_ck or dpll4 */ 458 .rate = 48000000, 459 .flags = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310, 460 }; 461 462 static struct clk mmc2_ck = { 463 .name = "mmc_ck", 464 .id = 2, 465 /* Functional clock is direct from ULPD, interface clock is ARMPER */ 466 .parent = &armper_ck, 467 .rate = 48000000, 468 .flags = CLOCK_IN_OMAP16XX, 469 }; 470 471 static struct clk cam_mclk = { 472 .name = "cam.mclk", 473 .flags = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX, 474 .rate = 12000000, 475 }; 476 477 static struct clk cam_exclk = { 478 .name = "cam.exclk", 479 .flags = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX, 480 /* Either 12M from cam.mclk or 48M from dpll4 */ 481 .parent = &cam_mclk, 482 }; 483 484 static struct clk cam_lclk = { 485 .name = "cam.lclk", 486 .flags = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX, 487 }; 488 489 static struct clk i2c_fck = { 490 .name = "i2c_fck", 491 .id = 1, 492 .flags = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | 493 ALWAYS_ENABLED, 494 .parent = &armxor_ck, 495 }; 496 497 static struct clk i2c_ick = { 498 .name = "i2c_ick", 499 .id = 1, 500 .flags = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED, 501 .parent = &armper_ck, 502 }; 503 504 static struct clk clk32k = { 505 .name = "clk32-kHz", 506 .flags = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | 507 CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED, 508 .parent = &xtal_osc32k, 509 }; 510 511 static struct clk ref_clk = { 512 .name = "ref_clk", 513 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED, 514 .rate = 12000000, /* 12 MHz or 13 MHz or 19.2 MHz */ 515 /*.parent = sys.xtalin */ 516 }; 517 518 static struct clk apll_96m = { 519 .name = "apll_96m", 520 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED, 521 .rate = 96000000, 522 /*.parent = ref_clk */ 523 }; 524 525 static struct clk apll_54m = { 526 .name = "apll_54m", 527 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED, 528 .rate = 54000000, 529 /*.parent = ref_clk */ 530 }; 531 532 static struct clk sys_clk = { 533 .name = "sys_clk", 534 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED, 535 .rate = 32768, 536 /*.parent = sys.xtalin */ 537 }; 538 539 static struct clk sleep_clk = { 540 .name = "sleep_clk", 541 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED, 542 .rate = 32768, 543 /*.parent = sys.xtalin */ 544 }; 545 546 static struct clk dpll_ck = { 547 .name = "dpll", 548 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED, 549 .parent = &ref_clk, 550 }; 551 552 static struct clk dpll_x2_ck = { 553 .name = "dpll_x2", 554 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED, 555 .parent = &ref_clk, 556 }; 557 558 static struct clk wdt1_sys_clk = { 559 .name = "wdt1_sys_clk", 560 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED, 561 .rate = 32768, 562 /*.parent = sys.xtalin */ 563 }; 564 565 static struct clk func_96m_clk = { 566 .name = "func_96m_clk", 567 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 568 .divisor = 1, 569 .parent = &apll_96m, 570 }; 571 572 static struct clk func_48m_clk = { 573 .name = "func_48m_clk", 574 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 575 .divisor = 2, 576 .parent = &apll_96m, 577 }; 578 579 static struct clk func_12m_clk = { 580 .name = "func_12m_clk", 581 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 582 .divisor = 8, 583 .parent = &apll_96m, 584 }; 585 586 static struct clk func_54m_clk = { 587 .name = "func_54m_clk", 588 .flags = CLOCK_IN_OMAP242X, 589 .divisor = 1, 590 .parent = &apll_54m, 591 }; 592 593 static struct clk sys_clkout = { 594 .name = "clkout", 595 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 596 .parent = &sys_clk, 597 }; 598 599 static struct clk sys_clkout2 = { 600 .name = "clkout2", 601 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 602 .parent = &sys_clk, 603 }; 604 605 static struct clk core_clk = { 606 .name = "core_clk", 607 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 608 .parent = &dpll_x2_ck, /* Switchable between dpll_ck and clk32k */ 609 }; 610 611 static struct clk l3_clk = { 612 .name = "l3_clk", 613 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 614 .parent = &core_clk, 615 }; 616 617 static struct clk core_l4_iclk = { 618 .name = "core_l4_iclk", 619 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 620 .parent = &l3_clk, 621 }; 622 623 static struct clk wu_l4_iclk = { 624 .name = "wu_l4_iclk", 625 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 626 .parent = &l3_clk, 627 }; 628 629 static struct clk core_l3_iclk = { 630 .name = "core_l3_iclk", 631 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 632 .parent = &core_clk, 633 }; 634 635 static struct clk core_l4_usb_clk = { 636 .name = "core_l4_usb_clk", 637 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 638 .parent = &l3_clk, 639 }; 640 641 static struct clk wu_gpt1_clk = { 642 .name = "wu_gpt1_clk", 643 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 644 .parent = &sys_clk, 645 }; 646 647 static struct clk wu_32k_clk = { 648 .name = "wu_32k_clk", 649 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 650 .parent = &sys_clk, 651 }; 652 653 static struct clk uart1_fclk = { 654 .name = "uart1_fclk", 655 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 656 .parent = &func_48m_clk, 657 }; 658 659 static struct clk uart1_iclk = { 660 .name = "uart1_iclk", 661 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 662 .parent = &core_l4_iclk, 663 }; 664 665 static struct clk uart2_fclk = { 666 .name = "uart2_fclk", 667 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 668 .parent = &func_48m_clk, 669 }; 670 671 static struct clk uart2_iclk = { 672 .name = "uart2_iclk", 673 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 674 .parent = &core_l4_iclk, 675 }; 676 677 static struct clk uart3_fclk = { 678 .name = "uart3_fclk", 679 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 680 .parent = &func_48m_clk, 681 }; 682 683 static struct clk uart3_iclk = { 684 .name = "uart3_iclk", 685 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 686 .parent = &core_l4_iclk, 687 }; 688 689 static struct clk mpu_fclk = { 690 .name = "mpu_fclk", 691 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 692 .parent = &core_clk, 693 }; 694 695 static struct clk mpu_iclk = { 696 .name = "mpu_iclk", 697 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 698 .parent = &core_clk, 699 }; 700 701 static struct clk int_m_fclk = { 702 .name = "int_m_fclk", 703 .alias = "mpu_intc_fclk", 704 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 705 .parent = &core_clk, 706 }; 707 708 static struct clk int_m_iclk = { 709 .name = "int_m_iclk", 710 .alias = "mpu_intc_iclk", 711 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 712 .parent = &core_clk, 713 }; 714 715 static struct clk core_gpt2_clk = { 716 .name = "core_gpt2_clk", 717 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 718 .parent = &sys_clk, 719 }; 720 721 static struct clk core_gpt3_clk = { 722 .name = "core_gpt3_clk", 723 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 724 .parent = &sys_clk, 725 }; 726 727 static struct clk core_gpt4_clk = { 728 .name = "core_gpt4_clk", 729 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 730 .parent = &sys_clk, 731 }; 732 733 static struct clk core_gpt5_clk = { 734 .name = "core_gpt5_clk", 735 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 736 .parent = &sys_clk, 737 }; 738 739 static struct clk core_gpt6_clk = { 740 .name = "core_gpt6_clk", 741 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 742 .parent = &sys_clk, 743 }; 744 745 static struct clk core_gpt7_clk = { 746 .name = "core_gpt7_clk", 747 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 748 .parent = &sys_clk, 749 }; 750 751 static struct clk core_gpt8_clk = { 752 .name = "core_gpt8_clk", 753 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 754 .parent = &sys_clk, 755 }; 756 757 static struct clk core_gpt9_clk = { 758 .name = "core_gpt9_clk", 759 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 760 .parent = &sys_clk, 761 }; 762 763 static struct clk core_gpt10_clk = { 764 .name = "core_gpt10_clk", 765 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 766 .parent = &sys_clk, 767 }; 768 769 static struct clk core_gpt11_clk = { 770 .name = "core_gpt11_clk", 771 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 772 .parent = &sys_clk, 773 }; 774 775 static struct clk core_gpt12_clk = { 776 .name = "core_gpt12_clk", 777 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 778 .parent = &sys_clk, 779 }; 780 781 static struct clk mcbsp1_clk = { 782 .name = "mcbsp1_cg", 783 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 784 .divisor = 2, 785 .parent = &func_96m_clk, 786 }; 787 788 static struct clk mcbsp2_clk = { 789 .name = "mcbsp2_cg", 790 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 791 .divisor = 2, 792 .parent = &func_96m_clk, 793 }; 794 795 static struct clk emul_clk = { 796 .name = "emul_ck", 797 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 798 .parent = &func_54m_clk, 799 }; 800 801 static struct clk sdma_fclk = { 802 .name = "sdma_fclk", 803 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 804 .parent = &l3_clk, 805 }; 806 807 static struct clk sdma_iclk = { 808 .name = "sdma_iclk", 809 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 810 .parent = &core_l3_iclk, /* core_l4_iclk for the configuration port */ 811 }; 812 813 static struct clk i2c1_fclk = { 814 .name = "i2c1.fclk", 815 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 816 .parent = &func_12m_clk, 817 .divisor = 1, 818 }; 819 820 static struct clk i2c1_iclk = { 821 .name = "i2c1.iclk", 822 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 823 .parent = &core_l4_iclk, 824 }; 825 826 static struct clk i2c2_fclk = { 827 .name = "i2c2.fclk", 828 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 829 .parent = &func_12m_clk, 830 .divisor = 1, 831 }; 832 833 static struct clk i2c2_iclk = { 834 .name = "i2c2.iclk", 835 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 836 .parent = &core_l4_iclk, 837 }; 838 839 static struct clk gpio_dbclk[5] = { 840 { 841 .name = "gpio1_dbclk", 842 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 843 .parent = &wu_32k_clk, 844 }, { 845 .name = "gpio2_dbclk", 846 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 847 .parent = &wu_32k_clk, 848 }, { 849 .name = "gpio3_dbclk", 850 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 851 .parent = &wu_32k_clk, 852 }, { 853 .name = "gpio4_dbclk", 854 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 855 .parent = &wu_32k_clk, 856 }, { 857 .name = "gpio5_dbclk", 858 .flags = CLOCK_IN_OMAP243X, 859 .parent = &wu_32k_clk, 860 }, 861 }; 862 863 static struct clk gpio_iclk = { 864 .name = "gpio_iclk", 865 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 866 .parent = &wu_l4_iclk, 867 }; 868 869 static struct clk mmc_fck = { 870 .name = "mmc_fclk", 871 .flags = CLOCK_IN_OMAP242X, 872 .parent = &func_96m_clk, 873 }; 874 875 static struct clk mmc_ick = { 876 .name = "mmc_iclk", 877 .flags = CLOCK_IN_OMAP242X, 878 .parent = &core_l4_iclk, 879 }; 880 881 static struct clk spi_fclk[3] = { 882 { 883 .name = "spi1_fclk", 884 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 885 .parent = &func_48m_clk, 886 }, { 887 .name = "spi2_fclk", 888 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 889 .parent = &func_48m_clk, 890 }, { 891 .name = "spi3_fclk", 892 .flags = CLOCK_IN_OMAP243X, 893 .parent = &func_48m_clk, 894 }, 895 }; 896 897 static struct clk dss_clk[2] = { 898 { 899 .name = "dss_clk1", 900 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 901 .parent = &core_clk, 902 }, { 903 .name = "dss_clk2", 904 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 905 .parent = &sys_clk, 906 }, 907 }; 908 909 static struct clk dss_54m_clk = { 910 .name = "dss_54m_clk", 911 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 912 .parent = &func_54m_clk, 913 }; 914 915 static struct clk dss_l3_iclk = { 916 .name = "dss_l3_iclk", 917 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 918 .parent = &core_l3_iclk, 919 }; 920 921 static struct clk dss_l4_iclk = { 922 .name = "dss_l4_iclk", 923 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 924 .parent = &core_l4_iclk, 925 }; 926 927 static struct clk spi_iclk[3] = { 928 { 929 .name = "spi1_iclk", 930 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 931 .parent = &core_l4_iclk, 932 }, { 933 .name = "spi2_iclk", 934 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 935 .parent = &core_l4_iclk, 936 }, { 937 .name = "spi3_iclk", 938 .flags = CLOCK_IN_OMAP243X, 939 .parent = &core_l4_iclk, 940 }, 941 }; 942 943 static struct clk omapctrl_clk = { 944 .name = "omapctrl_iclk", 945 .flags = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X, 946 /* XXX Should be in WKUP domain */ 947 .parent = &core_l4_iclk, 948 }; 949 950 static struct clk *onchip_clks[] = { 951 /* OMAP 1 */ 952 953 /* non-ULPD clocks */ 954 &xtal_osc12m, 955 &xtal_osc32k, 956 &ck_ref, 957 &dpll1, 958 &dpll2, 959 &dpll3, 960 &dpll4, 961 &apll, 962 &ck_48m, 963 /* CK_GEN1 clocks */ 964 &clkm1, 965 &ck_dpll1out, 966 &sossi_ck, 967 &arm_ck, 968 &armper_ck, 969 &arm_gpio_ck, 970 &armxor_ck, 971 &armtim_ck, 972 &armwdt_ck, 973 &arminth_ck15xx, &arminth_ck16xx, 974 /* CK_GEN2 clocks */ 975 &clkm2, 976 &dsp_ck, 977 &dspmmu_ck, 978 &dspper_ck, 979 &dspxor_ck, 980 &dsptim_ck, 981 /* CK_GEN3 clocks */ 982 &clkm3, 983 &tc_ck, 984 &tipb_ck, 985 &l3_ocpi_ck, 986 &tc1_ck, 987 &tc2_ck, 988 &dma_ck, 989 &dma_lcdfree_ck, 990 &api_ck, 991 &lb_ck, 992 &lbfree_ck, 993 &hsab_ck, 994 &rhea1_ck, 995 &rhea2_ck, 996 &lcd_ck_16xx, 997 &lcd_ck_1510, 998 /* ULPD clocks */ 999 &uart1_1510, 1000 &uart1_16xx, 1001 &uart2_ck, 1002 &uart3_1510, 1003 &uart3_16xx, 1004 &usb_clk0, 1005 &usb_hhc_ck1510, &usb_hhc_ck16xx, 1006 &mclk_1510, &mclk_16xx, &mclk_310, 1007 &bclk_1510, &bclk_16xx, &bclk_310, 1008 &mmc1_ck, 1009 &mmc2_ck, 1010 &cam_mclk, 1011 &cam_exclk, 1012 &cam_lclk, 1013 &clk32k, 1014 &usb_w2fc_mclk, 1015 /* Virtual clocks */ 1016 &i2c_fck, 1017 &i2c_ick, 1018 1019 /* OMAP 2 */ 1020 1021 &ref_clk, 1022 &apll_96m, 1023 &apll_54m, 1024 &sys_clk, 1025 &sleep_clk, 1026 &dpll_ck, 1027 &dpll_x2_ck, 1028 &wdt1_sys_clk, 1029 &func_96m_clk, 1030 &func_48m_clk, 1031 &func_12m_clk, 1032 &func_54m_clk, 1033 &sys_clkout, 1034 &sys_clkout2, 1035 &core_clk, 1036 &l3_clk, 1037 &core_l4_iclk, 1038 &wu_l4_iclk, 1039 &core_l3_iclk, 1040 &core_l4_usb_clk, 1041 &wu_gpt1_clk, 1042 &wu_32k_clk, 1043 &uart1_fclk, 1044 &uart1_iclk, 1045 &uart2_fclk, 1046 &uart2_iclk, 1047 &uart3_fclk, 1048 &uart3_iclk, 1049 &mpu_fclk, 1050 &mpu_iclk, 1051 &int_m_fclk, 1052 &int_m_iclk, 1053 &core_gpt2_clk, 1054 &core_gpt3_clk, 1055 &core_gpt4_clk, 1056 &core_gpt5_clk, 1057 &core_gpt6_clk, 1058 &core_gpt7_clk, 1059 &core_gpt8_clk, 1060 &core_gpt9_clk, 1061 &core_gpt10_clk, 1062 &core_gpt11_clk, 1063 &core_gpt12_clk, 1064 &mcbsp1_clk, 1065 &mcbsp2_clk, 1066 &emul_clk, 1067 &sdma_fclk, 1068 &sdma_iclk, 1069 &i2c1_fclk, 1070 &i2c1_iclk, 1071 &i2c2_fclk, 1072 &i2c2_iclk, 1073 &gpio_dbclk[0], 1074 &gpio_dbclk[1], 1075 &gpio_dbclk[2], 1076 &gpio_dbclk[3], 1077 &gpio_iclk, 1078 &mmc_fck, 1079 &mmc_ick, 1080 &spi_fclk[0], 1081 &spi_iclk[0], 1082 &spi_fclk[1], 1083 &spi_iclk[1], 1084 &spi_fclk[2], 1085 &spi_iclk[2], 1086 &dss_clk[0], 1087 &dss_clk[1], 1088 &dss_54m_clk, 1089 &dss_l3_iclk, 1090 &dss_l4_iclk, 1091 &omapctrl_clk, 1092 1093 NULL 1094 }; 1095 1096 void omap_clk_adduser(struct clk *clk, qemu_irq user) 1097 { 1098 qemu_irq *i; 1099 1100 for (i = clk->users; *i; i ++); 1101 *i = user; 1102 } 1103 1104 struct clk *omap_findclk(struct omap_mpu_state_s *mpu, const char *name) 1105 { 1106 struct clk *i; 1107 1108 for (i = mpu->clks; i->name; i ++) 1109 if (!strcmp(i->name, name) || (i->alias && !strcmp(i->alias, name))) 1110 return i; 1111 hw_error("%s: %s not found\n", __FUNCTION__, name); 1112 } 1113 1114 void omap_clk_get(struct clk *clk) 1115 { 1116 clk->usecount ++; 1117 } 1118 1119 void omap_clk_put(struct clk *clk) 1120 { 1121 if (!(clk->usecount --)) 1122 hw_error("%s: %s is not in use\n", __FUNCTION__, clk->name); 1123 } 1124 1125 static void omap_clk_update(struct clk *clk) 1126 { 1127 int parent, running; 1128 qemu_irq *user; 1129 struct clk *i; 1130 1131 if (clk->parent) 1132 parent = clk->parent->running; 1133 else 1134 parent = 1; 1135 1136 running = parent && (clk->enabled || 1137 ((clk->flags & ALWAYS_ENABLED) && clk->usecount)); 1138 if (clk->running != running) { 1139 clk->running = running; 1140 for (user = clk->users; *user; user ++) 1141 qemu_set_irq(*user, running); 1142 for (i = clk->child1; i; i = i->sibling) 1143 omap_clk_update(i); 1144 } 1145 } 1146 1147 static void omap_clk_rate_update_full(struct clk *clk, unsigned long int rate, 1148 unsigned long int div, unsigned long int mult) 1149 { 1150 struct clk *i; 1151 qemu_irq *user; 1152 1153 clk->rate = muldiv64(rate, mult, div); 1154 if (clk->running) 1155 for (user = clk->users; *user; user ++) 1156 qemu_irq_raise(*user); 1157 for (i = clk->child1; i; i = i->sibling) 1158 omap_clk_rate_update_full(i, rate, 1159 div * i->divisor, mult * i->multiplier); 1160 } 1161 1162 static void omap_clk_rate_update(struct clk *clk) 1163 { 1164 struct clk *i; 1165 unsigned long int div, mult = div = 1; 1166 1167 for (i = clk; i->parent; i = i->parent) { 1168 div *= i->divisor; 1169 mult *= i->multiplier; 1170 } 1171 1172 omap_clk_rate_update_full(clk, i->rate, div, mult); 1173 } 1174 1175 void omap_clk_reparent(struct clk *clk, struct clk *parent) 1176 { 1177 struct clk **p; 1178 1179 if (clk->parent) { 1180 for (p = &clk->parent->child1; *p != clk; p = &(*p)->sibling); 1181 *p = clk->sibling; 1182 } 1183 1184 clk->parent = parent; 1185 if (parent) { 1186 clk->sibling = parent->child1; 1187 parent->child1 = clk; 1188 omap_clk_update(clk); 1189 omap_clk_rate_update(clk); 1190 } else 1191 clk->sibling = NULL; 1192 } 1193 1194 void omap_clk_onoff(struct clk *clk, int on) 1195 { 1196 clk->enabled = on; 1197 omap_clk_update(clk); 1198 } 1199 1200 void omap_clk_canidle(struct clk *clk, int can) 1201 { 1202 if (can) 1203 omap_clk_put(clk); 1204 else 1205 omap_clk_get(clk); 1206 } 1207 1208 void omap_clk_setrate(struct clk *clk, int divide, int multiply) 1209 { 1210 clk->divisor = divide; 1211 clk->multiplier = multiply; 1212 omap_clk_rate_update(clk); 1213 } 1214 1215 int64_t omap_clk_getrate(omap_clk clk) 1216 { 1217 return clk->rate; 1218 } 1219 1220 void omap_clk_init(struct omap_mpu_state_s *mpu) 1221 { 1222 struct clk **i, *j, *k; 1223 int count; 1224 int flag; 1225 1226 if (cpu_is_omap310(mpu)) 1227 flag = CLOCK_IN_OMAP310; 1228 else if (cpu_is_omap1510(mpu)) 1229 flag = CLOCK_IN_OMAP1510; 1230 else if (cpu_is_omap2410(mpu) || cpu_is_omap2420(mpu)) 1231 flag = CLOCK_IN_OMAP242X; 1232 else if (cpu_is_omap2430(mpu)) 1233 flag = CLOCK_IN_OMAP243X; 1234 else if (cpu_is_omap3430(mpu)) 1235 flag = CLOCK_IN_OMAP243X; 1236 else 1237 return; 1238 1239 for (i = onchip_clks, count = 0; *i; i ++) 1240 if ((*i)->flags & flag) 1241 count ++; 1242 mpu->clks = (struct clk *) g_malloc0(sizeof(struct clk) * (count + 1)); 1243 for (i = onchip_clks, j = mpu->clks; *i; i ++) 1244 if ((*i)->flags & flag) { 1245 memcpy(j, *i, sizeof(struct clk)); 1246 for (k = mpu->clks; k < j; k ++) 1247 if (j->parent && !strcmp(j->parent->name, k->name)) { 1248 j->parent = k; 1249 j->sibling = k->child1; 1250 k->child1 = j; 1251 } else if (k->parent && !strcmp(k->parent->name, j->name)) { 1252 k->parent = j; 1253 k->sibling = j->child1; 1254 j->child1 = k; 1255 } 1256 j->divisor = j->divisor ?: 1; 1257 j->multiplier = j->multiplier ?: 1; 1258 j ++; 1259 } 1260 for (j = mpu->clks; count --; j ++) { 1261 omap_clk_update(j); 1262 omap_clk_rate_update(j); 1263 } 1264 } 1265