2 * QEMU PowerPC 405 embedded processors emulation
4 * Copyright (c) 2007 Jocelyn Mayer
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu/osdep.h"
25 #include "qapi/error.h"
26 #include "qemu-common.h"
29 #include "hw/ppc/ppc.h"
30 #include "hw/boards.h"
31 #include "hw/i2c/ppc4xx_i2c.h"
33 #include "hw/char/serial.h"
34 #include "qemu/timer.h"
35 #include "sysemu/sysemu.h"
37 #include "exec/address-spaces.h"
42 //#define DEBUG_SERIAL
45 //#define DEBUG_CLOCKS
46 //#define DEBUG_CLOCKS_LL
48 ram_addr_t
ppc405_set_bootinfo (CPUPPCState
*env
, ppc4xx_bd_info_t
*bd
,
51 CPUState
*cs
= CPU(ppc_env_get_cpu(env
));
55 /* We put the bd structure at the top of memory */
56 if (bd
->bi_memsize
>= 0x01000000UL
)
57 bdloc
= 0x01000000UL
- sizeof(struct ppc4xx_bd_info_t
);
59 bdloc
= bd
->bi_memsize
- sizeof(struct ppc4xx_bd_info_t
);
60 stl_be_phys(cs
->as
, bdloc
+ 0x00, bd
->bi_memstart
);
61 stl_be_phys(cs
->as
, bdloc
+ 0x04, bd
->bi_memsize
);
62 stl_be_phys(cs
->as
, bdloc
+ 0x08, bd
->bi_flashstart
);
63 stl_be_phys(cs
->as
, bdloc
+ 0x0C, bd
->bi_flashsize
);
64 stl_be_phys(cs
->as
, bdloc
+ 0x10, bd
->bi_flashoffset
);
65 stl_be_phys(cs
->as
, bdloc
+ 0x14, bd
->bi_sramstart
);
66 stl_be_phys(cs
->as
, bdloc
+ 0x18, bd
->bi_sramsize
);
67 stl_be_phys(cs
->as
, bdloc
+ 0x1C, bd
->bi_bootflags
);
68 stl_be_phys(cs
->as
, bdloc
+ 0x20, bd
->bi_ipaddr
);
69 for (i
= 0; i
< 6; i
++) {
70 stb_phys(cs
->as
, bdloc
+ 0x24 + i
, bd
->bi_enetaddr
[i
]);
72 stw_be_phys(cs
->as
, bdloc
+ 0x2A, bd
->bi_ethspeed
);
73 stl_be_phys(cs
->as
, bdloc
+ 0x2C, bd
->bi_intfreq
);
74 stl_be_phys(cs
->as
, bdloc
+ 0x30, bd
->bi_busfreq
);
75 stl_be_phys(cs
->as
, bdloc
+ 0x34, bd
->bi_baudrate
);
76 for (i
= 0; i
< 4; i
++) {
77 stb_phys(cs
->as
, bdloc
+ 0x38 + i
, bd
->bi_s_version
[i
]);
79 for (i
= 0; i
< 32; i
++) {
80 stb_phys(cs
->as
, bdloc
+ 0x3C + i
, bd
->bi_r_version
[i
]);
82 stl_be_phys(cs
->as
, bdloc
+ 0x5C, bd
->bi_plb_busfreq
);
83 stl_be_phys(cs
->as
, bdloc
+ 0x60, bd
->bi_pci_busfreq
);
84 for (i
= 0; i
< 6; i
++) {
85 stb_phys(cs
->as
, bdloc
+ 0x64 + i
, bd
->bi_pci_enetaddr
[i
]);
88 if (flags
& 0x00000001) {
89 for (i
= 0; i
< 6; i
++)
90 stb_phys(cs
->as
, bdloc
+ n
++, bd
->bi_pci_enetaddr2
[i
]);
92 stl_be_phys(cs
->as
, bdloc
+ n
, bd
->bi_opbfreq
);
94 for (i
= 0; i
< 2; i
++) {
95 stl_be_phys(cs
->as
, bdloc
+ n
, bd
->bi_iic_fast
[i
]);
102 /*****************************************************************************/
103 /* Shared peripherals */
105 /*****************************************************************************/
106 /* Peripheral local bus arbitrer */
113 typedef struct ppc4xx_plb_t ppc4xx_plb_t
;
114 struct ppc4xx_plb_t
{
120 static uint32_t dcr_read_plb (void *opaque
, int dcrn
)
137 /* Avoid gcc warning */
145 static void dcr_write_plb (void *opaque
, int dcrn
, uint32_t val
)
152 /* We don't care about the actual parameters written as
153 * we don't manage any priorities on the bus
155 plb
->acr
= val
& 0xF8000000;
167 static void ppc4xx_plb_reset (void *opaque
)
172 plb
->acr
= 0x00000000;
173 plb
->bear
= 0x00000000;
174 plb
->besr
= 0x00000000;
177 void ppc4xx_plb_init(CPUPPCState
*env
)
181 plb
= g_malloc0(sizeof(ppc4xx_plb_t
));
182 ppc_dcr_register(env
, PLB0_ACR
, plb
, &dcr_read_plb
, &dcr_write_plb
);
183 ppc_dcr_register(env
, PLB0_BEAR
, plb
, &dcr_read_plb
, &dcr_write_plb
);
184 ppc_dcr_register(env
, PLB0_BESR
, plb
, &dcr_read_plb
, &dcr_write_plb
);
185 qemu_register_reset(ppc4xx_plb_reset
, plb
);
188 /*****************************************************************************/
189 /* PLB to OPB bridge */
196 typedef struct ppc4xx_pob_t ppc4xx_pob_t
;
197 struct ppc4xx_pob_t
{
203 static uint32_t dcr_read_pob (void *opaque
, int dcrn
)
220 /* Avoid gcc warning */
228 static void dcr_write_pob (void *opaque
, int dcrn
, uint32_t val
)
248 static void ppc4xx_pob_reset (void *opaque
)
254 pob
->bear
= 0x00000000;
255 pob
->besr0
= 0x0000000;
256 pob
->besr1
= 0x0000000;
259 static void ppc4xx_pob_init(CPUPPCState
*env
)
263 pob
= g_malloc0(sizeof(ppc4xx_pob_t
));
264 ppc_dcr_register(env
, POB0_BEAR
, pob
, &dcr_read_pob
, &dcr_write_pob
);
265 ppc_dcr_register(env
, POB0_BESR0
, pob
, &dcr_read_pob
, &dcr_write_pob
);
266 ppc_dcr_register(env
, POB0_BESR1
, pob
, &dcr_read_pob
, &dcr_write_pob
);
267 qemu_register_reset(ppc4xx_pob_reset
, pob
);
270 /*****************************************************************************/
272 typedef struct ppc4xx_opba_t ppc4xx_opba_t
;
273 struct ppc4xx_opba_t
{
279 static uint32_t opba_readb (void *opaque
, hwaddr addr
)
285 printf("%s: addr " TARGET_FMT_plx
"\n", __func__
, addr
);
303 static void opba_writeb (void *opaque
,
304 hwaddr addr
, uint32_t value
)
309 printf("%s: addr " TARGET_FMT_plx
" val %08" PRIx32
"\n", __func__
, addr
,
315 opba
->cr
= value
& 0xF8;
318 opba
->pr
= value
& 0xFF;
325 static uint32_t opba_readw (void *opaque
, hwaddr addr
)
330 printf("%s: addr " TARGET_FMT_plx
"\n", __func__
, addr
);
332 ret
= opba_readb(opaque
, addr
) << 8;
333 ret
|= opba_readb(opaque
, addr
+ 1);
338 static void opba_writew (void *opaque
,
339 hwaddr addr
, uint32_t value
)
342 printf("%s: addr " TARGET_FMT_plx
" val %08" PRIx32
"\n", __func__
, addr
,
345 opba_writeb(opaque
, addr
, value
>> 8);
346 opba_writeb(opaque
, addr
+ 1, value
);
349 static uint32_t opba_readl (void *opaque
, hwaddr addr
)
354 printf("%s: addr " TARGET_FMT_plx
"\n", __func__
, addr
);
356 ret
= opba_readb(opaque
, addr
) << 24;
357 ret
|= opba_readb(opaque
, addr
+ 1) << 16;
362 static void opba_writel (void *opaque
,
363 hwaddr addr
, uint32_t value
)
366 printf("%s: addr " TARGET_FMT_plx
" val %08" PRIx32
"\n", __func__
, addr
,
369 opba_writeb(opaque
, addr
, value
>> 24);
370 opba_writeb(opaque
, addr
+ 1, value
>> 16);
373 static const MemoryRegionOps opba_ops
= {
375 .read
= { opba_readb
, opba_readw
, opba_readl
, },
376 .write
= { opba_writeb
, opba_writew
, opba_writel
, },
378 .endianness
= DEVICE_NATIVE_ENDIAN
,
381 static void ppc4xx_opba_reset (void *opaque
)
386 opba
->cr
= 0x00; /* No dynamic priorities - park disabled */
390 static void ppc4xx_opba_init(hwaddr base
)
394 opba
= g_malloc0(sizeof(ppc4xx_opba_t
));
396 printf("%s: offset " TARGET_FMT_plx
"\n", __func__
, base
);
398 memory_region_init_io(&opba
->io
, NULL
, &opba_ops
, opba
, "opba", 0x002);
399 memory_region_add_subregion(get_system_memory(), base
, &opba
->io
);
400 qemu_register_reset(ppc4xx_opba_reset
, opba
);
403 /*****************************************************************************/
404 /* Code decompression controller */
407 /*****************************************************************************/
408 /* Peripheral controller */
409 typedef struct ppc4xx_ebc_t ppc4xx_ebc_t
;
410 struct ppc4xx_ebc_t
{
421 EBC0_CFGADDR
= 0x012,
422 EBC0_CFGDATA
= 0x013,
425 static uint32_t dcr_read_ebc (void *opaque
, int dcrn
)
437 case 0x00: /* B0CR */
440 case 0x01: /* B1CR */
443 case 0x02: /* B2CR */
446 case 0x03: /* B3CR */
449 case 0x04: /* B4CR */
452 case 0x05: /* B5CR */
455 case 0x06: /* B6CR */
458 case 0x07: /* B7CR */
461 case 0x10: /* B0AP */
464 case 0x11: /* B1AP */
467 case 0x12: /* B2AP */
470 case 0x13: /* B3AP */
473 case 0x14: /* B4AP */
476 case 0x15: /* B5AP */
479 case 0x16: /* B6AP */
482 case 0x17: /* B7AP */
485 case 0x20: /* BEAR */
488 case 0x21: /* BESR0 */
491 case 0x22: /* BESR1 */
510 static void dcr_write_ebc (void *opaque
, int dcrn
, uint32_t val
)
521 case 0x00: /* B0CR */
523 case 0x01: /* B1CR */
525 case 0x02: /* B2CR */
527 case 0x03: /* B3CR */
529 case 0x04: /* B4CR */
531 case 0x05: /* B5CR */
533 case 0x06: /* B6CR */
535 case 0x07: /* B7CR */
537 case 0x10: /* B0AP */
539 case 0x11: /* B1AP */
541 case 0x12: /* B2AP */
543 case 0x13: /* B3AP */
545 case 0x14: /* B4AP */
547 case 0x15: /* B5AP */
549 case 0x16: /* B6AP */
551 case 0x17: /* B7AP */
553 case 0x20: /* BEAR */
555 case 0x21: /* BESR0 */
557 case 0x22: /* BESR1 */
570 static void ebc_reset (void *opaque
)
576 ebc
->addr
= 0x00000000;
577 ebc
->bap
[0] = 0x7F8FFE80;
578 ebc
->bcr
[0] = 0xFFE28000;
579 for (i
= 0; i
< 8; i
++) {
580 ebc
->bap
[i
] = 0x00000000;
581 ebc
->bcr
[i
] = 0x00000000;
583 ebc
->besr0
= 0x00000000;
584 ebc
->besr1
= 0x00000000;
585 ebc
->cfg
= 0x80400000;
588 void ppc405_ebc_init(CPUPPCState
*env
)
592 ebc
= g_malloc0(sizeof(ppc4xx_ebc_t
));
593 qemu_register_reset(&ebc_reset
, ebc
);
594 ppc_dcr_register(env
, EBC0_CFGADDR
,
595 ebc
, &dcr_read_ebc
, &dcr_write_ebc
);
596 ppc_dcr_register(env
, EBC0_CFGDATA
,
597 ebc
, &dcr_read_ebc
, &dcr_write_ebc
);
600 /*****************************************************************************/
629 typedef struct ppc405_dma_t ppc405_dma_t
;
630 struct ppc405_dma_t
{
643 static uint32_t dcr_read_dma (void *opaque
, int dcrn
)
648 static void dcr_write_dma (void *opaque
, int dcrn
, uint32_t val
)
652 static void ppc405_dma_reset (void *opaque
)
658 for (i
= 0; i
< 4; i
++) {
659 dma
->cr
[i
] = 0x00000000;
660 dma
->ct
[i
] = 0x00000000;
661 dma
->da
[i
] = 0x00000000;
662 dma
->sa
[i
] = 0x00000000;
663 dma
->sg
[i
] = 0x00000000;
665 dma
->sr
= 0x00000000;
666 dma
->sgc
= 0x00000000;
667 dma
->slp
= 0x7C000000;
668 dma
->pol
= 0x00000000;
671 static void ppc405_dma_init(CPUPPCState
*env
, qemu_irq irqs
[4])
675 dma
= g_malloc0(sizeof(ppc405_dma_t
));
676 memcpy(dma
->irqs
, irqs
, 4 * sizeof(qemu_irq
));
677 qemu_register_reset(&ppc405_dma_reset
, dma
);
678 ppc_dcr_register(env
, DMA0_CR0
,
679 dma
, &dcr_read_dma
, &dcr_write_dma
);
680 ppc_dcr_register(env
, DMA0_CT0
,
681 dma
, &dcr_read_dma
, &dcr_write_dma
);
682 ppc_dcr_register(env
, DMA0_DA0
,
683 dma
, &dcr_read_dma
, &dcr_write_dma
);
684 ppc_dcr_register(env
, DMA0_SA0
,
685 dma
, &dcr_read_dma
, &dcr_write_dma
);
686 ppc_dcr_register(env
, DMA0_SG0
,
687 dma
, &dcr_read_dma
, &dcr_write_dma
);
688 ppc_dcr_register(env
, DMA0_CR1
,
689 dma
, &dcr_read_dma
, &dcr_write_dma
);
690 ppc_dcr_register(env
, DMA0_CT1
,
691 dma
, &dcr_read_dma
, &dcr_write_dma
);
692 ppc_dcr_register(env
, DMA0_DA1
,
693 dma
, &dcr_read_dma
, &dcr_write_dma
);
694 ppc_dcr_register(env
, DMA0_SA1
,
695 dma
, &dcr_read_dma
, &dcr_write_dma
);
696 ppc_dcr_register(env
, DMA0_SG1
,
697 dma
, &dcr_read_dma
, &dcr_write_dma
);
698 ppc_dcr_register(env
, DMA0_CR2
,
699 dma
, &dcr_read_dma
, &dcr_write_dma
);
700 ppc_dcr_register(env
, DMA0_CT2
,
701 dma
, &dcr_read_dma
, &dcr_write_dma
);
702 ppc_dcr_register(env
, DMA0_DA2
,
703 dma
, &dcr_read_dma
, &dcr_write_dma
);
704 ppc_dcr_register(env
, DMA0_SA2
,
705 dma
, &dcr_read_dma
, &dcr_write_dma
);
706 ppc_dcr_register(env
, DMA0_SG2
,
707 dma
, &dcr_read_dma
, &dcr_write_dma
);
708 ppc_dcr_register(env
, DMA0_CR3
,
709 dma
, &dcr_read_dma
, &dcr_write_dma
);
710 ppc_dcr_register(env
, DMA0_CT3
,
711 dma
, &dcr_read_dma
, &dcr_write_dma
);
712 ppc_dcr_register(env
, DMA0_DA3
,
713 dma
, &dcr_read_dma
, &dcr_write_dma
);
714 ppc_dcr_register(env
, DMA0_SA3
,
715 dma
, &dcr_read_dma
, &dcr_write_dma
);
716 ppc_dcr_register(env
, DMA0_SG3
,
717 dma
, &dcr_read_dma
, &dcr_write_dma
);
718 ppc_dcr_register(env
, DMA0_SR
,
719 dma
, &dcr_read_dma
, &dcr_write_dma
);
720 ppc_dcr_register(env
, DMA0_SGC
,
721 dma
, &dcr_read_dma
, &dcr_write_dma
);
722 ppc_dcr_register(env
, DMA0_SLP
,
723 dma
, &dcr_read_dma
, &dcr_write_dma
);
724 ppc_dcr_register(env
, DMA0_POL
,
725 dma
, &dcr_read_dma
, &dcr_write_dma
);
728 /*****************************************************************************/
730 typedef struct ppc405_gpio_t ppc405_gpio_t
;
731 struct ppc405_gpio_t
{
746 static uint32_t ppc405_gpio_readb (void *opaque
, hwaddr addr
)
749 printf("%s: addr " TARGET_FMT_plx
"\n", __func__
, addr
);
755 static void ppc405_gpio_writeb (void *opaque
,
756 hwaddr addr
, uint32_t value
)
759 printf("%s: addr " TARGET_FMT_plx
" val %08" PRIx32
"\n", __func__
, addr
,
764 static uint32_t ppc405_gpio_readw (void *opaque
, hwaddr addr
)
767 printf("%s: addr " TARGET_FMT_plx
"\n", __func__
, addr
);
773 static void ppc405_gpio_writew (void *opaque
,
774 hwaddr addr
, uint32_t value
)
777 printf("%s: addr " TARGET_FMT_plx
" val %08" PRIx32
"\n", __func__
, addr
,
782 static uint32_t ppc405_gpio_readl (void *opaque
, hwaddr addr
)
785 printf("%s: addr " TARGET_FMT_plx
"\n", __func__
, addr
);
791 static void ppc405_gpio_writel (void *opaque
,
792 hwaddr addr
, uint32_t value
)
795 printf("%s: addr " TARGET_FMT_plx
" val %08" PRIx32
"\n", __func__
, addr
,
800 static const MemoryRegionOps ppc405_gpio_ops
= {
802 .read
= { ppc405_gpio_readb
, ppc405_gpio_readw
, ppc405_gpio_readl
, },
803 .write
= { ppc405_gpio_writeb
, ppc405_gpio_writew
, ppc405_gpio_writel
, },
805 .endianness
= DEVICE_NATIVE_ENDIAN
,
808 static void ppc405_gpio_reset (void *opaque
)
812 static void ppc405_gpio_init(hwaddr base
)
816 gpio
= g_malloc0(sizeof(ppc405_gpio_t
));
818 printf("%s: offset " TARGET_FMT_plx
"\n", __func__
, base
);
820 memory_region_init_io(&gpio
->io
, NULL
, &ppc405_gpio_ops
, gpio
, "pgio", 0x038);
821 memory_region_add_subregion(get_system_memory(), base
, &gpio
->io
);
822 qemu_register_reset(&ppc405_gpio_reset
, gpio
);
825 /*****************************************************************************/
829 OCM0_ISACNTL
= 0x019,
831 OCM0_DSACNTL
= 0x01B,
834 typedef struct ppc405_ocm_t ppc405_ocm_t
;
835 struct ppc405_ocm_t
{
837 MemoryRegion isarc_ram
;
838 MemoryRegion dsarc_ram
;
845 static void ocm_update_mappings (ppc405_ocm_t
*ocm
,
846 uint32_t isarc
, uint32_t isacntl
,
847 uint32_t dsarc
, uint32_t dsacntl
)
850 printf("OCM update ISA %08" PRIx32
" %08" PRIx32
" (%08" PRIx32
851 " %08" PRIx32
") DSA %08" PRIx32
" %08" PRIx32
852 " (%08" PRIx32
" %08" PRIx32
")\n",
853 isarc
, isacntl
, dsarc
, dsacntl
,
854 ocm
->isarc
, ocm
->isacntl
, ocm
->dsarc
, ocm
->dsacntl
);
856 if (ocm
->isarc
!= isarc
||
857 (ocm
->isacntl
& 0x80000000) != (isacntl
& 0x80000000)) {
858 if (ocm
->isacntl
& 0x80000000) {
859 /* Unmap previously assigned memory region */
860 printf("OCM unmap ISA %08" PRIx32
"\n", ocm
->isarc
);
861 memory_region_del_subregion(get_system_memory(), &ocm
->isarc_ram
);
863 if (isacntl
& 0x80000000) {
864 /* Map new instruction memory region */
866 printf("OCM map ISA %08" PRIx32
"\n", isarc
);
868 memory_region_add_subregion(get_system_memory(), isarc
,
872 if (ocm
->dsarc
!= dsarc
||
873 (ocm
->dsacntl
& 0x80000000) != (dsacntl
& 0x80000000)) {
874 if (ocm
->dsacntl
& 0x80000000) {
875 /* Beware not to unmap the region we just mapped */
876 if (!(isacntl
& 0x80000000) || ocm
->dsarc
!= isarc
) {
877 /* Unmap previously assigned memory region */
879 printf("OCM unmap DSA %08" PRIx32
"\n", ocm
->dsarc
);
881 memory_region_del_subregion(get_system_memory(),
885 if (dsacntl
& 0x80000000) {
886 /* Beware not to remap the region we just mapped */
887 if (!(isacntl
& 0x80000000) || dsarc
!= isarc
) {
888 /* Map new data memory region */
890 printf("OCM map DSA %08" PRIx32
"\n", dsarc
);
892 memory_region_add_subregion(get_system_memory(), dsarc
,
899 static uint32_t dcr_read_ocm (void *opaque
, int dcrn
)
926 static void dcr_write_ocm (void *opaque
, int dcrn
, uint32_t val
)
929 uint32_t isarc
, dsarc
, isacntl
, dsacntl
;
934 isacntl
= ocm
->isacntl
;
935 dsacntl
= ocm
->dsacntl
;
938 isarc
= val
& 0xFC000000;
941 isacntl
= val
& 0xC0000000;
944 isarc
= val
& 0xFC000000;
947 isacntl
= val
& 0xC0000000;
950 ocm_update_mappings(ocm
, isarc
, isacntl
, dsarc
, dsacntl
);
953 ocm
->isacntl
= isacntl
;
954 ocm
->dsacntl
= dsacntl
;
957 static void ocm_reset (void *opaque
)
960 uint32_t isarc
, dsarc
, isacntl
, dsacntl
;
964 isacntl
= 0x00000000;
966 dsacntl
= 0x00000000;
967 ocm_update_mappings(ocm
, isarc
, isacntl
, dsarc
, dsacntl
);
970 ocm
->isacntl
= isacntl
;
971 ocm
->dsacntl
= dsacntl
;
974 static void ppc405_ocm_init(CPUPPCState
*env
)
978 ocm
= g_malloc0(sizeof(ppc405_ocm_t
));
979 /* XXX: Size is 4096 or 0x04000000 */
980 memory_region_init_ram(&ocm
->isarc_ram
, NULL
, "ppc405.ocm", 4096,
982 memory_region_init_alias(&ocm
->dsarc_ram
, NULL
, "ppc405.dsarc", &ocm
->isarc_ram
,
984 qemu_register_reset(&ocm_reset
, ocm
);
985 ppc_dcr_register(env
, OCM0_ISARC
,
986 ocm
, &dcr_read_ocm
, &dcr_write_ocm
);
987 ppc_dcr_register(env
, OCM0_ISACNTL
,
988 ocm
, &dcr_read_ocm
, &dcr_write_ocm
);
989 ppc_dcr_register(env
, OCM0_DSARC
,
990 ocm
, &dcr_read_ocm
, &dcr_write_ocm
);
991 ppc_dcr_register(env
, OCM0_DSACNTL
,
992 ocm
, &dcr_read_ocm
, &dcr_write_ocm
);
995 /*****************************************************************************/
996 /* General purpose timers */
997 typedef struct ppc4xx_gpt_t ppc4xx_gpt_t
;
998 struct ppc4xx_gpt_t
{
1013 static uint32_t ppc4xx_gpt_readb (void *opaque
, hwaddr addr
)
1016 printf("%s: addr " TARGET_FMT_plx
"\n", __func__
, addr
);
1018 /* XXX: generate a bus fault */
1022 static void ppc4xx_gpt_writeb (void *opaque
,
1023 hwaddr addr
, uint32_t value
)
1026 printf("%s: addr " TARGET_FMT_plx
" val %08" PRIx32
"\n", __func__
, addr
,
1029 /* XXX: generate a bus fault */
1032 static uint32_t ppc4xx_gpt_readw (void *opaque
, hwaddr addr
)
1035 printf("%s: addr " TARGET_FMT_plx
"\n", __func__
, addr
);
1037 /* XXX: generate a bus fault */
1041 static void ppc4xx_gpt_writew (void *opaque
,
1042 hwaddr addr
, uint32_t value
)
1045 printf("%s: addr " TARGET_FMT_plx
" val %08" PRIx32
"\n", __func__
, addr
,
1048 /* XXX: generate a bus fault */
1051 static int ppc4xx_gpt_compare (ppc4xx_gpt_t
*gpt
, int n
)
1057 static void ppc4xx_gpt_set_output (ppc4xx_gpt_t
*gpt
, int n
, int level
)
1062 static void ppc4xx_gpt_set_outputs (ppc4xx_gpt_t
*gpt
)
1068 for (i
= 0; i
< 5; i
++) {
1069 if (gpt
->oe
& mask
) {
1070 /* Output is enabled */
1071 if (ppc4xx_gpt_compare(gpt
, i
)) {
1072 /* Comparison is OK */
1073 ppc4xx_gpt_set_output(gpt
, i
, gpt
->ol
& mask
);
1075 /* Comparison is KO */
1076 ppc4xx_gpt_set_output(gpt
, i
, gpt
->ol
& mask
? 0 : 1);
1083 static void ppc4xx_gpt_set_irqs (ppc4xx_gpt_t
*gpt
)
1089 for (i
= 0; i
< 5; i
++) {
1090 if (gpt
->is
& gpt
->im
& mask
)
1091 qemu_irq_raise(gpt
->irqs
[i
]);
1093 qemu_irq_lower(gpt
->irqs
[i
]);
1098 static void ppc4xx_gpt_compute_timer (ppc4xx_gpt_t
*gpt
)
1103 static uint32_t ppc4xx_gpt_readl (void *opaque
, hwaddr addr
)
1110 printf("%s: addr " TARGET_FMT_plx
"\n", __func__
, addr
);
1115 /* Time base counter */
1116 ret
= muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + gpt
->tb_offset
,
1117 gpt
->tb_freq
, NANOSECONDS_PER_SECOND
);
1128 /* Interrupt mask */
1133 /* Interrupt status */
1137 /* Interrupt enable */
1142 idx
= (addr
- 0x80) >> 2;
1143 ret
= gpt
->comp
[idx
];
1147 idx
= (addr
- 0xC0) >> 2;
1148 ret
= gpt
->mask
[idx
];
1158 static void ppc4xx_gpt_writel (void *opaque
,
1159 hwaddr addr
, uint32_t value
)
1165 printf("%s: addr " TARGET_FMT_plx
" val %08" PRIx32
"\n", __func__
, addr
,
1171 /* Time base counter */
1172 gpt
->tb_offset
= muldiv64(value
, NANOSECONDS_PER_SECOND
, gpt
->tb_freq
)
1173 - qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
1174 ppc4xx_gpt_compute_timer(gpt
);
1178 gpt
->oe
= value
& 0xF8000000;
1179 ppc4xx_gpt_set_outputs(gpt
);
1183 gpt
->ol
= value
& 0xF8000000;
1184 ppc4xx_gpt_set_outputs(gpt
);
1187 /* Interrupt mask */
1188 gpt
->im
= value
& 0x0000F800;
1191 /* Interrupt status set */
1192 gpt
->is
|= value
& 0x0000F800;
1193 ppc4xx_gpt_set_irqs(gpt
);
1196 /* Interrupt status clear */
1197 gpt
->is
&= ~(value
& 0x0000F800);
1198 ppc4xx_gpt_set_irqs(gpt
);
1201 /* Interrupt enable */
1202 gpt
->ie
= value
& 0x0000F800;
1203 ppc4xx_gpt_set_irqs(gpt
);
1207 idx
= (addr
- 0x80) >> 2;
1208 gpt
->comp
[idx
] = value
& 0xF8000000;
1209 ppc4xx_gpt_compute_timer(gpt
);
1213 idx
= (addr
- 0xC0) >> 2;
1214 gpt
->mask
[idx
] = value
& 0xF8000000;
1215 ppc4xx_gpt_compute_timer(gpt
);
1220 static const MemoryRegionOps gpt_ops
= {
1222 .read
= { ppc4xx_gpt_readb
, ppc4xx_gpt_readw
, ppc4xx_gpt_readl
, },
1223 .write
= { ppc4xx_gpt_writeb
, ppc4xx_gpt_writew
, ppc4xx_gpt_writel
, },
1225 .endianness
= DEVICE_NATIVE_ENDIAN
,
1228 static void ppc4xx_gpt_cb (void *opaque
)
1233 ppc4xx_gpt_set_irqs(gpt
);
1234 ppc4xx_gpt_set_outputs(gpt
);
1235 ppc4xx_gpt_compute_timer(gpt
);
1238 static void ppc4xx_gpt_reset (void *opaque
)
1244 timer_del(gpt
->timer
);
1245 gpt
->oe
= 0x00000000;
1246 gpt
->ol
= 0x00000000;
1247 gpt
->im
= 0x00000000;
1248 gpt
->is
= 0x00000000;
1249 gpt
->ie
= 0x00000000;
1250 for (i
= 0; i
< 5; i
++) {
1251 gpt
->comp
[i
] = 0x00000000;
1252 gpt
->mask
[i
] = 0x00000000;
1256 static void ppc4xx_gpt_init(hwaddr base
, qemu_irq irqs
[5])
1261 gpt
= g_malloc0(sizeof(ppc4xx_gpt_t
));
1262 for (i
= 0; i
< 5; i
++) {
1263 gpt
->irqs
[i
] = irqs
[i
];
1265 gpt
->timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, &ppc4xx_gpt_cb
, gpt
);
1267 printf("%s: offset " TARGET_FMT_plx
"\n", __func__
, base
);
1269 memory_region_init_io(&gpt
->iomem
, NULL
, &gpt_ops
, gpt
, "gpt", 0x0d4);
1270 memory_region_add_subregion(get_system_memory(), base
, &gpt
->iomem
);
1271 qemu_register_reset(ppc4xx_gpt_reset
, gpt
);
1274 /*****************************************************************************/
1276 void ppc40x_core_reset(PowerPCCPU
*cpu
)
1278 CPUPPCState
*env
= &cpu
->env
;
1281 printf("Reset PowerPC core\n");
1282 cpu_interrupt(CPU(cpu
), CPU_INTERRUPT_RESET
);
1283 dbsr
= env
->spr
[SPR_40x_DBSR
];
1284 dbsr
&= ~0x00000300;
1286 env
->spr
[SPR_40x_DBSR
] = dbsr
;
1289 void ppc40x_chip_reset(PowerPCCPU
*cpu
)
1291 CPUPPCState
*env
= &cpu
->env
;
1294 printf("Reset PowerPC chip\n");
1295 cpu_interrupt(CPU(cpu
), CPU_INTERRUPT_RESET
);
1296 /* XXX: TODO reset all internal peripherals */
1297 dbsr
= env
->spr
[SPR_40x_DBSR
];
1298 dbsr
&= ~0x00000300;
1300 env
->spr
[SPR_40x_DBSR
] = dbsr
;
1303 void ppc40x_system_reset(PowerPCCPU
*cpu
)
1305 printf("Reset PowerPC system\n");
1306 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET
);
1309 void store_40x_dbcr0 (CPUPPCState
*env
, uint32_t val
)
1311 PowerPCCPU
*cpu
= ppc_env_get_cpu(env
);
1313 switch ((val
>> 28) & 0x3) {
1319 ppc40x_core_reset(cpu
);
1323 ppc40x_chip_reset(cpu
);
1327 ppc40x_system_reset(cpu
);
1332 /*****************************************************************************/
1335 PPC405CR_CPC0_PLLMR
= 0x0B0,
1336 PPC405CR_CPC0_CR0
= 0x0B1,
1337 PPC405CR_CPC0_CR1
= 0x0B2,
1338 PPC405CR_CPC0_PSR
= 0x0B4,
1339 PPC405CR_CPC0_JTAGID
= 0x0B5,
1340 PPC405CR_CPC0_ER
= 0x0B9,
1341 PPC405CR_CPC0_FR
= 0x0BA,
1342 PPC405CR_CPC0_SR
= 0x0BB,
1346 PPC405CR_CPU_CLK
= 0,
1347 PPC405CR_TMR_CLK
= 1,
1348 PPC405CR_PLB_CLK
= 2,
1349 PPC405CR_SDRAM_CLK
= 3,
1350 PPC405CR_OPB_CLK
= 4,
1351 PPC405CR_EXT_CLK
= 5,
1352 PPC405CR_UART_CLK
= 6,
1353 PPC405CR_CLK_NB
= 7,
1356 typedef struct ppc405cr_cpc_t ppc405cr_cpc_t
;
1357 struct ppc405cr_cpc_t
{
1358 clk_setup_t clk_setup
[PPC405CR_CLK_NB
];
1369 static void ppc405cr_clk_setup (ppc405cr_cpc_t
*cpc
)
1371 uint64_t VCO_out
, PLL_out
;
1372 uint32_t CPU_clk
, TMR_clk
, SDRAM_clk
, PLB_clk
, OPB_clk
, EXT_clk
, UART_clk
;
1375 D0
= ((cpc
->pllmr
>> 26) & 0x3) + 1; /* CBDV */
1376 if (cpc
->pllmr
& 0x80000000) {
1377 D1
= (((cpc
->pllmr
>> 20) - 1) & 0xF) + 1; /* FBDV */
1378 D2
= 8 - ((cpc
->pllmr
>> 16) & 0x7); /* FWDVA */
1380 VCO_out
= (uint64_t)cpc
->sysclk
* M
;
1381 if (VCO_out
< 400000000 || VCO_out
> 800000000) {
1382 /* PLL cannot lock */
1383 cpc
->pllmr
&= ~0x80000000;
1386 PLL_out
= VCO_out
/ D2
;
1391 PLL_out
= (uint64_t)cpc
->sysclk
* M
;
1394 if (cpc
->cr1
& 0x00800000)
1395 TMR_clk
= cpc
->sysclk
; /* Should have a separate clock */
1398 PLB_clk
= CPU_clk
/ D0
;
1399 SDRAM_clk
= PLB_clk
;
1400 D0
= ((cpc
->pllmr
>> 10) & 0x3) + 1;
1401 OPB_clk
= PLB_clk
/ D0
;
1402 D0
= ((cpc
->pllmr
>> 24) & 0x3) + 2;
1403 EXT_clk
= PLB_clk
/ D0
;
1404 D0
= ((cpc
->cr0
>> 1) & 0x1F) + 1;
1405 UART_clk
= CPU_clk
/ D0
;
1406 /* Setup CPU clocks */
1407 clk_setup(&cpc
->clk_setup
[PPC405CR_CPU_CLK
], CPU_clk
);
1408 /* Setup time-base clock */
1409 clk_setup(&cpc
->clk_setup
[PPC405CR_TMR_CLK
], TMR_clk
);
1410 /* Setup PLB clock */
1411 clk_setup(&cpc
->clk_setup
[PPC405CR_PLB_CLK
], PLB_clk
);
1412 /* Setup SDRAM clock */
1413 clk_setup(&cpc
->clk_setup
[PPC405CR_SDRAM_CLK
], SDRAM_clk
);
1414 /* Setup OPB clock */
1415 clk_setup(&cpc
->clk_setup
[PPC405CR_OPB_CLK
], OPB_clk
);
1416 /* Setup external clock */
1417 clk_setup(&cpc
->clk_setup
[PPC405CR_EXT_CLK
], EXT_clk
);
1418 /* Setup UART clock */
1419 clk_setup(&cpc
->clk_setup
[PPC405CR_UART_CLK
], UART_clk
);
1422 static uint32_t dcr_read_crcpc (void *opaque
, int dcrn
)
1424 ppc405cr_cpc_t
*cpc
;
1429 case PPC405CR_CPC0_PLLMR
:
1432 case PPC405CR_CPC0_CR0
:
1435 case PPC405CR_CPC0_CR1
:
1438 case PPC405CR_CPC0_PSR
:
1441 case PPC405CR_CPC0_JTAGID
:
1444 case PPC405CR_CPC0_ER
:
1447 case PPC405CR_CPC0_FR
:
1450 case PPC405CR_CPC0_SR
:
1451 ret
= ~(cpc
->er
| cpc
->fr
) & 0xFFFF0000;
1454 /* Avoid gcc warning */
1462 static void dcr_write_crcpc (void *opaque
, int dcrn
, uint32_t val
)
1464 ppc405cr_cpc_t
*cpc
;
1468 case PPC405CR_CPC0_PLLMR
:
1469 cpc
->pllmr
= val
& 0xFFF77C3F;
1471 case PPC405CR_CPC0_CR0
:
1472 cpc
->cr0
= val
& 0x0FFFFFFE;
1474 case PPC405CR_CPC0_CR1
:
1475 cpc
->cr1
= val
& 0x00800000;
1477 case PPC405CR_CPC0_PSR
:
1480 case PPC405CR_CPC0_JTAGID
:
1483 case PPC405CR_CPC0_ER
:
1484 cpc
->er
= val
& 0xBFFC0000;
1486 case PPC405CR_CPC0_FR
:
1487 cpc
->fr
= val
& 0xBFFC0000;
1489 case PPC405CR_CPC0_SR
:
1495 static void ppc405cr_cpc_reset (void *opaque
)
1497 ppc405cr_cpc_t
*cpc
;
1501 /* Compute PLLMR value from PSR settings */
1502 cpc
->pllmr
= 0x80000000;
1504 switch ((cpc
->psr
>> 30) & 3) {
1507 cpc
->pllmr
&= ~0x80000000;
1511 cpc
->pllmr
|= 5 << 16;
1515 cpc
->pllmr
|= 4 << 16;
1519 cpc
->pllmr
|= 2 << 16;
1523 D
= (cpc
->psr
>> 28) & 3;
1524 cpc
->pllmr
|= (D
+ 1) << 20;
1526 D
= (cpc
->psr
>> 25) & 7;
1541 D
= (cpc
->psr
>> 23) & 3;
1542 cpc
->pllmr
|= D
<< 26;
1544 D
= (cpc
->psr
>> 21) & 3;
1545 cpc
->pllmr
|= D
<< 10;
1547 D
= (cpc
->psr
>> 17) & 3;
1548 cpc
->pllmr
|= D
<< 24;
1549 cpc
->cr0
= 0x0000003C;
1550 cpc
->cr1
= 0x2B0D8800;
1551 cpc
->er
= 0x00000000;
1552 cpc
->fr
= 0x00000000;
1553 ppc405cr_clk_setup(cpc
);
1556 static void ppc405cr_clk_init (ppc405cr_cpc_t
*cpc
)
1560 /* XXX: this should be read from IO pins */
1561 cpc
->psr
= 0x00000000; /* 8 bits ROM */
1563 D
= 0x2; /* Divide by 4 */
1564 cpc
->psr
|= D
<< 30;
1566 D
= 0x1; /* Divide by 2 */
1567 cpc
->psr
|= D
<< 28;
1569 D
= 0x1; /* Divide by 2 */
1570 cpc
->psr
|= D
<< 23;
1572 D
= 0x5; /* M = 16 */
1573 cpc
->psr
|= D
<< 25;
1575 D
= 0x1; /* Divide by 2 */
1576 cpc
->psr
|= D
<< 21;
1578 D
= 0x2; /* Divide by 4 */
1579 cpc
->psr
|= D
<< 17;
1582 static void ppc405cr_cpc_init (CPUPPCState
*env
, clk_setup_t clk_setup
[7],
1585 ppc405cr_cpc_t
*cpc
;
1587 cpc
= g_malloc0(sizeof(ppc405cr_cpc_t
));
1588 memcpy(cpc
->clk_setup
, clk_setup
,
1589 PPC405CR_CLK_NB
* sizeof(clk_setup_t
));
1590 cpc
->sysclk
= sysclk
;
1591 cpc
->jtagid
= 0x42051049;
1592 ppc_dcr_register(env
, PPC405CR_CPC0_PSR
, cpc
,
1593 &dcr_read_crcpc
, &dcr_write_crcpc
);
1594 ppc_dcr_register(env
, PPC405CR_CPC0_CR0
, cpc
,
1595 &dcr_read_crcpc
, &dcr_write_crcpc
);
1596 ppc_dcr_register(env
, PPC405CR_CPC0_CR1
, cpc
,
1597 &dcr_read_crcpc
, &dcr_write_crcpc
);
1598 ppc_dcr_register(env
, PPC405CR_CPC0_JTAGID
, cpc
,
1599 &dcr_read_crcpc
, &dcr_write_crcpc
);
1600 ppc_dcr_register(env
, PPC405CR_CPC0_PLLMR
, cpc
,
1601 &dcr_read_crcpc
, &dcr_write_crcpc
);
1602 ppc_dcr_register(env
, PPC405CR_CPC0_ER
, cpc
,
1603 &dcr_read_crcpc
, &dcr_write_crcpc
);
1604 ppc_dcr_register(env
, PPC405CR_CPC0_FR
, cpc
,
1605 &dcr_read_crcpc
, &dcr_write_crcpc
);
1606 ppc_dcr_register(env
, PPC405CR_CPC0_SR
, cpc
,
1607 &dcr_read_crcpc
, &dcr_write_crcpc
);
1608 ppc405cr_clk_init(cpc
);
1609 qemu_register_reset(ppc405cr_cpc_reset
, cpc
);
1612 CPUPPCState
*ppc405cr_init(MemoryRegion
*address_space_mem
,
1613 MemoryRegion ram_memories
[4],
1614 hwaddr ram_bases
[4],
1615 hwaddr ram_sizes
[4],
1616 uint32_t sysclk
, qemu_irq
**picp
,
1619 clk_setup_t clk_setup
[PPC405CR_CLK_NB
];
1620 qemu_irq dma_irqs
[4];
1623 qemu_irq
*pic
, *irqs
;
1625 memset(clk_setup
, 0, sizeof(clk_setup
));
1626 cpu
= ppc4xx_init("405cr", &clk_setup
[PPC405CR_CPU_CLK
],
1627 &clk_setup
[PPC405CR_TMR_CLK
], sysclk
);
1629 /* Memory mapped devices registers */
1631 ppc4xx_plb_init(env
);
1632 /* PLB to OPB bridge */
1633 ppc4xx_pob_init(env
);
1635 ppc4xx_opba_init(0xef600600);
1636 /* Universal interrupt controller */
1637 irqs
= g_malloc0(sizeof(qemu_irq
) * PPCUIC_OUTPUT_NB
);
1638 irqs
[PPCUIC_OUTPUT_INT
] =
1639 ((qemu_irq
*)env
->irq_inputs
)[PPC40x_INPUT_INT
];
1640 irqs
[PPCUIC_OUTPUT_CINT
] =
1641 ((qemu_irq
*)env
->irq_inputs
)[PPC40x_INPUT_CINT
];
1642 pic
= ppcuic_init(env
, irqs
, 0x0C0, 0, 1);
1644 /* SDRAM controller */
1645 ppc4xx_sdram_init(env
, pic
[14], 1, ram_memories
,
1646 ram_bases
, ram_sizes
, do_init
);
1647 /* External bus controller */
1648 ppc405_ebc_init(env
);
1649 /* DMA controller */
1650 dma_irqs
[0] = pic
[26];
1651 dma_irqs
[1] = pic
[25];
1652 dma_irqs
[2] = pic
[24];
1653 dma_irqs
[3] = pic
[23];
1654 ppc405_dma_init(env
, dma_irqs
);
1656 if (serial_hds
[0] != NULL
) {
1657 serial_mm_init(address_space_mem
, 0xef600300, 0, pic
[0],
1658 PPC_SERIAL_MM_BAUDBASE
, serial_hds
[0],
1661 if (serial_hds
[1] != NULL
) {
1662 serial_mm_init(address_space_mem
, 0xef600400, 0, pic
[1],
1663 PPC_SERIAL_MM_BAUDBASE
, serial_hds
[1],
1666 /* IIC controller */
1667 sysbus_create_simple(TYPE_PPC4xx_I2C
, 0xef600500, pic
[2]);
1669 ppc405_gpio_init(0xef600700);
1671 ppc405cr_cpc_init(env
, clk_setup
, sysclk
);
1676 /*****************************************************************************/
1680 PPC405EP_CPC0_PLLMR0
= 0x0F0,
1681 PPC405EP_CPC0_BOOT
= 0x0F1,
1682 PPC405EP_CPC0_EPCTL
= 0x0F3,
1683 PPC405EP_CPC0_PLLMR1
= 0x0F4,
1684 PPC405EP_CPC0_UCR
= 0x0F5,
1685 PPC405EP_CPC0_SRR
= 0x0F6,
1686 PPC405EP_CPC0_JTAGID
= 0x0F7,
1687 PPC405EP_CPC0_PCI
= 0x0F9,
1689 PPC405EP_CPC0_ER
= xxx
,
1690 PPC405EP_CPC0_FR
= xxx
,
1691 PPC405EP_CPC0_SR
= xxx
,
1696 PPC405EP_CPU_CLK
= 0,
1697 PPC405EP_PLB_CLK
= 1,
1698 PPC405EP_OPB_CLK
= 2,
1699 PPC405EP_EBC_CLK
= 3,
1700 PPC405EP_MAL_CLK
= 4,
1701 PPC405EP_PCI_CLK
= 5,
1702 PPC405EP_UART0_CLK
= 6,
1703 PPC405EP_UART1_CLK
= 7,
1704 PPC405EP_CLK_NB
= 8,
1707 typedef struct ppc405ep_cpc_t ppc405ep_cpc_t
;
1708 struct ppc405ep_cpc_t
{
1710 clk_setup_t clk_setup
[PPC405EP_CLK_NB
];
1718 /* Clock and power management */
1724 static void ppc405ep_compute_clocks (ppc405ep_cpc_t
*cpc
)
1726 uint32_t CPU_clk
, PLB_clk
, OPB_clk
, EBC_clk
, MAL_clk
, PCI_clk
;
1727 uint32_t UART0_clk
, UART1_clk
;
1728 uint64_t VCO_out
, PLL_out
;
1732 if ((cpc
->pllmr
[1] & 0x80000000) && !(cpc
->pllmr
[1] & 0x40000000)) {
1733 M
= (((cpc
->pllmr
[1] >> 20) - 1) & 0xF) + 1; /* FBMUL */
1734 #ifdef DEBUG_CLOCKS_LL
1735 printf("FBMUL %01" PRIx32
" %d\n", (cpc
->pllmr
[1] >> 20) & 0xF, M
);
1737 D
= 8 - ((cpc
->pllmr
[1] >> 16) & 0x7); /* FWDA */
1738 #ifdef DEBUG_CLOCKS_LL
1739 printf("FWDA %01" PRIx32
" %d\n", (cpc
->pllmr
[1] >> 16) & 0x7, D
);
1741 VCO_out
= (uint64_t)cpc
->sysclk
* M
* D
;
1742 if (VCO_out
< 500000000UL || VCO_out
> 1000000000UL) {
1743 /* Error - unlock the PLL */
1744 printf("VCO out of range %" PRIu64
"\n", VCO_out
);
1746 cpc
->pllmr
[1] &= ~0x80000000;
1750 PLL_out
= VCO_out
/ D
;
1751 /* Pretend the PLL is locked */
1752 cpc
->boot
|= 0x00000001;
1757 PLL_out
= cpc
->sysclk
;
1758 if (cpc
->pllmr
[1] & 0x40000000) {
1759 /* Pretend the PLL is not locked */
1760 cpc
->boot
&= ~0x00000001;
1763 /* Now, compute all other clocks */
1764 D
= ((cpc
->pllmr
[0] >> 20) & 0x3) + 1; /* CCDV */
1765 #ifdef DEBUG_CLOCKS_LL
1766 printf("CCDV %01" PRIx32
" %d\n", (cpc
->pllmr
[0] >> 20) & 0x3, D
);
1768 CPU_clk
= PLL_out
/ D
;
1769 D
= ((cpc
->pllmr
[0] >> 16) & 0x3) + 1; /* CBDV */
1770 #ifdef DEBUG_CLOCKS_LL
1771 printf("CBDV %01" PRIx32
" %d\n", (cpc
->pllmr
[0] >> 16) & 0x3, D
);
1773 PLB_clk
= CPU_clk
/ D
;
1774 D
= ((cpc
->pllmr
[0] >> 12) & 0x3) + 1; /* OPDV */
1775 #ifdef DEBUG_CLOCKS_LL
1776 printf("OPDV %01" PRIx32
" %d\n", (cpc
->pllmr
[0] >> 12) & 0x3, D
);
1778 OPB_clk
= PLB_clk
/ D
;
1779 D
= ((cpc
->pllmr
[0] >> 8) & 0x3) + 2; /* EPDV */
1780 #ifdef DEBUG_CLOCKS_LL
1781 printf("EPDV %01" PRIx32
" %d\n", (cpc
->pllmr
[0] >> 8) & 0x3, D
);
1783 EBC_clk
= PLB_clk
/ D
;
1784 D
= ((cpc
->pllmr
[0] >> 4) & 0x3) + 1; /* MPDV */
1785 #ifdef DEBUG_CLOCKS_LL
1786 printf("MPDV %01" PRIx32
" %d\n", (cpc
->pllmr
[0] >> 4) & 0x3, D
);
1788 MAL_clk
= PLB_clk
/ D
;
1789 D
= (cpc
->pllmr
[0] & 0x3) + 1; /* PPDV */
1790 #ifdef DEBUG_CLOCKS_LL
1791 printf("PPDV %01" PRIx32
" %d\n", cpc
->pllmr
[0] & 0x3, D
);
1793 PCI_clk
= PLB_clk
/ D
;
1794 D
= ((cpc
->ucr
- 1) & 0x7F) + 1; /* U0DIV */
1795 #ifdef DEBUG_CLOCKS_LL
1796 printf("U0DIV %01" PRIx32
" %d\n", cpc
->ucr
& 0x7F, D
);
1798 UART0_clk
= PLL_out
/ D
;
1799 D
= (((cpc
->ucr
>> 8) - 1) & 0x7F) + 1; /* U1DIV */
1800 #ifdef DEBUG_CLOCKS_LL
1801 printf("U1DIV %01" PRIx32
" %d\n", (cpc
->ucr
>> 8) & 0x7F, D
);
1803 UART1_clk
= PLL_out
/ D
;
1805 printf("Setup PPC405EP clocks - sysclk %" PRIu32
" VCO %" PRIu64
1806 " PLL out %" PRIu64
" Hz\n", cpc
->sysclk
, VCO_out
, PLL_out
);
1807 printf("CPU %" PRIu32
" PLB %" PRIu32
" OPB %" PRIu32
" EBC %" PRIu32
1808 " MAL %" PRIu32
" PCI %" PRIu32
" UART0 %" PRIu32
1809 " UART1 %" PRIu32
"\n",
1810 CPU_clk
, PLB_clk
, OPB_clk
, EBC_clk
, MAL_clk
, PCI_clk
,
1811 UART0_clk
, UART1_clk
);
1813 /* Setup CPU clocks */
1814 clk_setup(&cpc
->clk_setup
[PPC405EP_CPU_CLK
], CPU_clk
);
1815 /* Setup PLB clock */
1816 clk_setup(&cpc
->clk_setup
[PPC405EP_PLB_CLK
], PLB_clk
);
1817 /* Setup OPB clock */
1818 clk_setup(&cpc
->clk_setup
[PPC405EP_OPB_CLK
], OPB_clk
);
1819 /* Setup external clock */
1820 clk_setup(&cpc
->clk_setup
[PPC405EP_EBC_CLK
], EBC_clk
);
1821 /* Setup MAL clock */
1822 clk_setup(&cpc
->clk_setup
[PPC405EP_MAL_CLK
], MAL_clk
);
1823 /* Setup PCI clock */
1824 clk_setup(&cpc
->clk_setup
[PPC405EP_PCI_CLK
], PCI_clk
);
1825 /* Setup UART0 clock */
1826 clk_setup(&cpc
->clk_setup
[PPC405EP_UART0_CLK
], UART0_clk
);
1827 /* Setup UART1 clock */
1828 clk_setup(&cpc
->clk_setup
[PPC405EP_UART1_CLK
], UART1_clk
);
1831 static uint32_t dcr_read_epcpc (void *opaque
, int dcrn
)
1833 ppc405ep_cpc_t
*cpc
;
1838 case PPC405EP_CPC0_BOOT
:
1841 case PPC405EP_CPC0_EPCTL
:
1844 case PPC405EP_CPC0_PLLMR0
:
1845 ret
= cpc
->pllmr
[0];
1847 case PPC405EP_CPC0_PLLMR1
:
1848 ret
= cpc
->pllmr
[1];
1850 case PPC405EP_CPC0_UCR
:
1853 case PPC405EP_CPC0_SRR
:
1856 case PPC405EP_CPC0_JTAGID
:
1859 case PPC405EP_CPC0_PCI
:
1863 /* Avoid gcc warning */
1871 static void dcr_write_epcpc (void *opaque
, int dcrn
, uint32_t val
)
1873 ppc405ep_cpc_t
*cpc
;
1877 case PPC405EP_CPC0_BOOT
:
1878 /* Read-only register */
1880 case PPC405EP_CPC0_EPCTL
:
1881 /* Don't care for now */
1882 cpc
->epctl
= val
& 0xC00000F3;
1884 case PPC405EP_CPC0_PLLMR0
:
1885 cpc
->pllmr
[0] = val
& 0x00633333;
1886 ppc405ep_compute_clocks(cpc
);
1888 case PPC405EP_CPC0_PLLMR1
:
1889 cpc
->pllmr
[1] = val
& 0xC0F73FFF;
1890 ppc405ep_compute_clocks(cpc
);
1892 case PPC405EP_CPC0_UCR
:
1893 /* UART control - don't care for now */
1894 cpc
->ucr
= val
& 0x003F7F7F;
1896 case PPC405EP_CPC0_SRR
:
1899 case PPC405EP_CPC0_JTAGID
:
1902 case PPC405EP_CPC0_PCI
:
1908 static void ppc405ep_cpc_reset (void *opaque
)
1910 ppc405ep_cpc_t
*cpc
= opaque
;
1912 cpc
->boot
= 0x00000010; /* Boot from PCI - IIC EEPROM disabled */
1913 cpc
->epctl
= 0x00000000;
1914 cpc
->pllmr
[0] = 0x00011010;
1915 cpc
->pllmr
[1] = 0x40000000;
1916 cpc
->ucr
= 0x00000000;
1917 cpc
->srr
= 0x00040000;
1918 cpc
->pci
= 0x00000000;
1919 cpc
->er
= 0x00000000;
1920 cpc
->fr
= 0x00000000;
1921 cpc
->sr
= 0x00000000;
1922 ppc405ep_compute_clocks(cpc
);
1925 /* XXX: sysclk should be between 25 and 100 MHz */
1926 static void ppc405ep_cpc_init (CPUPPCState
*env
, clk_setup_t clk_setup
[8],
1929 ppc405ep_cpc_t
*cpc
;
1931 cpc
= g_malloc0(sizeof(ppc405ep_cpc_t
));
1932 memcpy(cpc
->clk_setup
, clk_setup
,
1933 PPC405EP_CLK_NB
* sizeof(clk_setup_t
));
1934 cpc
->jtagid
= 0x20267049;
1935 cpc
->sysclk
= sysclk
;
1936 qemu_register_reset(&ppc405ep_cpc_reset
, cpc
);
1937 ppc_dcr_register(env
, PPC405EP_CPC0_BOOT
, cpc
,
1938 &dcr_read_epcpc
, &dcr_write_epcpc
);
1939 ppc_dcr_register(env
, PPC405EP_CPC0_EPCTL
, cpc
,
1940 &dcr_read_epcpc
, &dcr_write_epcpc
);
1941 ppc_dcr_register(env
, PPC405EP_CPC0_PLLMR0
, cpc
,
1942 &dcr_read_epcpc
, &dcr_write_epcpc
);
1943 ppc_dcr_register(env
, PPC405EP_CPC0_PLLMR1
, cpc
,
1944 &dcr_read_epcpc
, &dcr_write_epcpc
);
1945 ppc_dcr_register(env
, PPC405EP_CPC0_UCR
, cpc
,
1946 &dcr_read_epcpc
, &dcr_write_epcpc
);
1947 ppc_dcr_register(env
, PPC405EP_CPC0_SRR
, cpc
,
1948 &dcr_read_epcpc
, &dcr_write_epcpc
);
1949 ppc_dcr_register(env
, PPC405EP_CPC0_JTAGID
, cpc
,
1950 &dcr_read_epcpc
, &dcr_write_epcpc
);
1951 ppc_dcr_register(env
, PPC405EP_CPC0_PCI
, cpc
,
1952 &dcr_read_epcpc
, &dcr_write_epcpc
);
1954 ppc_dcr_register(env
, PPC405EP_CPC0_ER
, cpc
,
1955 &dcr_read_epcpc
, &dcr_write_epcpc
);
1956 ppc_dcr_register(env
, PPC405EP_CPC0_FR
, cpc
,
1957 &dcr_read_epcpc
, &dcr_write_epcpc
);
1958 ppc_dcr_register(env
, PPC405EP_CPC0_SR
, cpc
,
1959 &dcr_read_epcpc
, &dcr_write_epcpc
);
1963 CPUPPCState
*ppc405ep_init(MemoryRegion
*address_space_mem
,
1964 MemoryRegion ram_memories
[2],
1965 hwaddr ram_bases
[2],
1966 hwaddr ram_sizes
[2],
1967 uint32_t sysclk
, qemu_irq
**picp
,
1970 clk_setup_t clk_setup
[PPC405EP_CLK_NB
], tlb_clk_setup
;
1971 qemu_irq dma_irqs
[4], gpt_irqs
[5], mal_irqs
[4];
1974 qemu_irq
*pic
, *irqs
;
1976 memset(clk_setup
, 0, sizeof(clk_setup
));
1978 cpu
= ppc4xx_init("405ep", &clk_setup
[PPC405EP_CPU_CLK
],
1979 &tlb_clk_setup
, sysclk
);
1981 clk_setup
[PPC405EP_CPU_CLK
].cb
= tlb_clk_setup
.cb
;
1982 clk_setup
[PPC405EP_CPU_CLK
].opaque
= tlb_clk_setup
.opaque
;
1983 /* Internal devices init */
1984 /* Memory mapped devices registers */
1986 ppc4xx_plb_init(env
);
1987 /* PLB to OPB bridge */
1988 ppc4xx_pob_init(env
);
1990 ppc4xx_opba_init(0xef600600);
1991 /* Initialize timers */
1992 ppc_booke_timers_init(cpu
, sysclk
, 0);
1993 /* Universal interrupt controller */
1994 irqs
= g_malloc0(sizeof(qemu_irq
) * PPCUIC_OUTPUT_NB
);
1995 irqs
[PPCUIC_OUTPUT_INT
] =
1996 ((qemu_irq
*)env
->irq_inputs
)[PPC40x_INPUT_INT
];
1997 irqs
[PPCUIC_OUTPUT_CINT
] =
1998 ((qemu_irq
*)env
->irq_inputs
)[PPC40x_INPUT_CINT
];
1999 pic
= ppcuic_init(env
, irqs
, 0x0C0, 0, 1);
2001 /* SDRAM controller */
2002 /* XXX 405EP has no ECC interrupt */
2003 ppc4xx_sdram_init(env
, pic
[17], 2, ram_memories
,
2004 ram_bases
, ram_sizes
, do_init
);
2005 /* External bus controller */
2006 ppc405_ebc_init(env
);
2007 /* DMA controller */
2008 dma_irqs
[0] = pic
[5];
2009 dma_irqs
[1] = pic
[6];
2010 dma_irqs
[2] = pic
[7];
2011 dma_irqs
[3] = pic
[8];
2012 ppc405_dma_init(env
, dma_irqs
);
2013 /* IIC controller */
2014 sysbus_create_simple(TYPE_PPC4xx_I2C
, 0xef600500, pic
[2]);
2016 ppc405_gpio_init(0xef600700);
2018 if (serial_hds
[0] != NULL
) {
2019 serial_mm_init(address_space_mem
, 0xef600300, 0, pic
[0],
2020 PPC_SERIAL_MM_BAUDBASE
, serial_hds
[0],
2023 if (serial_hds
[1] != NULL
) {
2024 serial_mm_init(address_space_mem
, 0xef600400, 0, pic
[1],
2025 PPC_SERIAL_MM_BAUDBASE
, serial_hds
[1],
2029 ppc405_ocm_init(env
);
2031 gpt_irqs
[0] = pic
[19];
2032 gpt_irqs
[1] = pic
[20];
2033 gpt_irqs
[2] = pic
[21];
2034 gpt_irqs
[3] = pic
[22];
2035 gpt_irqs
[4] = pic
[23];
2036 ppc4xx_gpt_init(0xef600000, gpt_irqs
);
2038 /* Uses pic[3], pic[16], pic[18] */
2040 mal_irqs
[0] = pic
[11];
2041 mal_irqs
[1] = pic
[12];
2042 mal_irqs
[2] = pic
[13];
2043 mal_irqs
[3] = pic
[14];
2044 ppc4xx_mal_init(env
, 4, 2, mal_irqs
);
2046 /* Uses pic[9], pic[15], pic[17] */
2048 ppc405ep_cpc_init(env
, clk_setup
, sysclk
);