paul@0 | 1 | /* |
paul@0 | 2 | * Clock and power management. This exposes the combined functionality |
paul@0 | 3 | * provided by the jz4730. The power management functionality could be exposed |
paul@0 | 4 | * using a separate driver. |
paul@0 | 5 | * |
paul@143 | 6 | * Copyright (C) 2017, 2018, 2020, 2023 Paul Boddie <paul@boddie.org.uk> |
paul@0 | 7 | * |
paul@0 | 8 | * This program is free software; you can redistribute it and/or |
paul@0 | 9 | * modify it under the terms of the GNU General Public License as |
paul@0 | 10 | * published by the Free Software Foundation; either version 2 of |
paul@0 | 11 | * the License, or (at your option) any later version. |
paul@0 | 12 | * |
paul@0 | 13 | * This program is distributed in the hope that it will be useful, |
paul@0 | 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
paul@0 | 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
paul@0 | 16 | * GNU General Public License for more details. |
paul@0 | 17 | * |
paul@0 | 18 | * You should have received a copy of the GNU General Public License |
paul@0 | 19 | * along with this program; if not, write to the Free Software |
paul@0 | 20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, |
paul@0 | 21 | * Boston, MA 02110-1301, USA |
paul@0 | 22 | */ |
paul@0 | 23 | |
paul@0 | 24 | #include <l4/devices/hw_mmio_register_block.h> |
paul@0 | 25 | #include "cpm-jz4730.h" |
paul@0 | 26 | |
paul@0 | 27 | |
paul@0 | 28 | |
paul@0 | 29 | enum Regs : unsigned |
paul@0 | 30 | { |
paul@0 | 31 | Clock_control = 0x000, // CFCR (CPCCR in JZ4740) |
paul@0 | 32 | Pll_control = 0x010, // PLCR1 (CPPCR in JZ4740) |
paul@0 | 33 | Clock_gate = 0x020, // MSCR (CLKGR in JZ4740) |
paul@0 | 34 | Sleep_control = 0x024, // SCR |
paul@0 | 35 | Lcd_divider = 0x060, // CFCR2 |
paul@0 | 36 | }; |
paul@0 | 37 | |
paul@0 | 38 | enum Clock_bits : unsigned |
paul@0 | 39 | { |
paul@0 | 40 | Clock_enable = 20, // UPE |
paul@0 | 41 | Clock_memory_divider = 16, // MFR |
paul@0 | 42 | Clock_lcd_divider = 12, // LFR |
paul@0 | 43 | Clock_pclock_divider = 8, // PFR (slow APB peripherals) |
paul@0 | 44 | Clock_hclock_divider = 4, // SFR (fast AHB peripherals) |
paul@0 | 45 | Clock_cpu_divider = 0, // IFR |
paul@0 | 46 | }; |
paul@0 | 47 | |
paul@0 | 48 | enum Pll_bits : unsigned |
paul@0 | 49 | { |
paul@0 | 50 | Pll_multiplier = 23, // PLL1FD |
paul@0 | 51 | Pll_input_division = 18, // PLL1RD |
paul@0 | 52 | Pll_output_division = 16, // PLL1OD |
paul@0 | 53 | Pll_stable = 10, // PLL1S |
paul@0 | 54 | Pll_bypassed = 9, // PLL1BP |
paul@0 | 55 | Pll_enabled = 8, // PLL1EN |
paul@0 | 56 | }; |
paul@0 | 57 | |
paul@0 | 58 | enum Clock_gate_bits : unsigned |
paul@0 | 59 | { |
paul@114 | 60 | Clock_gate_uprt = 25, |
paul@114 | 61 | Clock_gate_udc = 24, |
paul@114 | 62 | Clock_gate_cim = 23, |
paul@114 | 63 | Clock_gate_kbc = 22, |
paul@114 | 64 | Clock_gate_emac = 21, |
paul@114 | 65 | Clock_gate_uart3 = 20, |
paul@114 | 66 | Clock_gate_aic_bitclk = 18, |
paul@114 | 67 | Clock_gate_scc = 14, |
paul@114 | 68 | Clock_gate_msc = 13, |
paul@114 | 69 | Clock_gate_ssi = 12, |
paul@114 | 70 | Clock_gate_pwm1 = 11, |
paul@114 | 71 | Clock_gate_pmw0 = 10, |
paul@114 | 72 | Clock_gate_aic_pclk = 9, |
paul@114 | 73 | Clock_gate_i2c = 8, |
paul@114 | 74 | Clock_gate_lcd = 7, |
paul@114 | 75 | Clock_gate_uhc = 6, |
paul@114 | 76 | Clock_gate_dmac = 5, |
paul@114 | 77 | Clock_gate_timer = 3, |
paul@114 | 78 | Clock_gate_uart2 = 2, |
paul@114 | 79 | Clock_gate_uart1 = 1, |
paul@114 | 80 | Clock_gate_uart0 = 0, |
paul@0 | 81 | }; |
paul@0 | 82 | |
paul@0 | 83 | enum Lcd_divider_bits : unsigned |
paul@0 | 84 | { |
paul@0 | 85 | Lcd_divider_value = 0, // PIXFR (in CFCR2) |
paul@0 | 86 | }; |
paul@0 | 87 | |
paul@0 | 88 | |
paul@0 | 89 | |
paul@0 | 90 | // If implemented as a Hw::Device, various properties would be |
paul@0 | 91 | // initialised in the constructor and obtained from the device tree |
paul@0 | 92 | // definitions. |
paul@0 | 93 | |
paul@0 | 94 | Cpm_jz4730_chip::Cpm_jz4730_chip(l4_addr_t addr, uint32_t exclk_freq) |
paul@0 | 95 | : _exclk_freq(exclk_freq) |
paul@0 | 96 | { |
paul@0 | 97 | _regs = new Hw::Mmio_register_block<32>(addr); |
paul@0 | 98 | |
paul@0 | 99 | // add_cid("cpm"); |
paul@0 | 100 | // add_cid("cpm-jz4730"); |
paul@0 | 101 | // register_property("exclk_freq", &_exclk_freq); |
paul@0 | 102 | } |
paul@0 | 103 | |
paul@0 | 104 | // Clock/timer control. |
paul@0 | 105 | |
paul@0 | 106 | int |
paul@0 | 107 | Cpm_jz4730_chip::have_clock() |
paul@0 | 108 | { |
paul@0 | 109 | return !(_regs[Clock_gate] & (1 << Clock_gate_timer)); |
paul@0 | 110 | } |
paul@0 | 111 | |
paul@0 | 112 | void |
paul@0 | 113 | Cpm_jz4730_chip::start_clock() |
paul@0 | 114 | { |
paul@0 | 115 | _regs[Clock_gate] = _regs[Clock_gate] & ~(1 << Clock_gate_timer); |
paul@0 | 116 | } |
paul@0 | 117 | |
paul@0 | 118 | // PLL control. |
paul@0 | 119 | |
paul@0 | 120 | // Return whether the PLL is stable. |
paul@0 | 121 | |
paul@0 | 122 | int |
paul@0 | 123 | Cpm_jz4730_chip::have_pll() |
paul@0 | 124 | { |
paul@0 | 125 | return _regs[Pll_control] & (1 << Pll_stable); |
paul@0 | 126 | } |
paul@0 | 127 | |
paul@0 | 128 | int |
paul@0 | 129 | Cpm_jz4730_chip::pll_enabled() |
paul@0 | 130 | { |
paul@0 | 131 | return _regs[Pll_control] & (1 << Pll_enabled); |
paul@0 | 132 | } |
paul@0 | 133 | |
paul@0 | 134 | int |
paul@0 | 135 | Cpm_jz4730_chip::pll_bypassed() |
paul@0 | 136 | { |
paul@0 | 137 | return _regs[Pll_control] & (1 << Pll_bypassed); |
paul@0 | 138 | } |
paul@0 | 139 | |
paul@0 | 140 | // Feedback (9-bit) multiplier. |
paul@0 | 141 | |
paul@0 | 142 | uint16_t |
paul@0 | 143 | Cpm_jz4730_chip::get_multiplier() |
paul@0 | 144 | { |
paul@0 | 145 | return ((_regs[Pll_control] & (0x1ff << Pll_multiplier)) >> Pll_multiplier) + 2; |
paul@0 | 146 | } |
paul@0 | 147 | |
paul@0 | 148 | // Input (5-bit) divider. |
paul@0 | 149 | |
paul@0 | 150 | uint8_t |
paul@0 | 151 | Cpm_jz4730_chip::get_input_division() |
paul@0 | 152 | { |
paul@0 | 153 | return ((_regs[Pll_control] & (0x1f << Pll_input_division)) >> Pll_input_division) + 2; |
paul@0 | 154 | } |
paul@0 | 155 | |
paul@0 | 156 | // Output divider. |
paul@0 | 157 | |
paul@0 | 158 | static uint8_t od[4] = {1, 2, 2, 4}; |
paul@0 | 159 | |
paul@0 | 160 | uint8_t |
paul@0 | 161 | Cpm_jz4730_chip::get_output_division() |
paul@0 | 162 | { |
paul@0 | 163 | return od[(_regs[Pll_control] & (0x03 << Pll_output_division)) >> Pll_output_division]; |
paul@0 | 164 | } |
paul@0 | 165 | |
paul@0 | 166 | // General clock divider. |
paul@0 | 167 | |
paul@0 | 168 | static uint8_t cd[] = {1, 2, 3, 4, 6, 8, 12, 16, 24, 32}; |
paul@0 | 169 | |
paul@0 | 170 | uint8_t |
paul@0 | 171 | Cpm_jz4730_chip::_get_divider(uint32_t reg, uint32_t mask, uint8_t shift) |
paul@0 | 172 | { |
paul@0 | 173 | uint8_t d = (_regs[reg] & mask) >> shift; |
paul@0 | 174 | return (d < 10) ? cd[d] : 1; |
paul@0 | 175 | } |
paul@0 | 176 | |
paul@0 | 177 | // CPU clock (CCLK) divider. |
paul@0 | 178 | |
paul@0 | 179 | uint8_t |
paul@0 | 180 | Cpm_jz4730_chip::get_cpu_divider() |
paul@0 | 181 | { |
paul@0 | 182 | return _get_divider(Clock_control, 0xf << Clock_cpu_divider, Clock_cpu_divider); |
paul@0 | 183 | } |
paul@0 | 184 | |
paul@0 | 185 | // Fast peripheral clock (HCLK) divider. |
paul@0 | 186 | |
paul@0 | 187 | uint8_t |
paul@0 | 188 | Cpm_jz4730_chip::get_hclock_divider() |
paul@0 | 189 | { |
paul@0 | 190 | return _get_divider(Clock_control, 0xf << Clock_hclock_divider, Clock_hclock_divider); |
paul@0 | 191 | } |
paul@0 | 192 | |
paul@0 | 193 | // Slow peripheral clock (PCLK) divider. |
paul@0 | 194 | |
paul@0 | 195 | uint8_t |
paul@0 | 196 | Cpm_jz4730_chip::get_pclock_divider() |
paul@0 | 197 | { |
paul@0 | 198 | return _get_divider(Clock_control, 0xf << Clock_pclock_divider, Clock_pclock_divider); |
paul@0 | 199 | } |
paul@0 | 200 | |
paul@0 | 201 | // Memory clock (MCLK) divider. |
paul@0 | 202 | |
paul@0 | 203 | uint8_t |
paul@0 | 204 | Cpm_jz4730_chip::get_memory_divider() |
paul@0 | 205 | { |
paul@0 | 206 | return _get_divider(Clock_control, 0xf << Clock_memory_divider, Clock_memory_divider); |
paul@0 | 207 | } |
paul@0 | 208 | |
paul@0 | 209 | // Clock source divider for MSC, I2S, LCD and USB. |
paul@0 | 210 | |
paul@0 | 211 | uint8_t |
paul@0 | 212 | Cpm_jz4730_chip::get_source_divider() |
paul@0 | 213 | { |
paul@0 | 214 | return 1; |
paul@0 | 215 | } |
paul@0 | 216 | |
paul@0 | 217 | // LCD device clock divider. |
paul@0 | 218 | |
paul@0 | 219 | void |
paul@0 | 220 | Cpm_jz4730_chip::set_lcd_device_divider(uint8_t division) |
paul@0 | 221 | { |
paul@0 | 222 | if (division == 0) |
paul@0 | 223 | division = 1; |
paul@0 | 224 | |
paul@0 | 225 | // NOTE: The vendor code (clock.c) bounds the divider at 16, but maybe this is |
paul@0 | 226 | // NOTE: confused with the width of the bitfield which actually contains an |
paul@0 | 227 | // NOTE: index for the clock divider value array (cd). |
paul@0 | 228 | |
paul@0 | 229 | else if (division > 16) |
paul@0 | 230 | division = 16; |
paul@0 | 231 | |
paul@0 | 232 | // Obtain the divider or closest higher divider. |
paul@0 | 233 | |
paul@0 | 234 | int i; |
paul@0 | 235 | |
paul@0 | 236 | for (i = 0; i < 10; i++) |
paul@0 | 237 | if (cd[i] >= division) break; |
paul@0 | 238 | |
paul@0 | 239 | _regs[Clock_control] = (_regs[Clock_control] & ~(0xf << Clock_lcd_divider)) | |
paul@0 | 240 | (cd[i] << Clock_lcd_divider); |
paul@0 | 241 | } |
paul@0 | 242 | |
paul@0 | 243 | // LCD pixel clock divider. |
paul@0 | 244 | |
paul@0 | 245 | uint16_t |
paul@0 | 246 | Cpm_jz4730_chip::get_lcd_pixel_divider() |
paul@0 | 247 | { |
paul@0 | 248 | return (_regs[Lcd_divider] >> Lcd_divider_value) + 1; |
paul@0 | 249 | } |
paul@0 | 250 | |
paul@0 | 251 | void |
paul@0 | 252 | Cpm_jz4730_chip::set_lcd_pixel_divider(uint16_t division) |
paul@0 | 253 | { |
paul@0 | 254 | if (division == 0) |
paul@0 | 255 | division = 1; |
paul@0 | 256 | else if (division > 512) |
paul@0 | 257 | division = 512; |
paul@0 | 258 | |
paul@0 | 259 | _regs[Lcd_divider] = (_regs[Lcd_divider] & ~(0x1ff << Lcd_divider_value)) | |
paul@0 | 260 | ((division - 1) << Lcd_divider_value); |
paul@0 | 261 | } |
paul@0 | 262 | |
paul@0 | 263 | |
paul@0 | 264 | |
paul@0 | 265 | uint32_t |
paul@0 | 266 | Cpm_jz4730_chip::get_lcd_pixel_frequency() |
paul@0 | 267 | { |
paul@0 | 268 | return get_output_frequency() / get_lcd_pixel_divider(); |
paul@0 | 269 | } |
paul@0 | 270 | |
paul@0 | 271 | // Set the device and pixel frequencies, indicating the latter and |
paul@0 | 272 | // providing the device:pixel frequency ratio. |
paul@0 | 273 | |
paul@0 | 274 | void |
paul@0 | 275 | Cpm_jz4730_chip::set_lcd_frequencies(uint32_t pclk, uint8_t ratio) |
paul@0 | 276 | { |
paul@0 | 277 | uint32_t out = get_output_frequency(), |
paul@0 | 278 | lcd = pclk * ratio; |
paul@0 | 279 | |
paul@0 | 280 | set_lcd_pixel_divider(out / pclk); |
paul@0 | 281 | |
paul@0 | 282 | // Limit the device frequency to 150MHz. |
paul@0 | 283 | |
paul@0 | 284 | if (lcd > 150000000) lcd = 150000000; |
paul@0 | 285 | |
paul@0 | 286 | set_lcd_device_divider(out / lcd); |
paul@0 | 287 | } |
paul@0 | 288 | |
paul@0 | 289 | |
paul@0 | 290 | |
paul@143 | 291 | // DMA clock control. |
paul@143 | 292 | |
paul@143 | 293 | void |
paul@143 | 294 | Cpm_jz4730_chip::start_dma() |
paul@143 | 295 | { |
paul@143 | 296 | _regs[Clock_gate] = _regs[Clock_gate] & ~(1 << Clock_gate_dmac); |
paul@143 | 297 | } |
paul@143 | 298 | |
paul@143 | 299 | void |
paul@143 | 300 | Cpm_jz4730_chip::stop_dma() |
paul@143 | 301 | { |
paul@143 | 302 | _regs[Clock_gate] = _regs[Clock_gate] | (1 << Clock_gate_dmac); |
paul@143 | 303 | } |
paul@143 | 304 | |
paul@143 | 305 | |
paul@143 | 306 | |
paul@114 | 307 | // I2C clock control. |
paul@114 | 308 | |
paul@114 | 309 | void |
paul@114 | 310 | Cpm_jz4730_chip::start_i2c() |
paul@114 | 311 | { |
paul@114 | 312 | _regs[Clock_gate] = _regs[Clock_gate] & ~(1 << Clock_gate_i2c); |
paul@114 | 313 | } |
paul@114 | 314 | |
paul@114 | 315 | void |
paul@114 | 316 | Cpm_jz4730_chip::stop_i2c() |
paul@114 | 317 | { |
paul@114 | 318 | _regs[Clock_gate] = _regs[Clock_gate] | (1 << Clock_gate_i2c); |
paul@114 | 319 | } |
paul@114 | 320 | |
paul@114 | 321 | |
paul@114 | 322 | |
paul@0 | 323 | // LCD clock control. |
paul@0 | 324 | |
paul@0 | 325 | void |
paul@0 | 326 | Cpm_jz4730_chip::start_lcd() |
paul@0 | 327 | { |
paul@0 | 328 | _regs[Clock_gate] = _regs[Clock_gate] & ~(1 << Clock_gate_lcd); |
paul@0 | 329 | } |
paul@0 | 330 | |
paul@0 | 331 | void |
paul@0 | 332 | Cpm_jz4730_chip::stop_lcd() |
paul@0 | 333 | { |
paul@0 | 334 | _regs[Clock_gate] = _regs[Clock_gate] | (1 << Clock_gate_lcd); |
paul@0 | 335 | } |
paul@0 | 336 | |
paul@0 | 337 | |
paul@0 | 338 | |
paul@0 | 339 | uint32_t |
paul@0 | 340 | Cpm_jz4730_chip::get_pll_frequency() |
paul@0 | 341 | { |
paul@0 | 342 | // Test for PLL enable and not PLL bypass. |
paul@0 | 343 | |
paul@0 | 344 | if (pll_enabled() && !pll_bypassed()) |
paul@0 | 345 | return (_exclk_freq * get_multiplier()) / |
paul@0 | 346 | (get_input_division() * get_output_division()); |
paul@0 | 347 | else |
paul@0 | 348 | return _exclk_freq; |
paul@0 | 349 | } |
paul@0 | 350 | |
paul@0 | 351 | // Clock frequency for MSC, I2S, LCD and USB. |
paul@0 | 352 | |
paul@0 | 353 | uint32_t |
paul@0 | 354 | Cpm_jz4730_chip::get_output_frequency() |
paul@0 | 355 | { |
paul@0 | 356 | return get_pll_frequency() / get_source_divider(); |
paul@0 | 357 | } |
paul@0 | 358 | |
paul@0 | 359 | void |
paul@0 | 360 | Cpm_jz4730_chip::update_output_frequency() |
paul@0 | 361 | { |
paul@0 | 362 | _regs[Clock_control] = _regs[Clock_control] | (1 << Clock_enable); |
paul@0 | 363 | } |
paul@0 | 364 | |
paul@0 | 365 | // Clock frequency for the CPU. |
paul@0 | 366 | |
paul@0 | 367 | uint32_t Cpm_jz4730_chip::get_cpu_frequency() |
paul@0 | 368 | { |
paul@0 | 369 | if (pll_enabled()) |
paul@0 | 370 | return get_pll_frequency() / get_cpu_divider(); |
paul@0 | 371 | else |
paul@0 | 372 | return _exclk_freq; |
paul@0 | 373 | } |
paul@0 | 374 | |
paul@0 | 375 | // Clock frequency for fast peripherals. |
paul@0 | 376 | |
paul@0 | 377 | uint32_t |
paul@0 | 378 | Cpm_jz4730_chip::get_hclock_frequency() |
paul@0 | 379 | { |
paul@0 | 380 | if (pll_enabled()) |
paul@0 | 381 | return get_pll_frequency() / get_hclock_divider(); |
paul@0 | 382 | else |
paul@0 | 383 | return _exclk_freq; |
paul@0 | 384 | } |
paul@0 | 385 | |
paul@0 | 386 | // Clock frequency for slow peripherals. |
paul@0 | 387 | |
paul@0 | 388 | uint32_t |
paul@0 | 389 | Cpm_jz4730_chip::get_pclock_frequency() |
paul@0 | 390 | { |
paul@0 | 391 | if (pll_enabled()) |
paul@0 | 392 | return get_pll_frequency() / get_pclock_divider(); |
paul@0 | 393 | else |
paul@0 | 394 | return _exclk_freq; |
paul@0 | 395 | } |
paul@0 | 396 | |
paul@0 | 397 | // Clock frequency for the memory. |
paul@0 | 398 | |
paul@0 | 399 | uint32_t |
paul@0 | 400 | Cpm_jz4730_chip::get_memory_frequency() |
paul@0 | 401 | { |
paul@0 | 402 | if (pll_enabled()) |
paul@0 | 403 | return get_pll_frequency() / get_memory_divider(); |
paul@0 | 404 | else |
paul@0 | 405 | return _exclk_freq; |
paul@0 | 406 | } |
paul@0 | 407 | |
paul@0 | 408 | |
paul@0 | 409 | |
paul@0 | 410 | // C language interface functions. |
paul@0 | 411 | |
paul@0 | 412 | void |
paul@0 | 413 | *jz4730_cpm_init(l4_addr_t cpm_base) |
paul@0 | 414 | { |
paul@0 | 415 | /* Initialise the clock and power management peripheral with the |
paul@0 | 416 | register memory region and a 3.6864 MHz EXCLK frequency. */ |
paul@0 | 417 | |
paul@0 | 418 | return (void *) new Cpm_jz4730_chip(cpm_base, 3686400); |
paul@0 | 419 | } |
paul@0 | 420 | |
paul@0 | 421 | int |
paul@0 | 422 | jz4730_cpm_have_clock(void *cpm) |
paul@0 | 423 | { |
paul@0 | 424 | return static_cast<Cpm_jz4730_chip *>(cpm)->have_clock(); |
paul@0 | 425 | } |
paul@0 | 426 | |
paul@0 | 427 | void |
paul@0 | 428 | jz4730_cpm_start_clock(void *cpm) |
paul@0 | 429 | { |
paul@0 | 430 | static_cast<Cpm_jz4730_chip *>(cpm)->start_clock(); |
paul@0 | 431 | } |
paul@0 | 432 | |
paul@0 | 433 | void |
paul@114 | 434 | jz4730_cpm_start_i2c(void *cpm) |
paul@114 | 435 | { |
paul@114 | 436 | static_cast<Cpm_jz4730_chip *>(cpm)->start_i2c(); |
paul@114 | 437 | } |
paul@114 | 438 | |
paul@114 | 439 | void |
paul@114 | 440 | jz4730_cpm_stop_i2c(void *cpm) |
paul@114 | 441 | { |
paul@114 | 442 | static_cast<Cpm_jz4730_chip *>(cpm)->stop_i2c(); |
paul@114 | 443 | } |
paul@114 | 444 | |
paul@114 | 445 | void |
paul@0 | 446 | jz4730_cpm_start_lcd(void *cpm) |
paul@0 | 447 | { |
paul@0 | 448 | static_cast<Cpm_jz4730_chip *>(cpm)->start_lcd(); |
paul@0 | 449 | } |
paul@0 | 450 | |
paul@0 | 451 | void |
paul@0 | 452 | jz4730_cpm_stop_lcd(void *cpm) |
paul@0 | 453 | { |
paul@0 | 454 | static_cast<Cpm_jz4730_chip *>(cpm)->stop_lcd(); |
paul@0 | 455 | } |
paul@0 | 456 | |
paul@0 | 457 | uint32_t |
paul@0 | 458 | jz4730_cpm_get_cpu_frequency(void *cpm) |
paul@0 | 459 | { |
paul@0 | 460 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_cpu_frequency(); |
paul@0 | 461 | } |
paul@0 | 462 | |
paul@0 | 463 | uint32_t |
paul@0 | 464 | jz4730_cpm_get_hclock_frequency(void *cpm) |
paul@0 | 465 | { |
paul@0 | 466 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_hclock_frequency(); |
paul@0 | 467 | } |
paul@0 | 468 | |
paul@0 | 469 | uint32_t |
paul@0 | 470 | jz4730_cpm_get_output_frequency(void *cpm) |
paul@0 | 471 | { |
paul@0 | 472 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_output_frequency(); |
paul@0 | 473 | } |
paul@0 | 474 | |
paul@0 | 475 | uint32_t |
paul@0 | 476 | jz4730_cpm_get_pclock_frequency(void *cpm) |
paul@0 | 477 | { |
paul@0 | 478 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_pclock_frequency(); |
paul@0 | 479 | } |
paul@0 | 480 | |
paul@0 | 481 | uint32_t |
paul@0 | 482 | jz4730_cpm_get_memory_frequency(void *cpm) |
paul@0 | 483 | { |
paul@0 | 484 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_memory_frequency(); |
paul@0 | 485 | } |
paul@0 | 486 | |
paul@0 | 487 | uint16_t |
paul@0 | 488 | jz4730_cpm_get_lcd_pixel_divider(void *cpm) |
paul@0 | 489 | { |
paul@0 | 490 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_lcd_pixel_divider(); |
paul@0 | 491 | } |
paul@0 | 492 | |
paul@0 | 493 | uint32_t |
paul@0 | 494 | jz4730_cpm_get_lcd_pixel_frequency(void *cpm) |
paul@0 | 495 | { |
paul@0 | 496 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_lcd_pixel_frequency(); |
paul@0 | 497 | } |
paul@0 | 498 | |
paul@0 | 499 | void |
paul@0 | 500 | jz4730_cpm_set_lcd_frequencies(void *cpm, uint32_t pclk, uint8_t ratio) |
paul@0 | 501 | { |
paul@0 | 502 | static_cast<Cpm_jz4730_chip *>(cpm)->set_lcd_frequencies(pclk, ratio); |
paul@0 | 503 | } |
paul@0 | 504 | |
paul@0 | 505 | void |
paul@0 | 506 | jz4730_cpm_update_output_frequency(void *cpm) |
paul@0 | 507 | { |
paul@0 | 508 | static_cast<Cpm_jz4730_chip *>(cpm)->update_output_frequency(); |
paul@0 | 509 | } |