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@0 | 6 | * (c) 2017, 2018 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@0 | 60 | Clock_gate_lcd = 7, // LCD |
paul@0 | 61 | Clock_gate_timer = 3, // OST |
paul@0 | 62 | }; |
paul@0 | 63 | |
paul@0 | 64 | enum Lcd_divider_bits : unsigned |
paul@0 | 65 | { |
paul@0 | 66 | Lcd_divider_value = 0, // PIXFR (in CFCR2) |
paul@0 | 67 | }; |
paul@0 | 68 | |
paul@0 | 69 | |
paul@0 | 70 | |
paul@0 | 71 | // If implemented as a Hw::Device, various properties would be |
paul@0 | 72 | // initialised in the constructor and obtained from the device tree |
paul@0 | 73 | // definitions. |
paul@0 | 74 | |
paul@0 | 75 | Cpm_jz4730_chip::Cpm_jz4730_chip(l4_addr_t addr, uint32_t exclk_freq) |
paul@0 | 76 | : _exclk_freq(exclk_freq) |
paul@0 | 77 | { |
paul@0 | 78 | _regs = new Hw::Mmio_register_block<32>(addr); |
paul@0 | 79 | |
paul@0 | 80 | // add_cid("cpm"); |
paul@0 | 81 | // add_cid("cpm-jz4730"); |
paul@0 | 82 | // register_property("exclk_freq", &_exclk_freq); |
paul@0 | 83 | } |
paul@0 | 84 | |
paul@0 | 85 | // Clock/timer control. |
paul@0 | 86 | |
paul@0 | 87 | int |
paul@0 | 88 | Cpm_jz4730_chip::have_clock() |
paul@0 | 89 | { |
paul@0 | 90 | return !(_regs[Clock_gate] & (1 << Clock_gate_timer)); |
paul@0 | 91 | } |
paul@0 | 92 | |
paul@0 | 93 | void |
paul@0 | 94 | Cpm_jz4730_chip::start_clock() |
paul@0 | 95 | { |
paul@0 | 96 | _regs[Clock_gate] = _regs[Clock_gate] & ~(1 << Clock_gate_timer); |
paul@0 | 97 | } |
paul@0 | 98 | |
paul@0 | 99 | // PLL control. |
paul@0 | 100 | |
paul@0 | 101 | // Return whether the PLL is stable. |
paul@0 | 102 | |
paul@0 | 103 | int |
paul@0 | 104 | Cpm_jz4730_chip::have_pll() |
paul@0 | 105 | { |
paul@0 | 106 | return _regs[Pll_control] & (1 << Pll_stable); |
paul@0 | 107 | } |
paul@0 | 108 | |
paul@0 | 109 | int |
paul@0 | 110 | Cpm_jz4730_chip::pll_enabled() |
paul@0 | 111 | { |
paul@0 | 112 | return _regs[Pll_control] & (1 << Pll_enabled); |
paul@0 | 113 | } |
paul@0 | 114 | |
paul@0 | 115 | int |
paul@0 | 116 | Cpm_jz4730_chip::pll_bypassed() |
paul@0 | 117 | { |
paul@0 | 118 | return _regs[Pll_control] & (1 << Pll_bypassed); |
paul@0 | 119 | } |
paul@0 | 120 | |
paul@0 | 121 | // Feedback (9-bit) multiplier. |
paul@0 | 122 | |
paul@0 | 123 | uint16_t |
paul@0 | 124 | Cpm_jz4730_chip::get_multiplier() |
paul@0 | 125 | { |
paul@0 | 126 | return ((_regs[Pll_control] & (0x1ff << Pll_multiplier)) >> Pll_multiplier) + 2; |
paul@0 | 127 | } |
paul@0 | 128 | |
paul@0 | 129 | // Input (5-bit) divider. |
paul@0 | 130 | |
paul@0 | 131 | uint8_t |
paul@0 | 132 | Cpm_jz4730_chip::get_input_division() |
paul@0 | 133 | { |
paul@0 | 134 | return ((_regs[Pll_control] & (0x1f << Pll_input_division)) >> Pll_input_division) + 2; |
paul@0 | 135 | } |
paul@0 | 136 | |
paul@0 | 137 | // Output divider. |
paul@0 | 138 | |
paul@0 | 139 | static uint8_t od[4] = {1, 2, 2, 4}; |
paul@0 | 140 | |
paul@0 | 141 | uint8_t |
paul@0 | 142 | Cpm_jz4730_chip::get_output_division() |
paul@0 | 143 | { |
paul@0 | 144 | return od[(_regs[Pll_control] & (0x03 << Pll_output_division)) >> Pll_output_division]; |
paul@0 | 145 | } |
paul@0 | 146 | |
paul@0 | 147 | // General clock divider. |
paul@0 | 148 | |
paul@0 | 149 | static uint8_t cd[] = {1, 2, 3, 4, 6, 8, 12, 16, 24, 32}; |
paul@0 | 150 | |
paul@0 | 151 | uint8_t |
paul@0 | 152 | Cpm_jz4730_chip::_get_divider(uint32_t reg, uint32_t mask, uint8_t shift) |
paul@0 | 153 | { |
paul@0 | 154 | uint8_t d = (_regs[reg] & mask) >> shift; |
paul@0 | 155 | return (d < 10) ? cd[d] : 1; |
paul@0 | 156 | } |
paul@0 | 157 | |
paul@0 | 158 | // CPU clock (CCLK) divider. |
paul@0 | 159 | |
paul@0 | 160 | uint8_t |
paul@0 | 161 | Cpm_jz4730_chip::get_cpu_divider() |
paul@0 | 162 | { |
paul@0 | 163 | return _get_divider(Clock_control, 0xf << Clock_cpu_divider, Clock_cpu_divider); |
paul@0 | 164 | } |
paul@0 | 165 | |
paul@0 | 166 | // Fast peripheral clock (HCLK) divider. |
paul@0 | 167 | |
paul@0 | 168 | uint8_t |
paul@0 | 169 | Cpm_jz4730_chip::get_hclock_divider() |
paul@0 | 170 | { |
paul@0 | 171 | return _get_divider(Clock_control, 0xf << Clock_hclock_divider, Clock_hclock_divider); |
paul@0 | 172 | } |
paul@0 | 173 | |
paul@0 | 174 | // Slow peripheral clock (PCLK) divider. |
paul@0 | 175 | |
paul@0 | 176 | uint8_t |
paul@0 | 177 | Cpm_jz4730_chip::get_pclock_divider() |
paul@0 | 178 | { |
paul@0 | 179 | return _get_divider(Clock_control, 0xf << Clock_pclock_divider, Clock_pclock_divider); |
paul@0 | 180 | } |
paul@0 | 181 | |
paul@0 | 182 | // Memory clock (MCLK) divider. |
paul@0 | 183 | |
paul@0 | 184 | uint8_t |
paul@0 | 185 | Cpm_jz4730_chip::get_memory_divider() |
paul@0 | 186 | { |
paul@0 | 187 | return _get_divider(Clock_control, 0xf << Clock_memory_divider, Clock_memory_divider); |
paul@0 | 188 | } |
paul@0 | 189 | |
paul@0 | 190 | // Clock source divider for MSC, I2S, LCD and USB. |
paul@0 | 191 | |
paul@0 | 192 | uint8_t |
paul@0 | 193 | Cpm_jz4730_chip::get_source_divider() |
paul@0 | 194 | { |
paul@0 | 195 | return 1; |
paul@0 | 196 | } |
paul@0 | 197 | |
paul@0 | 198 | // LCD device clock divider. |
paul@0 | 199 | |
paul@0 | 200 | void |
paul@0 | 201 | Cpm_jz4730_chip::set_lcd_device_divider(uint8_t division) |
paul@0 | 202 | { |
paul@0 | 203 | if (division == 0) |
paul@0 | 204 | division = 1; |
paul@0 | 205 | |
paul@0 | 206 | // NOTE: The vendor code (clock.c) bounds the divider at 16, but maybe this is |
paul@0 | 207 | // NOTE: confused with the width of the bitfield which actually contains an |
paul@0 | 208 | // NOTE: index for the clock divider value array (cd). |
paul@0 | 209 | |
paul@0 | 210 | else if (division > 16) |
paul@0 | 211 | division = 16; |
paul@0 | 212 | |
paul@0 | 213 | // Obtain the divider or closest higher divider. |
paul@0 | 214 | |
paul@0 | 215 | int i; |
paul@0 | 216 | |
paul@0 | 217 | for (i = 0; i < 10; i++) |
paul@0 | 218 | if (cd[i] >= division) break; |
paul@0 | 219 | |
paul@0 | 220 | _regs[Clock_control] = (_regs[Clock_control] & ~(0xf << Clock_lcd_divider)) | |
paul@0 | 221 | (cd[i] << Clock_lcd_divider); |
paul@0 | 222 | } |
paul@0 | 223 | |
paul@0 | 224 | // LCD pixel clock divider. |
paul@0 | 225 | |
paul@0 | 226 | uint16_t |
paul@0 | 227 | Cpm_jz4730_chip::get_lcd_pixel_divider() |
paul@0 | 228 | { |
paul@0 | 229 | return (_regs[Lcd_divider] >> Lcd_divider_value) + 1; |
paul@0 | 230 | } |
paul@0 | 231 | |
paul@0 | 232 | void |
paul@0 | 233 | Cpm_jz4730_chip::set_lcd_pixel_divider(uint16_t division) |
paul@0 | 234 | { |
paul@0 | 235 | if (division == 0) |
paul@0 | 236 | division = 1; |
paul@0 | 237 | else if (division > 512) |
paul@0 | 238 | division = 512; |
paul@0 | 239 | |
paul@0 | 240 | _regs[Lcd_divider] = (_regs[Lcd_divider] & ~(0x1ff << Lcd_divider_value)) | |
paul@0 | 241 | ((division - 1) << Lcd_divider_value); |
paul@0 | 242 | } |
paul@0 | 243 | |
paul@0 | 244 | |
paul@0 | 245 | |
paul@0 | 246 | uint32_t |
paul@0 | 247 | Cpm_jz4730_chip::get_lcd_pixel_frequency() |
paul@0 | 248 | { |
paul@0 | 249 | return get_output_frequency() / get_lcd_pixel_divider(); |
paul@0 | 250 | } |
paul@0 | 251 | |
paul@0 | 252 | // Set the device and pixel frequencies, indicating the latter and |
paul@0 | 253 | // providing the device:pixel frequency ratio. |
paul@0 | 254 | |
paul@0 | 255 | void |
paul@0 | 256 | Cpm_jz4730_chip::set_lcd_frequencies(uint32_t pclk, uint8_t ratio) |
paul@0 | 257 | { |
paul@0 | 258 | uint32_t out = get_output_frequency(), |
paul@0 | 259 | lcd = pclk * ratio; |
paul@0 | 260 | |
paul@0 | 261 | set_lcd_pixel_divider(out / pclk); |
paul@0 | 262 | |
paul@0 | 263 | // Limit the device frequency to 150MHz. |
paul@0 | 264 | |
paul@0 | 265 | if (lcd > 150000000) lcd = 150000000; |
paul@0 | 266 | |
paul@0 | 267 | set_lcd_device_divider(out / lcd); |
paul@0 | 268 | } |
paul@0 | 269 | |
paul@0 | 270 | |
paul@0 | 271 | |
paul@0 | 272 | // LCD clock control. |
paul@0 | 273 | |
paul@0 | 274 | void |
paul@0 | 275 | Cpm_jz4730_chip::start_lcd() |
paul@0 | 276 | { |
paul@0 | 277 | _regs[Clock_gate] = _regs[Clock_gate] & ~(1 << Clock_gate_lcd); |
paul@0 | 278 | } |
paul@0 | 279 | |
paul@0 | 280 | void |
paul@0 | 281 | Cpm_jz4730_chip::stop_lcd() |
paul@0 | 282 | { |
paul@0 | 283 | _regs[Clock_gate] = _regs[Clock_gate] | (1 << Clock_gate_lcd); |
paul@0 | 284 | } |
paul@0 | 285 | |
paul@0 | 286 | |
paul@0 | 287 | |
paul@0 | 288 | uint32_t |
paul@0 | 289 | Cpm_jz4730_chip::get_pll_frequency() |
paul@0 | 290 | { |
paul@0 | 291 | // Test for PLL enable and not PLL bypass. |
paul@0 | 292 | |
paul@0 | 293 | if (pll_enabled() && !pll_bypassed()) |
paul@0 | 294 | return (_exclk_freq * get_multiplier()) / |
paul@0 | 295 | (get_input_division() * get_output_division()); |
paul@0 | 296 | else |
paul@0 | 297 | return _exclk_freq; |
paul@0 | 298 | } |
paul@0 | 299 | |
paul@0 | 300 | // Clock frequency for MSC, I2S, LCD and USB. |
paul@0 | 301 | |
paul@0 | 302 | uint32_t |
paul@0 | 303 | Cpm_jz4730_chip::get_output_frequency() |
paul@0 | 304 | { |
paul@0 | 305 | return get_pll_frequency() / get_source_divider(); |
paul@0 | 306 | } |
paul@0 | 307 | |
paul@0 | 308 | void |
paul@0 | 309 | Cpm_jz4730_chip::update_output_frequency() |
paul@0 | 310 | { |
paul@0 | 311 | _regs[Clock_control] = _regs[Clock_control] | (1 << Clock_enable); |
paul@0 | 312 | } |
paul@0 | 313 | |
paul@0 | 314 | // Clock frequency for the CPU. |
paul@0 | 315 | |
paul@0 | 316 | uint32_t Cpm_jz4730_chip::get_cpu_frequency() |
paul@0 | 317 | { |
paul@0 | 318 | if (pll_enabled()) |
paul@0 | 319 | return get_pll_frequency() / get_cpu_divider(); |
paul@0 | 320 | else |
paul@0 | 321 | return _exclk_freq; |
paul@0 | 322 | } |
paul@0 | 323 | |
paul@0 | 324 | // Clock frequency for fast peripherals. |
paul@0 | 325 | |
paul@0 | 326 | uint32_t |
paul@0 | 327 | Cpm_jz4730_chip::get_hclock_frequency() |
paul@0 | 328 | { |
paul@0 | 329 | if (pll_enabled()) |
paul@0 | 330 | return get_pll_frequency() / get_hclock_divider(); |
paul@0 | 331 | else |
paul@0 | 332 | return _exclk_freq; |
paul@0 | 333 | } |
paul@0 | 334 | |
paul@0 | 335 | // Clock frequency for slow peripherals. |
paul@0 | 336 | |
paul@0 | 337 | uint32_t |
paul@0 | 338 | Cpm_jz4730_chip::get_pclock_frequency() |
paul@0 | 339 | { |
paul@0 | 340 | if (pll_enabled()) |
paul@0 | 341 | return get_pll_frequency() / get_pclock_divider(); |
paul@0 | 342 | else |
paul@0 | 343 | return _exclk_freq; |
paul@0 | 344 | } |
paul@0 | 345 | |
paul@0 | 346 | // Clock frequency for the memory. |
paul@0 | 347 | |
paul@0 | 348 | uint32_t |
paul@0 | 349 | Cpm_jz4730_chip::get_memory_frequency() |
paul@0 | 350 | { |
paul@0 | 351 | if (pll_enabled()) |
paul@0 | 352 | return get_pll_frequency() / get_memory_divider(); |
paul@0 | 353 | else |
paul@0 | 354 | return _exclk_freq; |
paul@0 | 355 | } |
paul@0 | 356 | |
paul@0 | 357 | |
paul@0 | 358 | |
paul@0 | 359 | // C language interface functions. |
paul@0 | 360 | |
paul@0 | 361 | void |
paul@0 | 362 | *jz4730_cpm_init(l4_addr_t cpm_base) |
paul@0 | 363 | { |
paul@0 | 364 | /* Initialise the clock and power management peripheral with the |
paul@0 | 365 | register memory region and a 3.6864 MHz EXCLK frequency. */ |
paul@0 | 366 | |
paul@0 | 367 | return (void *) new Cpm_jz4730_chip(cpm_base, 3686400); |
paul@0 | 368 | } |
paul@0 | 369 | |
paul@0 | 370 | int |
paul@0 | 371 | jz4730_cpm_have_clock(void *cpm) |
paul@0 | 372 | { |
paul@0 | 373 | return static_cast<Cpm_jz4730_chip *>(cpm)->have_clock(); |
paul@0 | 374 | } |
paul@0 | 375 | |
paul@0 | 376 | void |
paul@0 | 377 | jz4730_cpm_start_clock(void *cpm) |
paul@0 | 378 | { |
paul@0 | 379 | static_cast<Cpm_jz4730_chip *>(cpm)->start_clock(); |
paul@0 | 380 | } |
paul@0 | 381 | |
paul@0 | 382 | void |
paul@0 | 383 | jz4730_cpm_start_lcd(void *cpm) |
paul@0 | 384 | { |
paul@0 | 385 | static_cast<Cpm_jz4730_chip *>(cpm)->start_lcd(); |
paul@0 | 386 | } |
paul@0 | 387 | |
paul@0 | 388 | void |
paul@0 | 389 | jz4730_cpm_stop_lcd(void *cpm) |
paul@0 | 390 | { |
paul@0 | 391 | static_cast<Cpm_jz4730_chip *>(cpm)->stop_lcd(); |
paul@0 | 392 | } |
paul@0 | 393 | |
paul@0 | 394 | uint32_t |
paul@0 | 395 | jz4730_cpm_get_cpu_frequency(void *cpm) |
paul@0 | 396 | { |
paul@0 | 397 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_cpu_frequency(); |
paul@0 | 398 | } |
paul@0 | 399 | |
paul@0 | 400 | uint32_t |
paul@0 | 401 | jz4730_cpm_get_hclock_frequency(void *cpm) |
paul@0 | 402 | { |
paul@0 | 403 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_hclock_frequency(); |
paul@0 | 404 | } |
paul@0 | 405 | |
paul@0 | 406 | uint32_t |
paul@0 | 407 | jz4730_cpm_get_output_frequency(void *cpm) |
paul@0 | 408 | { |
paul@0 | 409 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_output_frequency(); |
paul@0 | 410 | } |
paul@0 | 411 | |
paul@0 | 412 | uint32_t |
paul@0 | 413 | jz4730_cpm_get_pclock_frequency(void *cpm) |
paul@0 | 414 | { |
paul@0 | 415 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_pclock_frequency(); |
paul@0 | 416 | } |
paul@0 | 417 | |
paul@0 | 418 | uint32_t |
paul@0 | 419 | jz4730_cpm_get_memory_frequency(void *cpm) |
paul@0 | 420 | { |
paul@0 | 421 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_memory_frequency(); |
paul@0 | 422 | } |
paul@0 | 423 | |
paul@0 | 424 | uint16_t |
paul@0 | 425 | jz4730_cpm_get_lcd_pixel_divider(void *cpm) |
paul@0 | 426 | { |
paul@0 | 427 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_lcd_pixel_divider(); |
paul@0 | 428 | } |
paul@0 | 429 | |
paul@0 | 430 | uint32_t |
paul@0 | 431 | jz4730_cpm_get_lcd_pixel_frequency(void *cpm) |
paul@0 | 432 | { |
paul@0 | 433 | return static_cast<Cpm_jz4730_chip *>(cpm)->get_lcd_pixel_frequency(); |
paul@0 | 434 | } |
paul@0 | 435 | |
paul@0 | 436 | void |
paul@0 | 437 | jz4730_cpm_set_lcd_frequencies(void *cpm, uint32_t pclk, uint8_t ratio) |
paul@0 | 438 | { |
paul@0 | 439 | static_cast<Cpm_jz4730_chip *>(cpm)->set_lcd_frequencies(pclk, ratio); |
paul@0 | 440 | } |
paul@0 | 441 | |
paul@0 | 442 | void |
paul@0 | 443 | jz4730_cpm_update_output_frequency(void *cpm) |
paul@0 | 444 | { |
paul@0 | 445 | static_cast<Cpm_jz4730_chip *>(cpm)->update_output_frequency(); |
paul@0 | 446 | } |