iotkit-sysctl.c (25540B)
1 /* 2 * ARM IoTKit system control element 3 * 4 * Copyright (c) 2018 Linaro Limited 5 * Written by Peter Maydell 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 or 9 * (at your option) any later version. 10 */ 11 12 /* 13 * This is a model of the "system control element" which is part of the 14 * Arm IoTKit and documented in 15 * https://developer.arm.com/documentation/ecm0601256/latest 16 * Specifically, it implements the "system control register" blocks. 17 */ 18 19 #include "qemu/osdep.h" 20 #include "qemu/bitops.h" 21 #include "qemu/log.h" 22 #include "qemu/module.h" 23 #include "sysemu/runstate.h" 24 #include "trace.h" 25 #include "qapi/error.h" 26 #include "hw/sysbus.h" 27 #include "migration/vmstate.h" 28 #include "hw/registerfields.h" 29 #include "hw/misc/iotkit-sysctl.h" 30 #include "hw/qdev-properties.h" 31 #include "hw/arm/armsse-version.h" 32 #include "target/arm/arm-powerctl.h" 33 #include "target/arm/cpu.h" 34 35 REG32(SECDBGSTAT, 0x0) 36 REG32(SECDBGSET, 0x4) 37 REG32(SECDBGCLR, 0x8) 38 REG32(SCSECCTRL, 0xc) 39 REG32(FCLK_DIV, 0x10) 40 REG32(SYSCLK_DIV, 0x14) 41 REG32(CLOCK_FORCE, 0x18) 42 REG32(RESET_SYNDROME, 0x100) 43 REG32(RESET_MASK, 0x104) 44 REG32(SWRESET, 0x108) 45 FIELD(SWRESET, SWRESETREQ, 9, 1) 46 REG32(GRETREG, 0x10c) 47 REG32(INITSVTOR0, 0x110) 48 FIELD(INITSVTOR0, LOCK, 0, 1) 49 FIELD(INITSVTOR0, VTOR, 7, 25) 50 REG32(INITSVTOR1, 0x114) 51 REG32(CPUWAIT, 0x118) 52 REG32(NMI_ENABLE, 0x11c) /* BUSWAIT in IoTKit */ 53 REG32(WICCTRL, 0x120) 54 REG32(EWCTRL, 0x124) 55 REG32(PWRCTRL, 0x1fc) 56 FIELD(PWRCTRL, PPU_ACCESS_UNLOCK, 0, 1) 57 FIELD(PWRCTRL, PPU_ACCESS_FILTER, 1, 1) 58 REG32(PDCM_PD_SYS_SENSE, 0x200) 59 REG32(PDCM_PD_CPU0_SENSE, 0x204) 60 REG32(PDCM_PD_SRAM0_SENSE, 0x20c) 61 REG32(PDCM_PD_SRAM1_SENSE, 0x210) 62 REG32(PDCM_PD_SRAM2_SENSE, 0x214) /* PDCM_PD_VMR0_SENSE on SSE300 */ 63 REG32(PDCM_PD_SRAM3_SENSE, 0x218) /* PDCM_PD_VMR1_SENSE on SSE300 */ 64 REG32(PID4, 0xfd0) 65 REG32(PID5, 0xfd4) 66 REG32(PID6, 0xfd8) 67 REG32(PID7, 0xfdc) 68 REG32(PID0, 0xfe0) 69 REG32(PID1, 0xfe4) 70 REG32(PID2, 0xfe8) 71 REG32(PID3, 0xfec) 72 REG32(CID0, 0xff0) 73 REG32(CID1, 0xff4) 74 REG32(CID2, 0xff8) 75 REG32(CID3, 0xffc) 76 77 /* PID/CID values */ 78 static const int iotkit_sysctl_id[] = { 79 0x04, 0x00, 0x00, 0x00, /* PID4..PID7 */ 80 0x54, 0xb8, 0x0b, 0x00, /* PID0..PID3 */ 81 0x0d, 0xf0, 0x05, 0xb1, /* CID0..CID3 */ 82 }; 83 84 /* Also used by the SSE300 */ 85 static const int sse200_sysctl_id[] = { 86 0x04, 0x00, 0x00, 0x00, /* PID4..PID7 */ 87 0x54, 0xb8, 0x1b, 0x00, /* PID0..PID3 */ 88 0x0d, 0xf0, 0x05, 0xb1, /* CID0..CID3 */ 89 }; 90 91 /* 92 * Set the initial secure vector table offset address for the core. 93 * This will take effect when the CPU next resets. 94 */ 95 static void set_init_vtor(uint64_t cpuid, uint32_t vtor) 96 { 97 Object *cpuobj = OBJECT(arm_get_cpu_by_id(cpuid)); 98 99 if (cpuobj) { 100 if (object_property_find(cpuobj, "init-svtor")) { 101 object_property_set_uint(cpuobj, "init-svtor", vtor, &error_abort); 102 } 103 } 104 } 105 106 static uint64_t iotkit_sysctl_read(void *opaque, hwaddr offset, 107 unsigned size) 108 { 109 IoTKitSysCtl *s = IOTKIT_SYSCTL(opaque); 110 uint64_t r; 111 112 switch (offset) { 113 case A_SECDBGSTAT: 114 r = s->secure_debug; 115 break; 116 case A_SCSECCTRL: 117 switch (s->sse_version) { 118 case ARMSSE_IOTKIT: 119 goto bad_offset; 120 case ARMSSE_SSE200: 121 case ARMSSE_SSE300: 122 r = s->scsecctrl; 123 break; 124 default: 125 g_assert_not_reached(); 126 } 127 break; 128 case A_FCLK_DIV: 129 switch (s->sse_version) { 130 case ARMSSE_IOTKIT: 131 goto bad_offset; 132 case ARMSSE_SSE200: 133 case ARMSSE_SSE300: 134 r = s->fclk_div; 135 break; 136 default: 137 g_assert_not_reached(); 138 } 139 break; 140 case A_SYSCLK_DIV: 141 switch (s->sse_version) { 142 case ARMSSE_IOTKIT: 143 goto bad_offset; 144 case ARMSSE_SSE200: 145 case ARMSSE_SSE300: 146 r = s->sysclk_div; 147 break; 148 default: 149 g_assert_not_reached(); 150 } 151 break; 152 case A_CLOCK_FORCE: 153 switch (s->sse_version) { 154 case ARMSSE_IOTKIT: 155 goto bad_offset; 156 case ARMSSE_SSE200: 157 case ARMSSE_SSE300: 158 r = s->clock_force; 159 break; 160 default: 161 g_assert_not_reached(); 162 } 163 break; 164 case A_RESET_SYNDROME: 165 r = s->reset_syndrome; 166 break; 167 case A_RESET_MASK: 168 r = s->reset_mask; 169 break; 170 case A_GRETREG: 171 r = s->gretreg; 172 break; 173 case A_INITSVTOR0: 174 r = s->initsvtor0; 175 break; 176 case A_INITSVTOR1: 177 switch (s->sse_version) { 178 case ARMSSE_IOTKIT: 179 goto bad_offset; 180 case ARMSSE_SSE200: 181 r = s->initsvtor1; 182 break; 183 case ARMSSE_SSE300: 184 goto bad_offset; 185 default: 186 g_assert_not_reached(); 187 } 188 break; 189 case A_CPUWAIT: 190 switch (s->sse_version) { 191 case ARMSSE_IOTKIT: 192 case ARMSSE_SSE200: 193 r = s->cpuwait; 194 break; 195 case ARMSSE_SSE300: 196 /* In SSE300 this is reserved (for INITSVTOR2) */ 197 goto bad_offset; 198 default: 199 g_assert_not_reached(); 200 } 201 break; 202 case A_NMI_ENABLE: 203 switch (s->sse_version) { 204 case ARMSSE_IOTKIT: 205 /* In IoTKit this is named BUSWAIT but marked reserved, R/O, zero */ 206 r = 0; 207 break; 208 case ARMSSE_SSE200: 209 r = s->nmi_enable; 210 break; 211 case ARMSSE_SSE300: 212 /* In SSE300 this is reserved (for INITSVTOR3) */ 213 goto bad_offset; 214 default: 215 g_assert_not_reached(); 216 } 217 break; 218 case A_WICCTRL: 219 switch (s->sse_version) { 220 case ARMSSE_IOTKIT: 221 case ARMSSE_SSE200: 222 r = s->wicctrl; 223 break; 224 case ARMSSE_SSE300: 225 /* In SSE300 this offset is CPUWAIT */ 226 r = s->cpuwait; 227 break; 228 default: 229 g_assert_not_reached(); 230 } 231 break; 232 case A_EWCTRL: 233 switch (s->sse_version) { 234 case ARMSSE_IOTKIT: 235 goto bad_offset; 236 case ARMSSE_SSE200: 237 r = s->ewctrl; 238 break; 239 case ARMSSE_SSE300: 240 /* In SSE300 this offset is NMI_ENABLE */ 241 r = s->nmi_enable; 242 break; 243 default: 244 g_assert_not_reached(); 245 } 246 break; 247 case A_PWRCTRL: 248 switch (s->sse_version) { 249 case ARMSSE_IOTKIT: 250 case ARMSSE_SSE200: 251 goto bad_offset; 252 case ARMSSE_SSE300: 253 r = s->pwrctrl; 254 break; 255 default: 256 g_assert_not_reached(); 257 } 258 break; 259 case A_PDCM_PD_SYS_SENSE: 260 switch (s->sse_version) { 261 case ARMSSE_IOTKIT: 262 goto bad_offset; 263 case ARMSSE_SSE200: 264 case ARMSSE_SSE300: 265 r = s->pdcm_pd_sys_sense; 266 break; 267 default: 268 g_assert_not_reached(); 269 } 270 break; 271 case A_PDCM_PD_CPU0_SENSE: 272 switch (s->sse_version) { 273 case ARMSSE_IOTKIT: 274 case ARMSSE_SSE200: 275 goto bad_offset; 276 case ARMSSE_SSE300: 277 r = s->pdcm_pd_cpu0_sense; 278 break; 279 default: 280 g_assert_not_reached(); 281 } 282 break; 283 case A_PDCM_PD_SRAM0_SENSE: 284 switch (s->sse_version) { 285 case ARMSSE_IOTKIT: 286 goto bad_offset; 287 case ARMSSE_SSE200: 288 r = s->pdcm_pd_sram0_sense; 289 break; 290 case ARMSSE_SSE300: 291 goto bad_offset; 292 default: 293 g_assert_not_reached(); 294 } 295 break; 296 case A_PDCM_PD_SRAM1_SENSE: 297 switch (s->sse_version) { 298 case ARMSSE_IOTKIT: 299 goto bad_offset; 300 case ARMSSE_SSE200: 301 r = s->pdcm_pd_sram1_sense; 302 break; 303 case ARMSSE_SSE300: 304 goto bad_offset; 305 default: 306 g_assert_not_reached(); 307 } 308 break; 309 case A_PDCM_PD_SRAM2_SENSE: 310 switch (s->sse_version) { 311 case ARMSSE_IOTKIT: 312 goto bad_offset; 313 case ARMSSE_SSE200: 314 r = s->pdcm_pd_sram2_sense; 315 break; 316 case ARMSSE_SSE300: 317 r = s->pdcm_pd_vmr0_sense; 318 break; 319 default: 320 g_assert_not_reached(); 321 } 322 break; 323 case A_PDCM_PD_SRAM3_SENSE: 324 switch (s->sse_version) { 325 case ARMSSE_IOTKIT: 326 goto bad_offset; 327 case ARMSSE_SSE200: 328 r = s->pdcm_pd_sram3_sense; 329 break; 330 case ARMSSE_SSE300: 331 r = s->pdcm_pd_vmr1_sense; 332 break; 333 default: 334 g_assert_not_reached(); 335 } 336 break; 337 case A_PID4 ... A_CID3: 338 switch (s->sse_version) { 339 case ARMSSE_IOTKIT: 340 r = iotkit_sysctl_id[(offset - A_PID4) / 4]; 341 break; 342 case ARMSSE_SSE200: 343 case ARMSSE_SSE300: 344 r = sse200_sysctl_id[(offset - A_PID4) / 4]; 345 break; 346 default: 347 g_assert_not_reached(); 348 } 349 break; 350 case A_SECDBGSET: 351 case A_SECDBGCLR: 352 case A_SWRESET: 353 qemu_log_mask(LOG_GUEST_ERROR, 354 "IoTKit SysCtl read: read of WO offset %x\n", 355 (int)offset); 356 r = 0; 357 break; 358 default: 359 bad_offset: 360 qemu_log_mask(LOG_GUEST_ERROR, 361 "IoTKit SysCtl read: bad offset %x\n", (int)offset); 362 r = 0; 363 break; 364 } 365 trace_iotkit_sysctl_read(offset, r, size); 366 return r; 367 } 368 369 static void cpuwait_write(IoTKitSysCtl *s, uint32_t value) 370 { 371 int num_cpus = (s->sse_version == ARMSSE_SSE300) ? 1 : 2; 372 int i; 373 374 for (i = 0; i < num_cpus; i++) { 375 uint32_t mask = 1 << i; 376 if ((s->cpuwait & mask) && !(value & mask)) { 377 /* Powering up CPU 0 */ 378 arm_set_cpu_on_and_reset(i); 379 } 380 } 381 s->cpuwait = value; 382 } 383 384 static void iotkit_sysctl_write(void *opaque, hwaddr offset, 385 uint64_t value, unsigned size) 386 { 387 IoTKitSysCtl *s = IOTKIT_SYSCTL(opaque); 388 389 trace_iotkit_sysctl_write(offset, value, size); 390 391 /* 392 * Most of the state here has to do with control of reset and 393 * similar kinds of power up -- for instance the guest can ask 394 * what the reason for the last reset was, or forbid reset for 395 * some causes (like the non-secure watchdog). Most of this is 396 * not relevant to QEMU, which doesn't really model anything other 397 * than a full power-on reset. 398 * We just model the registers as reads-as-written. 399 */ 400 401 switch (offset) { 402 case A_RESET_SYNDROME: 403 qemu_log_mask(LOG_UNIMP, 404 "IoTKit SysCtl RESET_SYNDROME unimplemented\n"); 405 s->reset_syndrome = value; 406 break; 407 case A_RESET_MASK: 408 qemu_log_mask(LOG_UNIMP, "IoTKit SysCtl RESET_MASK unimplemented\n"); 409 s->reset_mask = value; 410 break; 411 case A_GRETREG: 412 /* 413 * General retention register, which is only reset by a power-on 414 * reset. Technically this implementation is complete, since 415 * QEMU only supports power-on resets... 416 */ 417 s->gretreg = value; 418 break; 419 case A_INITSVTOR0: 420 switch (s->sse_version) { 421 case ARMSSE_SSE300: 422 /* SSE300 has a LOCK bit which prevents further writes when set */ 423 if (s->initsvtor0 & R_INITSVTOR0_LOCK_MASK) { 424 qemu_log_mask(LOG_GUEST_ERROR, 425 "IoTKit INITSVTOR0 write when register locked\n"); 426 break; 427 } 428 s->initsvtor0 = value; 429 set_init_vtor(0, s->initsvtor0 & R_INITSVTOR0_VTOR_MASK); 430 break; 431 case ARMSSE_IOTKIT: 432 case ARMSSE_SSE200: 433 s->initsvtor0 = value; 434 set_init_vtor(0, s->initsvtor0); 435 break; 436 default: 437 g_assert_not_reached(); 438 } 439 break; 440 case A_CPUWAIT: 441 switch (s->sse_version) { 442 case ARMSSE_IOTKIT: 443 case ARMSSE_SSE200: 444 cpuwait_write(s, value); 445 break; 446 case ARMSSE_SSE300: 447 /* In SSE300 this is reserved (for INITSVTOR2) */ 448 goto bad_offset; 449 default: 450 g_assert_not_reached(); 451 } 452 break; 453 case A_WICCTRL: 454 switch (s->sse_version) { 455 case ARMSSE_IOTKIT: 456 case ARMSSE_SSE200: 457 qemu_log_mask(LOG_UNIMP, "IoTKit SysCtl WICCTRL unimplemented\n"); 458 s->wicctrl = value; 459 break; 460 case ARMSSE_SSE300: 461 /* In SSE300 this offset is CPUWAIT */ 462 cpuwait_write(s, value); 463 break; 464 default: 465 g_assert_not_reached(); 466 } 467 break; 468 case A_SECDBGSET: 469 /* write-1-to-set */ 470 qemu_log_mask(LOG_UNIMP, "IoTKit SysCtl SECDBGSET unimplemented\n"); 471 s->secure_debug |= value; 472 break; 473 case A_SECDBGCLR: 474 /* write-1-to-clear */ 475 s->secure_debug &= ~value; 476 break; 477 case A_SWRESET: 478 /* One w/o bit to request a reset; all other bits reserved */ 479 if (value & R_SWRESET_SWRESETREQ_MASK) { 480 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET); 481 } 482 break; 483 case A_SCSECCTRL: 484 switch (s->sse_version) { 485 case ARMSSE_IOTKIT: 486 goto bad_offset; 487 case ARMSSE_SSE200: 488 case ARMSSE_SSE300: 489 qemu_log_mask(LOG_UNIMP, "IoTKit SysCtl SCSECCTRL unimplemented\n"); 490 s->scsecctrl = value; 491 break; 492 default: 493 g_assert_not_reached(); 494 } 495 break; 496 case A_FCLK_DIV: 497 switch (s->sse_version) { 498 case ARMSSE_IOTKIT: 499 goto bad_offset; 500 case ARMSSE_SSE200: 501 case ARMSSE_SSE300: 502 qemu_log_mask(LOG_UNIMP, "IoTKit SysCtl FCLK_DIV unimplemented\n"); 503 s->fclk_div = value; 504 break; 505 default: 506 g_assert_not_reached(); 507 } 508 break; 509 case A_SYSCLK_DIV: 510 switch (s->sse_version) { 511 case ARMSSE_IOTKIT: 512 goto bad_offset; 513 case ARMSSE_SSE200: 514 case ARMSSE_SSE300: 515 qemu_log_mask(LOG_UNIMP, "IoTKit SysCtl SYSCLK_DIV unimplemented\n"); 516 s->sysclk_div = value; 517 break; 518 default: 519 g_assert_not_reached(); 520 } 521 break; 522 case A_CLOCK_FORCE: 523 switch (s->sse_version) { 524 case ARMSSE_IOTKIT: 525 goto bad_offset; 526 case ARMSSE_SSE200: 527 case ARMSSE_SSE300: 528 qemu_log_mask(LOG_UNIMP, "IoTKit SysCtl CLOCK_FORCE unimplemented\n"); 529 s->clock_force = value; 530 break; 531 default: 532 g_assert_not_reached(); 533 } 534 break; 535 case A_INITSVTOR1: 536 switch (s->sse_version) { 537 case ARMSSE_IOTKIT: 538 goto bad_offset; 539 case ARMSSE_SSE200: 540 s->initsvtor1 = value; 541 set_init_vtor(1, s->initsvtor1); 542 break; 543 case ARMSSE_SSE300: 544 goto bad_offset; 545 default: 546 g_assert_not_reached(); 547 } 548 break; 549 case A_EWCTRL: 550 switch (s->sse_version) { 551 case ARMSSE_IOTKIT: 552 goto bad_offset; 553 case ARMSSE_SSE200: 554 qemu_log_mask(LOG_UNIMP, "IoTKit SysCtl EWCTRL unimplemented\n"); 555 s->ewctrl = value; 556 break; 557 case ARMSSE_SSE300: 558 /* In SSE300 this offset is NMI_ENABLE */ 559 qemu_log_mask(LOG_UNIMP, "IoTKit SysCtl NMI_ENABLE unimplemented\n"); 560 s->nmi_enable = value; 561 break; 562 default: 563 g_assert_not_reached(); 564 } 565 break; 566 case A_PWRCTRL: 567 switch (s->sse_version) { 568 case ARMSSE_IOTKIT: 569 case ARMSSE_SSE200: 570 goto bad_offset; 571 case ARMSSE_SSE300: 572 if (!(s->pwrctrl & R_PWRCTRL_PPU_ACCESS_UNLOCK_MASK)) { 573 qemu_log_mask(LOG_GUEST_ERROR, 574 "IoTKit PWRCTRL write when register locked\n"); 575 break; 576 } 577 s->pwrctrl = value; 578 break; 579 default: 580 g_assert_not_reached(); 581 } 582 break; 583 case A_PDCM_PD_SYS_SENSE: 584 switch (s->sse_version) { 585 case ARMSSE_IOTKIT: 586 goto bad_offset; 587 case ARMSSE_SSE200: 588 case ARMSSE_SSE300: 589 qemu_log_mask(LOG_UNIMP, 590 "IoTKit SysCtl PDCM_PD_SYS_SENSE unimplemented\n"); 591 s->pdcm_pd_sys_sense = value; 592 break; 593 default: 594 g_assert_not_reached(); 595 } 596 break; 597 case A_PDCM_PD_CPU0_SENSE: 598 switch (s->sse_version) { 599 case ARMSSE_IOTKIT: 600 case ARMSSE_SSE200: 601 goto bad_offset; 602 case ARMSSE_SSE300: 603 qemu_log_mask(LOG_UNIMP, 604 "IoTKit SysCtl PDCM_PD_CPU0_SENSE unimplemented\n"); 605 s->pdcm_pd_cpu0_sense = value; 606 break; 607 default: 608 g_assert_not_reached(); 609 } 610 break; 611 case A_PDCM_PD_SRAM0_SENSE: 612 switch (s->sse_version) { 613 case ARMSSE_IOTKIT: 614 goto bad_offset; 615 case ARMSSE_SSE200: 616 qemu_log_mask(LOG_UNIMP, 617 "IoTKit SysCtl PDCM_PD_SRAM0_SENSE unimplemented\n"); 618 s->pdcm_pd_sram0_sense = value; 619 break; 620 case ARMSSE_SSE300: 621 goto bad_offset; 622 default: 623 g_assert_not_reached(); 624 } 625 break; 626 case A_PDCM_PD_SRAM1_SENSE: 627 switch (s->sse_version) { 628 case ARMSSE_IOTKIT: 629 goto bad_offset; 630 case ARMSSE_SSE200: 631 qemu_log_mask(LOG_UNIMP, 632 "IoTKit SysCtl PDCM_PD_SRAM1_SENSE unimplemented\n"); 633 s->pdcm_pd_sram1_sense = value; 634 break; 635 case ARMSSE_SSE300: 636 goto bad_offset; 637 default: 638 g_assert_not_reached(); 639 } 640 break; 641 case A_PDCM_PD_SRAM2_SENSE: 642 switch (s->sse_version) { 643 case ARMSSE_IOTKIT: 644 goto bad_offset; 645 case ARMSSE_SSE200: 646 qemu_log_mask(LOG_UNIMP, 647 "IoTKit SysCtl PDCM_PD_SRAM2_SENSE unimplemented\n"); 648 s->pdcm_pd_sram2_sense = value; 649 break; 650 case ARMSSE_SSE300: 651 qemu_log_mask(LOG_UNIMP, 652 "IoTKit SysCtl PDCM_PD_VMR0_SENSE unimplemented\n"); 653 s->pdcm_pd_vmr0_sense = value; 654 break; 655 default: 656 g_assert_not_reached(); 657 } 658 break; 659 case A_PDCM_PD_SRAM3_SENSE: 660 switch (s->sse_version) { 661 case ARMSSE_IOTKIT: 662 goto bad_offset; 663 case ARMSSE_SSE200: 664 qemu_log_mask(LOG_UNIMP, 665 "IoTKit SysCtl PDCM_PD_SRAM3_SENSE unimplemented\n"); 666 s->pdcm_pd_sram3_sense = value; 667 break; 668 case ARMSSE_SSE300: 669 qemu_log_mask(LOG_UNIMP, 670 "IoTKit SysCtl PDCM_PD_VMR1_SENSE unimplemented\n"); 671 s->pdcm_pd_vmr1_sense = value; 672 break; 673 default: 674 g_assert_not_reached(); 675 } 676 break; 677 case A_NMI_ENABLE: 678 /* In IoTKit this is BUSWAIT: reserved, R/O, zero */ 679 switch (s->sse_version) { 680 case ARMSSE_IOTKIT: 681 goto ro_offset; 682 case ARMSSE_SSE200: 683 qemu_log_mask(LOG_UNIMP, "IoTKit SysCtl NMI_ENABLE unimplemented\n"); 684 s->nmi_enable = value; 685 break; 686 case ARMSSE_SSE300: 687 /* In SSE300 this is reserved (for INITSVTOR3) */ 688 goto bad_offset; 689 default: 690 g_assert_not_reached(); 691 } 692 break; 693 case A_SECDBGSTAT: 694 case A_PID4 ... A_CID3: 695 ro_offset: 696 qemu_log_mask(LOG_GUEST_ERROR, 697 "IoTKit SysCtl write: write of RO offset %x\n", 698 (int)offset); 699 break; 700 default: 701 bad_offset: 702 qemu_log_mask(LOG_GUEST_ERROR, 703 "IoTKit SysCtl write: bad offset %x\n", (int)offset); 704 break; 705 } 706 } 707 708 static const MemoryRegionOps iotkit_sysctl_ops = { 709 .read = iotkit_sysctl_read, 710 .write = iotkit_sysctl_write, 711 .endianness = DEVICE_LITTLE_ENDIAN, 712 /* byte/halfword accesses are just zero-padded on reads and writes */ 713 .impl.min_access_size = 4, 714 .impl.max_access_size = 4, 715 .valid.min_access_size = 1, 716 .valid.max_access_size = 4, 717 }; 718 719 static void iotkit_sysctl_reset(DeviceState *dev) 720 { 721 IoTKitSysCtl *s = IOTKIT_SYSCTL(dev); 722 723 trace_iotkit_sysctl_reset(); 724 s->secure_debug = 0; 725 s->reset_syndrome = 1; 726 s->reset_mask = 0; 727 s->gretreg = 0; 728 s->initsvtor0 = s->initsvtor0_rst; 729 s->initsvtor1 = s->initsvtor1_rst; 730 s->cpuwait = s->cpuwait_rst; 731 s->wicctrl = 0; 732 s->scsecctrl = 0; 733 s->fclk_div = 0; 734 s->sysclk_div = 0; 735 s->clock_force = 0; 736 s->nmi_enable = 0; 737 s->ewctrl = 0; 738 s->pwrctrl = 0x3; 739 s->pdcm_pd_sys_sense = 0x7f; 740 s->pdcm_pd_sram0_sense = 0; 741 s->pdcm_pd_sram1_sense = 0; 742 s->pdcm_pd_sram2_sense = 0; 743 s->pdcm_pd_sram3_sense = 0; 744 s->pdcm_pd_cpu0_sense = 0; 745 s->pdcm_pd_vmr0_sense = 0; 746 s->pdcm_pd_vmr1_sense = 0; 747 } 748 749 static void iotkit_sysctl_init(Object *obj) 750 { 751 SysBusDevice *sbd = SYS_BUS_DEVICE(obj); 752 IoTKitSysCtl *s = IOTKIT_SYSCTL(obj); 753 754 memory_region_init_io(&s->iomem, obj, &iotkit_sysctl_ops, 755 s, "iotkit-sysctl", 0x1000); 756 sysbus_init_mmio(sbd, &s->iomem); 757 } 758 759 static void iotkit_sysctl_realize(DeviceState *dev, Error **errp) 760 { 761 IoTKitSysCtl *s = IOTKIT_SYSCTL(dev); 762 763 if (!armsse_version_valid(s->sse_version)) { 764 error_setg(errp, "invalid sse-version value %d", s->sse_version); 765 return; 766 } 767 } 768 769 static bool sse300_needed(void *opaque) 770 { 771 IoTKitSysCtl *s = IOTKIT_SYSCTL(opaque); 772 773 return s->sse_version == ARMSSE_SSE300; 774 } 775 776 static const VMStateDescription iotkit_sysctl_sse300_vmstate = { 777 .name = "iotkit-sysctl/sse-300", 778 .version_id = 1, 779 .minimum_version_id = 1, 780 .needed = sse300_needed, 781 .fields = (VMStateField[]) { 782 VMSTATE_UINT32(pwrctrl, IoTKitSysCtl), 783 VMSTATE_UINT32(pdcm_pd_cpu0_sense, IoTKitSysCtl), 784 VMSTATE_UINT32(pdcm_pd_vmr0_sense, IoTKitSysCtl), 785 VMSTATE_UINT32(pdcm_pd_vmr1_sense, IoTKitSysCtl), 786 VMSTATE_END_OF_LIST() 787 } 788 }; 789 790 static bool sse200_needed(void *opaque) 791 { 792 IoTKitSysCtl *s = IOTKIT_SYSCTL(opaque); 793 794 return s->sse_version != ARMSSE_IOTKIT; 795 } 796 797 static const VMStateDescription iotkit_sysctl_sse200_vmstate = { 798 .name = "iotkit-sysctl/sse-200", 799 .version_id = 1, 800 .minimum_version_id = 1, 801 .needed = sse200_needed, 802 .fields = (VMStateField[]) { 803 VMSTATE_UINT32(scsecctrl, IoTKitSysCtl), 804 VMSTATE_UINT32(fclk_div, IoTKitSysCtl), 805 VMSTATE_UINT32(sysclk_div, IoTKitSysCtl), 806 VMSTATE_UINT32(clock_force, IoTKitSysCtl), 807 VMSTATE_UINT32(initsvtor1, IoTKitSysCtl), 808 VMSTATE_UINT32(nmi_enable, IoTKitSysCtl), 809 VMSTATE_UINT32(pdcm_pd_sys_sense, IoTKitSysCtl), 810 VMSTATE_UINT32(pdcm_pd_sram0_sense, IoTKitSysCtl), 811 VMSTATE_UINT32(pdcm_pd_sram1_sense, IoTKitSysCtl), 812 VMSTATE_UINT32(pdcm_pd_sram2_sense, IoTKitSysCtl), 813 VMSTATE_UINT32(pdcm_pd_sram3_sense, IoTKitSysCtl), 814 VMSTATE_END_OF_LIST() 815 } 816 }; 817 818 static const VMStateDescription iotkit_sysctl_vmstate = { 819 .name = "iotkit-sysctl", 820 .version_id = 1, 821 .minimum_version_id = 1, 822 .fields = (VMStateField[]) { 823 VMSTATE_UINT32(secure_debug, IoTKitSysCtl), 824 VMSTATE_UINT32(reset_syndrome, IoTKitSysCtl), 825 VMSTATE_UINT32(reset_mask, IoTKitSysCtl), 826 VMSTATE_UINT32(gretreg, IoTKitSysCtl), 827 VMSTATE_UINT32(initsvtor0, IoTKitSysCtl), 828 VMSTATE_UINT32(cpuwait, IoTKitSysCtl), 829 VMSTATE_UINT32(wicctrl, IoTKitSysCtl), 830 VMSTATE_END_OF_LIST() 831 }, 832 .subsections = (const VMStateDescription*[]) { 833 &iotkit_sysctl_sse200_vmstate, 834 &iotkit_sysctl_sse300_vmstate, 835 NULL 836 } 837 }; 838 839 static Property iotkit_sysctl_props[] = { 840 DEFINE_PROP_UINT32("sse-version", IoTKitSysCtl, sse_version, 0), 841 DEFINE_PROP_UINT32("CPUWAIT_RST", IoTKitSysCtl, cpuwait_rst, 0), 842 DEFINE_PROP_UINT32("INITSVTOR0_RST", IoTKitSysCtl, initsvtor0_rst, 843 0x10000000), 844 DEFINE_PROP_UINT32("INITSVTOR1_RST", IoTKitSysCtl, initsvtor1_rst, 845 0x10000000), 846 DEFINE_PROP_END_OF_LIST() 847 }; 848 849 static void iotkit_sysctl_class_init(ObjectClass *klass, void *data) 850 { 851 DeviceClass *dc = DEVICE_CLASS(klass); 852 853 dc->vmsd = &iotkit_sysctl_vmstate; 854 dc->reset = iotkit_sysctl_reset; 855 device_class_set_props(dc, iotkit_sysctl_props); 856 dc->realize = iotkit_sysctl_realize; 857 } 858 859 static const TypeInfo iotkit_sysctl_info = { 860 .name = TYPE_IOTKIT_SYSCTL, 861 .parent = TYPE_SYS_BUS_DEVICE, 862 .instance_size = sizeof(IoTKitSysCtl), 863 .instance_init = iotkit_sysctl_init, 864 .class_init = iotkit_sysctl_class_init, 865 }; 866 867 static void iotkit_sysctl_register_types(void) 868 { 869 type_register_static(&iotkit_sysctl_info); 870 } 871 872 type_init(iotkit_sysctl_register_types);