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
41 //#define DEBUG_UNASSIGNED
43 /*****************************************************************************/
44 /* Generic PowerPC 405 processor instanciation */
45 CPUState
*ppc405_init (const unsigned char *cpu_model
,
46 clk_setup_t
*cpu_clk
, clk_setup_t
*tb_clk
,
54 ppc_find_by_name(cpu_model
, &def
);
56 cpu_abort(env
, "Unable to find PowerPC %s CPU definition\n",
59 cpu_ppc_register(env
, def
);
61 cpu_clk
->cb
= NULL
; /* We don't care about CPU clock frequency changes */
62 cpu_clk
->opaque
= env
;
63 /* Set time-base frequency to sysclk */
64 tb_clk
->cb
= ppc_emb_timers_init(env
, sysclk
);
66 ppc_dcr_init(env
, NULL
, NULL
);
67 /* Register Qemu callbacks */
68 qemu_register_reset(&cpu_ppc_reset
, env
);
69 register_savevm("cpu", 0, 3, cpu_save
, cpu_load
, env
);
74 ram_addr_t
ppc405_set_bootinfo (CPUState
*env
, ppc4xx_bd_info_t
*bd
,
80 /* We put the bd structure at the top of memory */
81 if (bd
->bi_memsize
>= 0x01000000UL
)
82 bdloc
= 0x01000000UL
- sizeof(struct ppc4xx_bd_info_t
);
84 bdloc
= bd
->bi_memsize
- sizeof(struct ppc4xx_bd_info_t
);
85 stl_raw(phys_ram_base
+ bdloc
+ 0x00, bd
->bi_memstart
);
86 stl_raw(phys_ram_base
+ bdloc
+ 0x04, bd
->bi_memsize
);
87 stl_raw(phys_ram_base
+ bdloc
+ 0x08, bd
->bi_flashstart
);
88 stl_raw(phys_ram_base
+ bdloc
+ 0x0C, bd
->bi_flashsize
);
89 stl_raw(phys_ram_base
+ bdloc
+ 0x10, bd
->bi_flashoffset
);
90 stl_raw(phys_ram_base
+ bdloc
+ 0x14, bd
->bi_sramstart
);
91 stl_raw(phys_ram_base
+ bdloc
+ 0x18, bd
->bi_sramsize
);
92 stl_raw(phys_ram_base
+ bdloc
+ 0x1C, bd
->bi_bootflags
);
93 stl_raw(phys_ram_base
+ bdloc
+ 0x20, bd
->bi_ipaddr
);
94 for (i
= 0; i
< 6; i
++)
95 stb_raw(phys_ram_base
+ bdloc
+ 0x24 + i
, bd
->bi_enetaddr
[i
]);
96 stw_raw(phys_ram_base
+ bdloc
+ 0x2A, bd
->bi_ethspeed
);
97 stl_raw(phys_ram_base
+ bdloc
+ 0x2C, bd
->bi_intfreq
);
98 stl_raw(phys_ram_base
+ bdloc
+ 0x30, bd
->bi_busfreq
);
99 stl_raw(phys_ram_base
+ bdloc
+ 0x34, bd
->bi_baudrate
);
100 for (i
= 0; i
< 4; i
++)
101 stb_raw(phys_ram_base
+ bdloc
+ 0x38 + i
, bd
->bi_s_version
[i
]);
102 for (i
= 0; i
< 32; i
++)
103 stb_raw(phys_ram_base
+ bdloc
+ 0x3C + i
, bd
->bi_s_version
[i
]);
104 stl_raw(phys_ram_base
+ bdloc
+ 0x5C, bd
->bi_plb_busfreq
);
105 stl_raw(phys_ram_base
+ bdloc
+ 0x60, bd
->bi_pci_busfreq
);
106 for (i
= 0; i
< 6; i
++)
107 stb_raw(phys_ram_base
+ bdloc
+ 0x64 + i
, bd
->bi_pci_enetaddr
[i
]);
109 if (flags
& 0x00000001) {
110 for (i
= 0; i
< 6; i
++)
111 stb_raw(phys_ram_base
+ bdloc
+ n
++, bd
->bi_pci_enetaddr2
[i
]);
113 stl_raw(phys_ram_base
+ bdloc
+ n
, bd
->bi_opbfreq
);
115 for (i
= 0; i
< 2; i
++) {
116 stl_raw(phys_ram_base
+ bdloc
+ n
, bd
->bi_iic_fast
[i
]);
123 /*****************************************************************************/
124 /* Shared peripherals */
126 /*****************************************************************************/
127 /* Fake device used to map multiple devices in a single memory page */
128 #define MMIO_AREA_BITS 8
129 #define MMIO_AREA_LEN (1 << MMIO_AREA_BITS)
130 #define MMIO_AREA_NB (1 << (TARGET_PAGE_BITS - MMIO_AREA_BITS))
131 #define MMIO_IDX(addr) (((addr) >> MMIO_AREA_BITS) & (MMIO_AREA_NB - 1))
132 struct ppc4xx_mmio_t
{
133 target_phys_addr_t base
;
134 CPUReadMemoryFunc
**mem_read
[MMIO_AREA_NB
];
135 CPUWriteMemoryFunc
**mem_write
[MMIO_AREA_NB
];
136 void *opaque
[MMIO_AREA_NB
];
139 static uint32_t unassigned_mmio_readb (void *opaque
, target_phys_addr_t addr
)
141 #ifdef DEBUG_UNASSIGNED
145 printf("Unassigned mmio read 0x" PADDRX
" base " PADDRX
"\n",
152 static void unassigned_mmio_writeb (void *opaque
,
153 target_phys_addr_t addr
, uint32_t val
)
155 #ifdef DEBUG_UNASSIGNED
159 printf("Unassigned mmio write 0x" PADDRX
" = 0x%x base " PADDRX
"\n",
160 addr
, val
, mmio
->base
);
164 static CPUReadMemoryFunc
*unassigned_mmio_read
[3] = {
165 unassigned_mmio_readb
,
166 unassigned_mmio_readb
,
167 unassigned_mmio_readb
,
170 static CPUWriteMemoryFunc
*unassigned_mmio_write
[3] = {
171 unassigned_mmio_writeb
,
172 unassigned_mmio_writeb
,
173 unassigned_mmio_writeb
,
176 static uint32_t mmio_readlen (ppc4xx_mmio_t
*mmio
,
177 target_phys_addr_t addr
, int len
)
179 CPUReadMemoryFunc
**mem_read
;
183 idx
= MMIO_IDX(addr
- mmio
->base
);
184 #if defined(DEBUG_MMIO)
185 printf("%s: mmio %p len %d addr " PADDRX
" idx %d\n", __func__
,
186 mmio
, len
, addr
, idx
);
188 mem_read
= mmio
->mem_read
[idx
];
189 ret
= (*mem_read
[len
])(mmio
->opaque
[idx
], addr
- mmio
->base
);
194 static void mmio_writelen (ppc4xx_mmio_t
*mmio
,
195 target_phys_addr_t addr
, uint32_t value
, int len
)
197 CPUWriteMemoryFunc
**mem_write
;
200 idx
= MMIO_IDX(addr
- mmio
->base
);
201 #if defined(DEBUG_MMIO)
202 printf("%s: mmio %p len %d addr " PADDRX
" idx %d value %08x\n", __func__
,
203 mmio
, len
, addr
, idx
, value
);
205 mem_write
= mmio
->mem_write
[idx
];
206 (*mem_write
[len
])(mmio
->opaque
[idx
], addr
- mmio
->base
, value
);
209 static uint32_t mmio_readb (void *opaque
, target_phys_addr_t addr
)
211 #if defined(DEBUG_MMIO)
212 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
215 return mmio_readlen(opaque
, addr
, 0);
218 static void mmio_writeb (void *opaque
,
219 target_phys_addr_t addr
, uint32_t value
)
221 #if defined(DEBUG_MMIO)
222 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
224 mmio_writelen(opaque
, addr
, value
, 0);
227 static uint32_t mmio_readw (void *opaque
, target_phys_addr_t addr
)
229 #if defined(DEBUG_MMIO)
230 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
233 return mmio_readlen(opaque
, addr
, 1);
236 static void mmio_writew (void *opaque
,
237 target_phys_addr_t addr
, uint32_t value
)
239 #if defined(DEBUG_MMIO)
240 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
242 mmio_writelen(opaque
, addr
, value
, 1);
245 static uint32_t mmio_readl (void *opaque
, target_phys_addr_t addr
)
247 #if defined(DEBUG_MMIO)
248 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
251 return mmio_readlen(opaque
, addr
, 2);
254 static void mmio_writel (void *opaque
,
255 target_phys_addr_t addr
, uint32_t value
)
257 #if defined(DEBUG_MMIO)
258 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
260 mmio_writelen(opaque
, addr
, value
, 2);
263 static CPUReadMemoryFunc
*mmio_read
[] = {
269 static CPUWriteMemoryFunc
*mmio_write
[] = {
275 int ppc4xx_mmio_register (CPUState
*env
, ppc4xx_mmio_t
*mmio
,
276 target_phys_addr_t offset
, uint32_t len
,
277 CPUReadMemoryFunc
**mem_read
,
278 CPUWriteMemoryFunc
**mem_write
, void *opaque
)
283 if ((offset
+ len
) > TARGET_PAGE_SIZE
)
285 idx
= MMIO_IDX(offset
);
286 end
= offset
+ len
- 1;
287 eidx
= MMIO_IDX(end
);
288 #if defined(DEBUG_MMIO)
289 printf("%s: offset %08x len %08x %08x %d %d\n", __func__
, offset
, len
,
292 for (; idx
<= eidx
; idx
++) {
293 mmio
->mem_read
[idx
] = mem_read
;
294 mmio
->mem_write
[idx
] = mem_write
;
295 mmio
->opaque
[idx
] = opaque
;
301 ppc4xx_mmio_t
*ppc4xx_mmio_init (CPUState
*env
, target_phys_addr_t base
)
306 mmio
= qemu_mallocz(sizeof(ppc4xx_mmio_t
));
309 mmio_memory
= cpu_register_io_memory(0, mmio_read
, mmio_write
, mmio
);
310 #if defined(DEBUG_MMIO)
311 printf("%s: %p base %08x len %08x %d\n", __func__
,
312 mmio
, base
, TARGET_PAGE_SIZE
, mmio_memory
);
314 cpu_register_physical_memory(base
, TARGET_PAGE_SIZE
, mmio_memory
);
315 ppc4xx_mmio_register(env
, mmio
, 0, TARGET_PAGE_SIZE
,
316 unassigned_mmio_read
, unassigned_mmio_write
,
323 /*****************************************************************************/
324 /* Peripheral local bus arbitrer */
331 typedef struct ppc4xx_plb_t ppc4xx_plb_t
;
332 struct ppc4xx_plb_t
{
338 static target_ulong
dcr_read_plb (void *opaque
, int dcrn
)
355 /* Avoid gcc warning */
363 static void dcr_write_plb (void *opaque
, int dcrn
, target_ulong val
)
370 /* We don't care about the actual parameters written as
371 * we don't manage any priorities on the bus
373 plb
->acr
= val
& 0xF8000000;
385 static void ppc4xx_plb_reset (void *opaque
)
390 plb
->acr
= 0x00000000;
391 plb
->bear
= 0x00000000;
392 plb
->besr
= 0x00000000;
395 void ppc4xx_plb_init (CPUState
*env
)
399 plb
= qemu_mallocz(sizeof(ppc4xx_plb_t
));
401 ppc_dcr_register(env
, PLB0_ACR
, plb
, &dcr_read_plb
, &dcr_write_plb
);
402 ppc_dcr_register(env
, PLB0_BEAR
, plb
, &dcr_read_plb
, &dcr_write_plb
);
403 ppc_dcr_register(env
, PLB0_BESR
, plb
, &dcr_read_plb
, &dcr_write_plb
);
404 ppc4xx_plb_reset(plb
);
405 qemu_register_reset(ppc4xx_plb_reset
, plb
);
409 /*****************************************************************************/
410 /* PLB to OPB bridge */
417 typedef struct ppc4xx_pob_t ppc4xx_pob_t
;
418 struct ppc4xx_pob_t
{
423 static target_ulong
dcr_read_pob (void *opaque
, int dcrn
)
435 ret
= pob
->besr
[dcrn
- POB0_BESR0
];
438 /* Avoid gcc warning */
446 static void dcr_write_pob (void *opaque
, int dcrn
, target_ulong val
)
458 pob
->besr
[dcrn
- POB0_BESR0
] &= ~val
;
463 static void ppc4xx_pob_reset (void *opaque
)
469 pob
->bear
= 0x00000000;
470 pob
->besr
[0] = 0x0000000;
471 pob
->besr
[1] = 0x0000000;
474 void ppc4xx_pob_init (CPUState
*env
)
478 pob
= qemu_mallocz(sizeof(ppc4xx_pob_t
));
480 ppc_dcr_register(env
, POB0_BEAR
, pob
, &dcr_read_pob
, &dcr_write_pob
);
481 ppc_dcr_register(env
, POB0_BESR0
, pob
, &dcr_read_pob
, &dcr_write_pob
);
482 ppc_dcr_register(env
, POB0_BESR1
, pob
, &dcr_read_pob
, &dcr_write_pob
);
483 qemu_register_reset(ppc4xx_pob_reset
, pob
);
484 ppc4xx_pob_reset(env
);
488 /*****************************************************************************/
490 typedef struct ppc4xx_opba_t ppc4xx_opba_t
;
491 struct ppc4xx_opba_t
{
492 target_phys_addr_t base
;
497 static uint32_t opba_readb (void *opaque
, target_phys_addr_t addr
)
503 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
506 switch (addr
- opba
->base
) {
521 static void opba_writeb (void *opaque
,
522 target_phys_addr_t addr
, uint32_t value
)
527 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
530 switch (addr
- opba
->base
) {
532 opba
->cr
= value
& 0xF8;
535 opba
->pr
= value
& 0xFF;
542 static uint32_t opba_readw (void *opaque
, target_phys_addr_t addr
)
547 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
549 ret
= opba_readb(opaque
, addr
) << 8;
550 ret
|= opba_readb(opaque
, addr
+ 1);
555 static void opba_writew (void *opaque
,
556 target_phys_addr_t addr
, uint32_t value
)
559 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
561 opba_writeb(opaque
, addr
, value
>> 8);
562 opba_writeb(opaque
, addr
+ 1, value
);
565 static uint32_t opba_readl (void *opaque
, target_phys_addr_t addr
)
570 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
572 ret
= opba_readb(opaque
, addr
) << 24;
573 ret
|= opba_readb(opaque
, addr
+ 1) << 16;
578 static void opba_writel (void *opaque
,
579 target_phys_addr_t addr
, uint32_t value
)
582 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
584 opba_writeb(opaque
, addr
, value
>> 24);
585 opba_writeb(opaque
, addr
+ 1, value
>> 16);
588 static CPUReadMemoryFunc
*opba_read
[] = {
594 static CPUWriteMemoryFunc
*opba_write
[] = {
600 static void ppc4xx_opba_reset (void *opaque
)
605 opba
->cr
= 0x00; /* No dynamic priorities - park disabled */
609 void ppc4xx_opba_init (CPUState
*env
, ppc4xx_mmio_t
*mmio
,
610 target_phys_addr_t offset
)
614 opba
= qemu_mallocz(sizeof(ppc4xx_opba_t
));
618 printf("%s: offset=" PADDRX
"\n", __func__
, offset
);
620 ppc4xx_mmio_register(env
, mmio
, offset
, 0x002,
621 opba_read
, opba_write
, opba
);
622 qemu_register_reset(ppc4xx_opba_reset
, opba
);
623 ppc4xx_opba_reset(opba
);
627 /*****************************************************************************/
628 /* "Universal" Interrupt controller */
642 #define UIC_MAX_IRQ 32
643 typedef struct ppcuic_t ppcuic_t
;
647 uint32_t uicsr
; /* Status register */
648 uint32_t uicer
; /* Enable register */
649 uint32_t uiccr
; /* Critical register */
650 uint32_t uicpr
; /* Polarity register */
651 uint32_t uictr
; /* Triggering register */
652 uint32_t uicvcr
; /* Vector configuration register */
657 static void ppcuic_trigger_irq (ppcuic_t
*uic
)
660 int start
, end
, inc
, i
;
662 /* Trigger interrupt if any is pending */
663 ir
= uic
->uicsr
& uic
->uicer
& (~uic
->uiccr
);
664 cr
= uic
->uicsr
& uic
->uicer
& uic
->uiccr
;
666 if (loglevel
& CPU_LOG_INT
) {
667 fprintf(logfile
, "%s: uicsr %08x uicer %08x uiccr %08x\n"
668 " %08x ir %08x cr %08x\n", __func__
,
669 uic
->uicsr
, uic
->uicer
, uic
->uiccr
,
670 uic
->uicsr
& uic
->uicer
, ir
, cr
);
673 if (ir
!= 0x0000000) {
675 if (loglevel
& CPU_LOG_INT
) {
676 fprintf(logfile
, "Raise UIC interrupt\n");
679 qemu_irq_raise(uic
->irqs
[PPCUIC_OUTPUT_INT
]);
682 if (loglevel
& CPU_LOG_INT
) {
683 fprintf(logfile
, "Lower UIC interrupt\n");
686 qemu_irq_lower(uic
->irqs
[PPCUIC_OUTPUT_INT
]);
688 /* Trigger critical interrupt if any is pending and update vector */
689 if (cr
!= 0x0000000) {
690 qemu_irq_raise(uic
->irqs
[PPCUIC_OUTPUT_CINT
]);
691 if (uic
->use_vectors
) {
692 /* Compute critical IRQ vector */
693 if (uic
->uicvcr
& 1) {
702 uic
->uicvr
= uic
->uicvcr
& 0xFFFFFFFC;
703 for (i
= start
; i
<= end
; i
+= inc
) {
705 uic
->uicvr
+= (i
- start
) * 512 * inc
;
711 if (loglevel
& CPU_LOG_INT
) {
712 fprintf(logfile
, "Raise UIC critical interrupt - vector %08x\n",
718 if (loglevel
& CPU_LOG_INT
) {
719 fprintf(logfile
, "Lower UIC critical interrupt\n");
722 qemu_irq_lower(uic
->irqs
[PPCUIC_OUTPUT_CINT
]);
723 uic
->uicvr
= 0x00000000;
727 static void ppcuic_set_irq (void *opaque
, int irq_num
, int level
)
735 if (loglevel
& CPU_LOG_INT
) {
736 fprintf(logfile
, "%s: irq %d level %d uicsr %08x mask %08x => %08x "
737 "%08x\n", __func__
, irq_num
, level
,
738 uic
->uicsr
, mask
, uic
->uicsr
& mask
, level
<< irq_num
);
741 if (irq_num
< 0 || irq_num
> 31)
744 if (!(uic
->uicpr
& mask
)) {
745 /* Negatively asserted IRQ */
746 level
= level
== 0 ? 1 : 0;
748 /* Update status register */
749 if (uic
->uictr
& mask
) {
750 /* Edge sensitive interrupt */
754 /* Level sensitive interrupt */
761 if (loglevel
& CPU_LOG_INT
) {
762 fprintf(logfile
, "%s: irq %d level %d sr %08x => %08x\n", __func__
,
763 irq_num
, level
, uic
->uicsr
, sr
);
766 if (sr
!= uic
->uicsr
)
767 ppcuic_trigger_irq(uic
);
770 static target_ulong
dcr_read_uic (void *opaque
, int dcrn
)
776 dcrn
-= uic
->dcr_base
;
795 ret
= uic
->uicsr
& uic
->uicer
;
798 if (!uic
->use_vectors
)
803 if (!uic
->use_vectors
)
816 static void dcr_write_uic (void *opaque
, int dcrn
, target_ulong val
)
821 dcrn
-= uic
->dcr_base
;
823 if (loglevel
& CPU_LOG_INT
) {
824 fprintf(logfile
, "%s: dcr %d val " ADDRX
"\n", __func__
, dcrn
, val
);
830 ppcuic_trigger_irq(uic
);
834 ppcuic_trigger_irq(uic
);
838 ppcuic_trigger_irq(uic
);
842 ppcuic_trigger_irq(uic
);
846 ppcuic_trigger_irq(uic
);
850 ppcuic_trigger_irq(uic
);
857 uic
->uicvcr
= val
& 0xFFFFFFFD;
858 ppcuic_trigger_irq(uic
);
863 static void ppcuic_reset (void *opaque
)
868 uic
->uiccr
= 0x00000000;
869 uic
->uicer
= 0x00000000;
870 uic
->uicpr
= 0x00000000;
871 uic
->uicsr
= 0x00000000;
872 uic
->uictr
= 0x00000000;
873 if (uic
->use_vectors
) {
874 uic
->uicvcr
= 0x00000000;
875 uic
->uicvr
= 0x0000000;
879 qemu_irq
*ppcuic_init (CPUState
*env
, qemu_irq
*irqs
,
880 uint32_t dcr_base
, int has_ssr
, int has_vr
)
885 uic
= qemu_mallocz(sizeof(ppcuic_t
));
887 uic
->dcr_base
= dcr_base
;
890 uic
->use_vectors
= 1;
891 for (i
= 0; i
< DCR_UICMAX
; i
++) {
892 ppc_dcr_register(env
, dcr_base
+ i
, uic
,
893 &dcr_read_uic
, &dcr_write_uic
);
895 qemu_register_reset(ppcuic_reset
, uic
);
899 return qemu_allocate_irqs(&ppcuic_set_irq
, uic
, UIC_MAX_IRQ
);
902 /*****************************************************************************/
903 /* Code decompression controller */
906 /*****************************************************************************/
907 /* SDRAM controller */
908 typedef struct ppc4xx_sdram_t ppc4xx_sdram_t
;
909 struct ppc4xx_sdram_t
{
912 target_phys_addr_t ram_bases
[4];
913 target_phys_addr_t ram_sizes
[4];
929 SDRAM0_CFGADDR
= 0x010,
930 SDRAM0_CFGDATA
= 0x011,
933 static uint32_t sdram_bcr (target_phys_addr_t ram_base
,
934 target_phys_addr_t ram_size
)
939 case (4 * 1024 * 1024):
942 case (8 * 1024 * 1024):
945 case (16 * 1024 * 1024):
948 case (32 * 1024 * 1024):
951 case (64 * 1024 * 1024):
954 case (128 * 1024 * 1024):
957 case (256 * 1024 * 1024):
961 printf("%s: invalid RAM size " TARGET_FMT_plx
"\n",
965 bcr
|= ram_base
& 0xFF800000;
971 static inline target_phys_addr_t
sdram_base (uint32_t bcr
)
973 return bcr
& 0xFF800000;
976 static target_ulong
sdram_size (uint32_t bcr
)
981 sh
= (bcr
>> 17) & 0x7;
985 size
= (4 * 1024 * 1024) << sh
;
990 static void sdram_set_bcr (uint32_t *bcrp
, uint32_t bcr
, int enabled
)
992 if (*bcrp
& 0x00000001) {
995 printf("%s: unmap RAM area " TARGET_FMT_plx
" " TARGET_FMT_lx
"\n",
996 __func__
, sdram_base(*bcrp
), sdram_size(*bcrp
));
998 cpu_register_physical_memory(sdram_base(*bcrp
), sdram_size(*bcrp
),
1001 *bcrp
= bcr
& 0xFFDEE001;
1002 if (enabled
&& (bcr
& 0x00000001)) {
1004 printf("%s: Map RAM area " TARGET_FMT_plx
" " TARGET_FMT_lx
"\n",
1005 __func__
, sdram_base(bcr
), sdram_size(bcr
));
1007 cpu_register_physical_memory(sdram_base(bcr
), sdram_size(bcr
),
1008 sdram_base(bcr
) | IO_MEM_RAM
);
1012 static void sdram_map_bcr (ppc4xx_sdram_t
*sdram
)
1016 for (i
= 0; i
< sdram
->nbanks
; i
++) {
1017 if (sdram
->ram_sizes
[i
] != 0) {
1018 sdram_set_bcr(&sdram
->bcr
[i
],
1019 sdram_bcr(sdram
->ram_bases
[i
], sdram
->ram_sizes
[i
]),
1022 sdram_set_bcr(&sdram
->bcr
[i
], 0x00000000, 0);
1027 static void sdram_unmap_bcr (ppc4xx_sdram_t
*sdram
)
1031 for (i
= 0; i
< sdram
->nbanks
; i
++) {
1033 printf("%s: Unmap RAM area " TARGET_FMT_plx
" " TARGET_FMT_lx
"\n",
1034 __func__
, sdram_base(sdram
->bcr
[i
]), sdram_size(sdram
->bcr
[i
]));
1036 cpu_register_physical_memory(sdram_base(sdram
->bcr
[i
]),
1037 sdram_size(sdram
->bcr
[i
]),
1042 static target_ulong
dcr_read_sdram (void *opaque
, int dcrn
)
1044 ppc4xx_sdram_t
*sdram
;
1049 case SDRAM0_CFGADDR
:
1052 case SDRAM0_CFGDATA
:
1053 switch (sdram
->addr
) {
1054 case 0x00: /* SDRAM_BESR0 */
1057 case 0x08: /* SDRAM_BESR1 */
1060 case 0x10: /* SDRAM_BEAR */
1063 case 0x20: /* SDRAM_CFG */
1066 case 0x24: /* SDRAM_STATUS */
1067 ret
= sdram
->status
;
1069 case 0x30: /* SDRAM_RTR */
1072 case 0x34: /* SDRAM_PMIT */
1075 case 0x40: /* SDRAM_B0CR */
1076 ret
= sdram
->bcr
[0];
1078 case 0x44: /* SDRAM_B1CR */
1079 ret
= sdram
->bcr
[1];
1081 case 0x48: /* SDRAM_B2CR */
1082 ret
= sdram
->bcr
[2];
1084 case 0x4C: /* SDRAM_B3CR */
1085 ret
= sdram
->bcr
[3];
1087 case 0x80: /* SDRAM_TR */
1090 case 0x94: /* SDRAM_ECCCFG */
1091 ret
= sdram
->ecccfg
;
1093 case 0x98: /* SDRAM_ECCESR */
1094 ret
= sdram
->eccesr
;
1096 default: /* Error */
1102 /* Avoid gcc warning */
1110 static void dcr_write_sdram (void *opaque
, int dcrn
, target_ulong val
)
1112 ppc4xx_sdram_t
*sdram
;
1116 case SDRAM0_CFGADDR
:
1119 case SDRAM0_CFGDATA
:
1120 switch (sdram
->addr
) {
1121 case 0x00: /* SDRAM_BESR0 */
1122 sdram
->besr0
&= ~val
;
1124 case 0x08: /* SDRAM_BESR1 */
1125 sdram
->besr1
&= ~val
;
1127 case 0x10: /* SDRAM_BEAR */
1130 case 0x20: /* SDRAM_CFG */
1132 if (!(sdram
->cfg
& 0x80000000) && (val
& 0x80000000)) {
1134 printf("%s: enable SDRAM controller\n", __func__
);
1136 /* validate all RAM mappings */
1137 sdram_map_bcr(sdram
);
1138 sdram
->status
&= ~0x80000000;
1139 } else if ((sdram
->cfg
& 0x80000000) && !(val
& 0x80000000)) {
1141 printf("%s: disable SDRAM controller\n", __func__
);
1143 /* invalidate all RAM mappings */
1144 sdram_unmap_bcr(sdram
);
1145 sdram
->status
|= 0x80000000;
1147 if (!(sdram
->cfg
& 0x40000000) && (val
& 0x40000000))
1148 sdram
->status
|= 0x40000000;
1149 else if ((sdram
->cfg
& 0x40000000) && !(val
& 0x40000000))
1150 sdram
->status
&= ~0x40000000;
1153 case 0x24: /* SDRAM_STATUS */
1154 /* Read-only register */
1156 case 0x30: /* SDRAM_RTR */
1157 sdram
->rtr
= val
& 0x3FF80000;
1159 case 0x34: /* SDRAM_PMIT */
1160 sdram
->pmit
= (val
& 0xF8000000) | 0x07C00000;
1162 case 0x40: /* SDRAM_B0CR */
1163 sdram_set_bcr(&sdram
->bcr
[0], val
, sdram
->cfg
& 0x80000000);
1165 case 0x44: /* SDRAM_B1CR */
1166 sdram_set_bcr(&sdram
->bcr
[1], val
, sdram
->cfg
& 0x80000000);
1168 case 0x48: /* SDRAM_B2CR */
1169 sdram_set_bcr(&sdram
->bcr
[2], val
, sdram
->cfg
& 0x80000000);
1171 case 0x4C: /* SDRAM_B3CR */
1172 sdram_set_bcr(&sdram
->bcr
[3], val
, sdram
->cfg
& 0x80000000);
1174 case 0x80: /* SDRAM_TR */
1175 sdram
->tr
= val
& 0x018FC01F;
1177 case 0x94: /* SDRAM_ECCCFG */
1178 sdram
->ecccfg
= val
& 0x00F00000;
1180 case 0x98: /* SDRAM_ECCESR */
1182 if (sdram
->eccesr
== 0 && val
!= 0)
1183 qemu_irq_raise(sdram
->irq
);
1184 else if (sdram
->eccesr
!= 0 && val
== 0)
1185 qemu_irq_lower(sdram
->irq
);
1186 sdram
->eccesr
= val
;
1188 default: /* Error */
1195 static void sdram_reset (void *opaque
)
1197 ppc4xx_sdram_t
*sdram
;
1200 sdram
->addr
= 0x00000000;
1201 sdram
->bear
= 0x00000000;
1202 sdram
->besr0
= 0x00000000; /* No error */
1203 sdram
->besr1
= 0x00000000; /* No error */
1204 sdram
->cfg
= 0x00000000;
1205 sdram
->ecccfg
= 0x00000000; /* No ECC */
1206 sdram
->eccesr
= 0x00000000; /* No error */
1207 sdram
->pmit
= 0x07C00000;
1208 sdram
->rtr
= 0x05F00000;
1209 sdram
->tr
= 0x00854009;
1210 /* We pre-initialize RAM banks */
1211 sdram
->status
= 0x00000000;
1212 sdram
->cfg
= 0x00800000;
1213 sdram_unmap_bcr(sdram
);
1216 void ppc405_sdram_init (CPUState
*env
, qemu_irq irq
, int nbanks
,
1217 target_phys_addr_t
*ram_bases
,
1218 target_phys_addr_t
*ram_sizes
,
1221 ppc4xx_sdram_t
*sdram
;
1223 sdram
= qemu_mallocz(sizeof(ppc4xx_sdram_t
));
1224 if (sdram
!= NULL
) {
1226 sdram
->nbanks
= nbanks
;
1227 memset(sdram
->ram_bases
, 0, 4 * sizeof(target_phys_addr_t
));
1228 memcpy(sdram
->ram_bases
, ram_bases
,
1229 nbanks
* sizeof(target_phys_addr_t
));
1230 memset(sdram
->ram_sizes
, 0, 4 * sizeof(target_phys_addr_t
));
1231 memcpy(sdram
->ram_sizes
, ram_sizes
,
1232 nbanks
* sizeof(target_phys_addr_t
));
1234 qemu_register_reset(&sdram_reset
, sdram
);
1235 ppc_dcr_register(env
, SDRAM0_CFGADDR
,
1236 sdram
, &dcr_read_sdram
, &dcr_write_sdram
);
1237 ppc_dcr_register(env
, SDRAM0_CFGDATA
,
1238 sdram
, &dcr_read_sdram
, &dcr_write_sdram
);
1240 sdram_map_bcr(sdram
);
1244 /*****************************************************************************/
1245 /* Peripheral controller */
1246 typedef struct ppc4xx_ebc_t ppc4xx_ebc_t
;
1247 struct ppc4xx_ebc_t
{
1258 EBC0_CFGADDR
= 0x012,
1259 EBC0_CFGDATA
= 0x013,
1262 static target_ulong
dcr_read_ebc (void *opaque
, int dcrn
)
1273 switch (ebc
->addr
) {
1274 case 0x00: /* B0CR */
1277 case 0x01: /* B1CR */
1280 case 0x02: /* B2CR */
1283 case 0x03: /* B3CR */
1286 case 0x04: /* B4CR */
1289 case 0x05: /* B5CR */
1292 case 0x06: /* B6CR */
1295 case 0x07: /* B7CR */
1298 case 0x10: /* B0AP */
1301 case 0x11: /* B1AP */
1304 case 0x12: /* B2AP */
1307 case 0x13: /* B3AP */
1310 case 0x14: /* B4AP */
1313 case 0x15: /* B5AP */
1316 case 0x16: /* B6AP */
1319 case 0x17: /* B7AP */
1322 case 0x20: /* BEAR */
1325 case 0x21: /* BESR0 */
1328 case 0x22: /* BESR1 */
1331 case 0x23: /* CFG */
1346 static void dcr_write_ebc (void *opaque
, int dcrn
, target_ulong val
)
1356 switch (ebc
->addr
) {
1357 case 0x00: /* B0CR */
1359 case 0x01: /* B1CR */
1361 case 0x02: /* B2CR */
1363 case 0x03: /* B3CR */
1365 case 0x04: /* B4CR */
1367 case 0x05: /* B5CR */
1369 case 0x06: /* B6CR */
1371 case 0x07: /* B7CR */
1373 case 0x10: /* B0AP */
1375 case 0x11: /* B1AP */
1377 case 0x12: /* B2AP */
1379 case 0x13: /* B3AP */
1381 case 0x14: /* B4AP */
1383 case 0x15: /* B5AP */
1385 case 0x16: /* B6AP */
1387 case 0x17: /* B7AP */
1389 case 0x20: /* BEAR */
1391 case 0x21: /* BESR0 */
1393 case 0x22: /* BESR1 */
1395 case 0x23: /* CFG */
1406 static void ebc_reset (void *opaque
)
1412 ebc
->addr
= 0x00000000;
1413 ebc
->bap
[0] = 0x7F8FFE80;
1414 ebc
->bcr
[0] = 0xFFE28000;
1415 for (i
= 0; i
< 8; i
++) {
1416 ebc
->bap
[i
] = 0x00000000;
1417 ebc
->bcr
[i
] = 0x00000000;
1419 ebc
->besr0
= 0x00000000;
1420 ebc
->besr1
= 0x00000000;
1421 ebc
->cfg
= 0x80400000;
1424 void ppc405_ebc_init (CPUState
*env
)
1428 ebc
= qemu_mallocz(sizeof(ppc4xx_ebc_t
));
1431 qemu_register_reset(&ebc_reset
, ebc
);
1432 ppc_dcr_register(env
, EBC0_CFGADDR
,
1433 ebc
, &dcr_read_ebc
, &dcr_write_ebc
);
1434 ppc_dcr_register(env
, EBC0_CFGDATA
,
1435 ebc
, &dcr_read_ebc
, &dcr_write_ebc
);
1439 /*****************************************************************************/
1440 /* DMA controller */
1468 typedef struct ppc405_dma_t ppc405_dma_t
;
1469 struct ppc405_dma_t
{
1482 static target_ulong
dcr_read_dma (void *opaque
, int dcrn
)
1491 static void dcr_write_dma (void *opaque
, int dcrn
, target_ulong val
)
1498 static void ppc405_dma_reset (void *opaque
)
1504 for (i
= 0; i
< 4; i
++) {
1505 dma
->cr
[i
] = 0x00000000;
1506 dma
->ct
[i
] = 0x00000000;
1507 dma
->da
[i
] = 0x00000000;
1508 dma
->sa
[i
] = 0x00000000;
1509 dma
->sg
[i
] = 0x00000000;
1511 dma
->sr
= 0x00000000;
1512 dma
->sgc
= 0x00000000;
1513 dma
->slp
= 0x7C000000;
1514 dma
->pol
= 0x00000000;
1517 void ppc405_dma_init (CPUState
*env
, qemu_irq irqs
[4])
1521 dma
= qemu_mallocz(sizeof(ppc405_dma_t
));
1523 memcpy(dma
->irqs
, irqs
, 4 * sizeof(qemu_irq
));
1524 ppc405_dma_reset(dma
);
1525 qemu_register_reset(&ppc405_dma_reset
, dma
);
1526 ppc_dcr_register(env
, DMA0_CR0
,
1527 dma
, &dcr_read_dma
, &dcr_write_dma
);
1528 ppc_dcr_register(env
, DMA0_CT0
,
1529 dma
, &dcr_read_dma
, &dcr_write_dma
);
1530 ppc_dcr_register(env
, DMA0_DA0
,
1531 dma
, &dcr_read_dma
, &dcr_write_dma
);
1532 ppc_dcr_register(env
, DMA0_SA0
,
1533 dma
, &dcr_read_dma
, &dcr_write_dma
);
1534 ppc_dcr_register(env
, DMA0_SG0
,
1535 dma
, &dcr_read_dma
, &dcr_write_dma
);
1536 ppc_dcr_register(env
, DMA0_CR1
,
1537 dma
, &dcr_read_dma
, &dcr_write_dma
);
1538 ppc_dcr_register(env
, DMA0_CT1
,
1539 dma
, &dcr_read_dma
, &dcr_write_dma
);
1540 ppc_dcr_register(env
, DMA0_DA1
,
1541 dma
, &dcr_read_dma
, &dcr_write_dma
);
1542 ppc_dcr_register(env
, DMA0_SA1
,
1543 dma
, &dcr_read_dma
, &dcr_write_dma
);
1544 ppc_dcr_register(env
, DMA0_SG1
,
1545 dma
, &dcr_read_dma
, &dcr_write_dma
);
1546 ppc_dcr_register(env
, DMA0_CR2
,
1547 dma
, &dcr_read_dma
, &dcr_write_dma
);
1548 ppc_dcr_register(env
, DMA0_CT2
,
1549 dma
, &dcr_read_dma
, &dcr_write_dma
);
1550 ppc_dcr_register(env
, DMA0_DA2
,
1551 dma
, &dcr_read_dma
, &dcr_write_dma
);
1552 ppc_dcr_register(env
, DMA0_SA2
,
1553 dma
, &dcr_read_dma
, &dcr_write_dma
);
1554 ppc_dcr_register(env
, DMA0_SG2
,
1555 dma
, &dcr_read_dma
, &dcr_write_dma
);
1556 ppc_dcr_register(env
, DMA0_CR3
,
1557 dma
, &dcr_read_dma
, &dcr_write_dma
);
1558 ppc_dcr_register(env
, DMA0_CT3
,
1559 dma
, &dcr_read_dma
, &dcr_write_dma
);
1560 ppc_dcr_register(env
, DMA0_DA3
,
1561 dma
, &dcr_read_dma
, &dcr_write_dma
);
1562 ppc_dcr_register(env
, DMA0_SA3
,
1563 dma
, &dcr_read_dma
, &dcr_write_dma
);
1564 ppc_dcr_register(env
, DMA0_SG3
,
1565 dma
, &dcr_read_dma
, &dcr_write_dma
);
1566 ppc_dcr_register(env
, DMA0_SR
,
1567 dma
, &dcr_read_dma
, &dcr_write_dma
);
1568 ppc_dcr_register(env
, DMA0_SGC
,
1569 dma
, &dcr_read_dma
, &dcr_write_dma
);
1570 ppc_dcr_register(env
, DMA0_SLP
,
1571 dma
, &dcr_read_dma
, &dcr_write_dma
);
1572 ppc_dcr_register(env
, DMA0_POL
,
1573 dma
, &dcr_read_dma
, &dcr_write_dma
);
1577 /*****************************************************************************/
1579 typedef struct ppc405_gpio_t ppc405_gpio_t
;
1580 struct ppc405_gpio_t
{
1581 target_phys_addr_t base
;
1595 static uint32_t ppc405_gpio_readb (void *opaque
, target_phys_addr_t addr
)
1597 ppc405_gpio_t
*gpio
;
1601 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
1607 static void ppc405_gpio_writeb (void *opaque
,
1608 target_phys_addr_t addr
, uint32_t value
)
1610 ppc405_gpio_t
*gpio
;
1614 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
1618 static uint32_t ppc405_gpio_readw (void *opaque
, target_phys_addr_t addr
)
1620 ppc405_gpio_t
*gpio
;
1624 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
1630 static void ppc405_gpio_writew (void *opaque
,
1631 target_phys_addr_t addr
, uint32_t value
)
1633 ppc405_gpio_t
*gpio
;
1637 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
1641 static uint32_t ppc405_gpio_readl (void *opaque
, target_phys_addr_t addr
)
1643 ppc405_gpio_t
*gpio
;
1647 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
1653 static void ppc405_gpio_writel (void *opaque
,
1654 target_phys_addr_t addr
, uint32_t value
)
1656 ppc405_gpio_t
*gpio
;
1660 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
1664 static CPUReadMemoryFunc
*ppc405_gpio_read
[] = {
1670 static CPUWriteMemoryFunc
*ppc405_gpio_write
[] = {
1671 &ppc405_gpio_writeb
,
1672 &ppc405_gpio_writew
,
1673 &ppc405_gpio_writel
,
1676 static void ppc405_gpio_reset (void *opaque
)
1678 ppc405_gpio_t
*gpio
;
1683 void ppc405_gpio_init (CPUState
*env
, ppc4xx_mmio_t
*mmio
,
1684 target_phys_addr_t offset
)
1686 ppc405_gpio_t
*gpio
;
1688 gpio
= qemu_mallocz(sizeof(ppc405_gpio_t
));
1690 gpio
->base
= offset
;
1691 ppc405_gpio_reset(gpio
);
1692 qemu_register_reset(&ppc405_gpio_reset
, gpio
);
1694 printf("%s: offset=" PADDRX
"\n", __func__
, offset
);
1696 ppc4xx_mmio_register(env
, mmio
, offset
, 0x038,
1697 ppc405_gpio_read
, ppc405_gpio_write
, gpio
);
1701 /*****************************************************************************/
1703 static CPUReadMemoryFunc
*serial_mm_read
[] = {
1709 static CPUWriteMemoryFunc
*serial_mm_write
[] = {
1715 void ppc405_serial_init (CPUState
*env
, ppc4xx_mmio_t
*mmio
,
1716 target_phys_addr_t offset
, qemu_irq irq
,
1717 CharDriverState
*chr
)
1722 printf("%s: offset=" PADDRX
"\n", __func__
, offset
);
1724 serial
= serial_mm_init(offset
, 0, irq
, chr
, 0);
1725 ppc4xx_mmio_register(env
, mmio
, offset
, 0x008,
1726 serial_mm_read
, serial_mm_write
, serial
);
1729 /*****************************************************************************/
1730 /* On Chip Memory */
1733 OCM0_ISACNTL
= 0x019,
1735 OCM0_DSACNTL
= 0x01B,
1738 typedef struct ppc405_ocm_t ppc405_ocm_t
;
1739 struct ppc405_ocm_t
{
1740 target_ulong offset
;
1747 static void ocm_update_mappings (ppc405_ocm_t
*ocm
,
1748 uint32_t isarc
, uint32_t isacntl
,
1749 uint32_t dsarc
, uint32_t dsacntl
)
1752 printf("OCM update ISA %08x %08x (%08x %08x) DSA %08x %08x (%08x %08x)\n",
1753 isarc
, isacntl
, dsarc
, dsacntl
,
1754 ocm
->isarc
, ocm
->isacntl
, ocm
->dsarc
, ocm
->dsacntl
);
1756 if (ocm
->isarc
!= isarc
||
1757 (ocm
->isacntl
& 0x80000000) != (isacntl
& 0x80000000)) {
1758 if (ocm
->isacntl
& 0x80000000) {
1759 /* Unmap previously assigned memory region */
1760 printf("OCM unmap ISA %08x\n", ocm
->isarc
);
1761 cpu_register_physical_memory(ocm
->isarc
, 0x04000000,
1764 if (isacntl
& 0x80000000) {
1765 /* Map new instruction memory region */
1767 printf("OCM map ISA %08x\n", isarc
);
1769 cpu_register_physical_memory(isarc
, 0x04000000,
1770 ocm
->offset
| IO_MEM_RAM
);
1773 if (ocm
->dsarc
!= dsarc
||
1774 (ocm
->dsacntl
& 0x80000000) != (dsacntl
& 0x80000000)) {
1775 if (ocm
->dsacntl
& 0x80000000) {
1776 /* Beware not to unmap the region we just mapped */
1777 if (!(isacntl
& 0x80000000) || ocm
->dsarc
!= isarc
) {
1778 /* Unmap previously assigned memory region */
1780 printf("OCM unmap DSA %08x\n", ocm
->dsarc
);
1782 cpu_register_physical_memory(ocm
->dsarc
, 0x04000000,
1786 if (dsacntl
& 0x80000000) {
1787 /* Beware not to remap the region we just mapped */
1788 if (!(isacntl
& 0x80000000) || dsarc
!= isarc
) {
1789 /* Map new data memory region */
1791 printf("OCM map DSA %08x\n", dsarc
);
1793 cpu_register_physical_memory(dsarc
, 0x04000000,
1794 ocm
->offset
| IO_MEM_RAM
);
1800 static target_ulong
dcr_read_ocm (void *opaque
, int dcrn
)
1827 static void dcr_write_ocm (void *opaque
, int dcrn
, target_ulong val
)
1830 uint32_t isarc
, dsarc
, isacntl
, dsacntl
;
1835 isacntl
= ocm
->isacntl
;
1836 dsacntl
= ocm
->dsacntl
;
1839 isarc
= val
& 0xFC000000;
1842 isacntl
= val
& 0xC0000000;
1845 isarc
= val
& 0xFC000000;
1848 isacntl
= val
& 0xC0000000;
1851 ocm_update_mappings(ocm
, isarc
, isacntl
, dsarc
, dsacntl
);
1854 ocm
->isacntl
= isacntl
;
1855 ocm
->dsacntl
= dsacntl
;
1858 static void ocm_reset (void *opaque
)
1861 uint32_t isarc
, dsarc
, isacntl
, dsacntl
;
1865 isacntl
= 0x00000000;
1867 dsacntl
= 0x00000000;
1868 ocm_update_mappings(ocm
, isarc
, isacntl
, dsarc
, dsacntl
);
1871 ocm
->isacntl
= isacntl
;
1872 ocm
->dsacntl
= dsacntl
;
1875 void ppc405_ocm_init (CPUState
*env
, unsigned long offset
)
1879 ocm
= qemu_mallocz(sizeof(ppc405_ocm_t
));
1881 ocm
->offset
= offset
;
1883 qemu_register_reset(&ocm_reset
, ocm
);
1884 ppc_dcr_register(env
, OCM0_ISARC
,
1885 ocm
, &dcr_read_ocm
, &dcr_write_ocm
);
1886 ppc_dcr_register(env
, OCM0_ISACNTL
,
1887 ocm
, &dcr_read_ocm
, &dcr_write_ocm
);
1888 ppc_dcr_register(env
, OCM0_DSARC
,
1889 ocm
, &dcr_read_ocm
, &dcr_write_ocm
);
1890 ppc_dcr_register(env
, OCM0_DSACNTL
,
1891 ocm
, &dcr_read_ocm
, &dcr_write_ocm
);
1895 /*****************************************************************************/
1896 /* I2C controller */
1897 typedef struct ppc4xx_i2c_t ppc4xx_i2c_t
;
1898 struct ppc4xx_i2c_t
{
1899 target_phys_addr_t base
;
1918 static uint32_t ppc4xx_i2c_readb (void *opaque
, target_phys_addr_t addr
)
1924 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
1927 switch (addr
- i2c
->base
) {
1929 // i2c_readbyte(&i2c->mdata);
1969 ret
= i2c
->xtcntlss
;
1972 ret
= i2c
->directcntl
;
1979 printf("%s: addr " PADDRX
" %02x\n", __func__
, addr
, ret
);
1985 static void ppc4xx_i2c_writeb (void *opaque
,
1986 target_phys_addr_t addr
, uint32_t value
)
1991 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
1994 switch (addr
- i2c
->base
) {
1997 // i2c_sendbyte(&i2c->mdata);
2012 i2c
->mdcntl
= value
& 0xDF;
2015 i2c
->sts
&= ~(value
& 0x0A);
2018 i2c
->extsts
&= ~(value
& 0x8F);
2027 i2c
->clkdiv
= value
;
2030 i2c
->intrmsk
= value
;
2033 i2c
->xfrcnt
= value
& 0x77;
2036 i2c
->xtcntlss
= value
;
2039 i2c
->directcntl
= value
& 0x7;
2044 static uint32_t ppc4xx_i2c_readw (void *opaque
, target_phys_addr_t addr
)
2049 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
2051 ret
= ppc4xx_i2c_readb(opaque
, addr
) << 8;
2052 ret
|= ppc4xx_i2c_readb(opaque
, addr
+ 1);
2057 static void ppc4xx_i2c_writew (void *opaque
,
2058 target_phys_addr_t addr
, uint32_t value
)
2061 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
2063 ppc4xx_i2c_writeb(opaque
, addr
, value
>> 8);
2064 ppc4xx_i2c_writeb(opaque
, addr
+ 1, value
);
2067 static uint32_t ppc4xx_i2c_readl (void *opaque
, target_phys_addr_t addr
)
2072 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
2074 ret
= ppc4xx_i2c_readb(opaque
, addr
) << 24;
2075 ret
|= ppc4xx_i2c_readb(opaque
, addr
+ 1) << 16;
2076 ret
|= ppc4xx_i2c_readb(opaque
, addr
+ 2) << 8;
2077 ret
|= ppc4xx_i2c_readb(opaque
, addr
+ 3);
2082 static void ppc4xx_i2c_writel (void *opaque
,
2083 target_phys_addr_t addr
, uint32_t value
)
2086 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
2088 ppc4xx_i2c_writeb(opaque
, addr
, value
>> 24);
2089 ppc4xx_i2c_writeb(opaque
, addr
+ 1, value
>> 16);
2090 ppc4xx_i2c_writeb(opaque
, addr
+ 2, value
>> 8);
2091 ppc4xx_i2c_writeb(opaque
, addr
+ 3, value
);
2094 static CPUReadMemoryFunc
*i2c_read
[] = {
2100 static CPUWriteMemoryFunc
*i2c_write
[] = {
2106 static void ppc4xx_i2c_reset (void *opaque
)
2119 i2c
->directcntl
= 0x0F;
2122 void ppc405_i2c_init (CPUState
*env
, ppc4xx_mmio_t
*mmio
,
2123 target_phys_addr_t offset
, qemu_irq irq
)
2127 i2c
= qemu_mallocz(sizeof(ppc4xx_i2c_t
));
2131 ppc4xx_i2c_reset(i2c
);
2133 printf("%s: offset=" PADDRX
"\n", __func__
, offset
);
2135 ppc4xx_mmio_register(env
, mmio
, offset
, 0x011,
2136 i2c_read
, i2c_write
, i2c
);
2137 qemu_register_reset(ppc4xx_i2c_reset
, i2c
);
2141 /*****************************************************************************/
2142 /* General purpose timers */
2143 typedef struct ppc4xx_gpt_t ppc4xx_gpt_t
;
2144 struct ppc4xx_gpt_t
{
2145 target_phys_addr_t base
;
2148 struct QEMUTimer
*timer
;
2159 static uint32_t ppc4xx_gpt_readb (void *opaque
, target_phys_addr_t addr
)
2162 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
2164 /* XXX: generate a bus fault */
2168 static void ppc4xx_gpt_writeb (void *opaque
,
2169 target_phys_addr_t addr
, uint32_t value
)
2172 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
2174 /* XXX: generate a bus fault */
2177 static uint32_t ppc4xx_gpt_readw (void *opaque
, target_phys_addr_t addr
)
2180 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
2182 /* XXX: generate a bus fault */
2186 static void ppc4xx_gpt_writew (void *opaque
,
2187 target_phys_addr_t addr
, uint32_t value
)
2190 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
2192 /* XXX: generate a bus fault */
2195 static int ppc4xx_gpt_compare (ppc4xx_gpt_t
*gpt
, int n
)
2201 static void ppc4xx_gpt_set_output (ppc4xx_gpt_t
*gpt
, int n
, int level
)
2206 static void ppc4xx_gpt_set_outputs (ppc4xx_gpt_t
*gpt
)
2212 for (i
= 0; i
< 5; i
++) {
2213 if (gpt
->oe
& mask
) {
2214 /* Output is enabled */
2215 if (ppc4xx_gpt_compare(gpt
, i
)) {
2216 /* Comparison is OK */
2217 ppc4xx_gpt_set_output(gpt
, i
, gpt
->ol
& mask
);
2219 /* Comparison is KO */
2220 ppc4xx_gpt_set_output(gpt
, i
, gpt
->ol
& mask
? 0 : 1);
2227 static void ppc4xx_gpt_set_irqs (ppc4xx_gpt_t
*gpt
)
2233 for (i
= 0; i
< 5; i
++) {
2234 if (gpt
->is
& gpt
->im
& mask
)
2235 qemu_irq_raise(gpt
->irqs
[i
]);
2237 qemu_irq_lower(gpt
->irqs
[i
]);
2242 static void ppc4xx_gpt_compute_timer (ppc4xx_gpt_t
*gpt
)
2247 static uint32_t ppc4xx_gpt_readl (void *opaque
, target_phys_addr_t addr
)
2254 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
2257 switch (addr
- gpt
->base
) {
2259 /* Time base counter */
2260 ret
= muldiv64(qemu_get_clock(vm_clock
) + gpt
->tb_offset
,
2261 gpt
->tb_freq
, ticks_per_sec
);
2272 /* Interrupt mask */
2277 /* Interrupt status */
2281 /* Interrupt enable */
2286 idx
= ((addr
- gpt
->base
) - 0x80) >> 2;
2287 ret
= gpt
->comp
[idx
];
2291 idx
= ((addr
- gpt
->base
) - 0xC0) >> 2;
2292 ret
= gpt
->mask
[idx
];
2302 static void ppc4xx_gpt_writel (void *opaque
,
2303 target_phys_addr_t addr
, uint32_t value
)
2309 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
2312 switch (addr
- gpt
->base
) {
2314 /* Time base counter */
2315 gpt
->tb_offset
= muldiv64(value
, ticks_per_sec
, gpt
->tb_freq
)
2316 - qemu_get_clock(vm_clock
);
2317 ppc4xx_gpt_compute_timer(gpt
);
2321 gpt
->oe
= value
& 0xF8000000;
2322 ppc4xx_gpt_set_outputs(gpt
);
2326 gpt
->ol
= value
& 0xF8000000;
2327 ppc4xx_gpt_set_outputs(gpt
);
2330 /* Interrupt mask */
2331 gpt
->im
= value
& 0x0000F800;
2334 /* Interrupt status set */
2335 gpt
->is
|= value
& 0x0000F800;
2336 ppc4xx_gpt_set_irqs(gpt
);
2339 /* Interrupt status clear */
2340 gpt
->is
&= ~(value
& 0x0000F800);
2341 ppc4xx_gpt_set_irqs(gpt
);
2344 /* Interrupt enable */
2345 gpt
->ie
= value
& 0x0000F800;
2346 ppc4xx_gpt_set_irqs(gpt
);
2350 idx
= ((addr
- gpt
->base
) - 0x80) >> 2;
2351 gpt
->comp
[idx
] = value
& 0xF8000000;
2352 ppc4xx_gpt_compute_timer(gpt
);
2356 idx
= ((addr
- gpt
->base
) - 0xC0) >> 2;
2357 gpt
->mask
[idx
] = value
& 0xF8000000;
2358 ppc4xx_gpt_compute_timer(gpt
);
2363 static CPUReadMemoryFunc
*gpt_read
[] = {
2369 static CPUWriteMemoryFunc
*gpt_write
[] = {
2375 static void ppc4xx_gpt_cb (void *opaque
)
2380 ppc4xx_gpt_set_irqs(gpt
);
2381 ppc4xx_gpt_set_outputs(gpt
);
2382 ppc4xx_gpt_compute_timer(gpt
);
2385 static void ppc4xx_gpt_reset (void *opaque
)
2391 qemu_del_timer(gpt
->timer
);
2392 gpt
->oe
= 0x00000000;
2393 gpt
->ol
= 0x00000000;
2394 gpt
->im
= 0x00000000;
2395 gpt
->is
= 0x00000000;
2396 gpt
->ie
= 0x00000000;
2397 for (i
= 0; i
< 5; i
++) {
2398 gpt
->comp
[i
] = 0x00000000;
2399 gpt
->mask
[i
] = 0x00000000;
2403 void ppc4xx_gpt_init (CPUState
*env
, ppc4xx_mmio_t
*mmio
,
2404 target_phys_addr_t offset
, qemu_irq irqs
[5])
2409 gpt
= qemu_mallocz(sizeof(ppc4xx_gpt_t
));
2412 for (i
= 0; i
< 5; i
++)
2413 gpt
->irqs
[i
] = irqs
[i
];
2414 gpt
->timer
= qemu_new_timer(vm_clock
, &ppc4xx_gpt_cb
, gpt
);
2415 ppc4xx_gpt_reset(gpt
);
2417 printf("%s: offset=" PADDRX
"\n", __func__
, offset
);
2419 ppc4xx_mmio_register(env
, mmio
, offset
, 0x0D4,
2420 gpt_read
, gpt_write
, gpt
);
2421 qemu_register_reset(ppc4xx_gpt_reset
, gpt
);
2425 /*****************************************************************************/
2431 MAL0_TXCASR
= 0x184,
2432 MAL0_TXCARR
= 0x185,
2433 MAL0_TXEOBISR
= 0x186,
2434 MAL0_TXDEIR
= 0x187,
2435 MAL0_RXCASR
= 0x190,
2436 MAL0_RXCARR
= 0x191,
2437 MAL0_RXEOBISR
= 0x192,
2438 MAL0_RXDEIR
= 0x193,
2439 MAL0_TXCTP0R
= 0x1A0,
2440 MAL0_TXCTP1R
= 0x1A1,
2441 MAL0_TXCTP2R
= 0x1A2,
2442 MAL0_TXCTP3R
= 0x1A3,
2443 MAL0_RXCTP0R
= 0x1C0,
2444 MAL0_RXCTP1R
= 0x1C1,
2449 typedef struct ppc40x_mal_t ppc40x_mal_t
;
2450 struct ppc40x_mal_t
{
2468 static void ppc40x_mal_reset (void *opaque
);
2470 static target_ulong
dcr_read_mal (void *opaque
, int dcrn
)
2493 ret
= mal
->txeobisr
;
2505 ret
= mal
->rxeobisr
;
2511 ret
= mal
->txctpr
[0];
2514 ret
= mal
->txctpr
[1];
2517 ret
= mal
->txctpr
[2];
2520 ret
= mal
->txctpr
[3];
2523 ret
= mal
->rxctpr
[0];
2526 ret
= mal
->rxctpr
[1];
2542 static void dcr_write_mal (void *opaque
, int dcrn
, target_ulong val
)
2550 if (val
& 0x80000000)
2551 ppc40x_mal_reset(mal
);
2552 mal
->cfg
= val
& 0x00FFC087;
2559 mal
->ier
= val
& 0x0000001F;
2562 mal
->txcasr
= val
& 0xF0000000;
2565 mal
->txcarr
= val
& 0xF0000000;
2569 mal
->txeobisr
&= ~val
;
2573 mal
->txdeir
&= ~val
;
2576 mal
->rxcasr
= val
& 0xC0000000;
2579 mal
->rxcarr
= val
& 0xC0000000;
2583 mal
->rxeobisr
&= ~val
;
2587 mal
->rxdeir
&= ~val
;
2601 mal
->txctpr
[idx
] = val
;
2609 mal
->rxctpr
[idx
] = val
;
2613 goto update_rx_size
;
2617 mal
->rcbs
[idx
] = val
& 0x000000FF;
2622 static void ppc40x_mal_reset (void *opaque
)
2627 mal
->cfg
= 0x0007C000;
2628 mal
->esr
= 0x00000000;
2629 mal
->ier
= 0x00000000;
2630 mal
->rxcasr
= 0x00000000;
2631 mal
->rxdeir
= 0x00000000;
2632 mal
->rxeobisr
= 0x00000000;
2633 mal
->txcasr
= 0x00000000;
2634 mal
->txdeir
= 0x00000000;
2635 mal
->txeobisr
= 0x00000000;
2638 void ppc405_mal_init (CPUState
*env
, qemu_irq irqs
[4])
2643 mal
= qemu_mallocz(sizeof(ppc40x_mal_t
));
2645 for (i
= 0; i
< 4; i
++)
2646 mal
->irqs
[i
] = irqs
[i
];
2647 ppc40x_mal_reset(mal
);
2648 qemu_register_reset(&ppc40x_mal_reset
, mal
);
2649 ppc_dcr_register(env
, MAL0_CFG
,
2650 mal
, &dcr_read_mal
, &dcr_write_mal
);
2651 ppc_dcr_register(env
, MAL0_ESR
,
2652 mal
, &dcr_read_mal
, &dcr_write_mal
);
2653 ppc_dcr_register(env
, MAL0_IER
,
2654 mal
, &dcr_read_mal
, &dcr_write_mal
);
2655 ppc_dcr_register(env
, MAL0_TXCASR
,
2656 mal
, &dcr_read_mal
, &dcr_write_mal
);
2657 ppc_dcr_register(env
, MAL0_TXCARR
,
2658 mal
, &dcr_read_mal
, &dcr_write_mal
);
2659 ppc_dcr_register(env
, MAL0_TXEOBISR
,
2660 mal
, &dcr_read_mal
, &dcr_write_mal
);
2661 ppc_dcr_register(env
, MAL0_TXDEIR
,
2662 mal
, &dcr_read_mal
, &dcr_write_mal
);
2663 ppc_dcr_register(env
, MAL0_RXCASR
,
2664 mal
, &dcr_read_mal
, &dcr_write_mal
);
2665 ppc_dcr_register(env
, MAL0_RXCARR
,
2666 mal
, &dcr_read_mal
, &dcr_write_mal
);
2667 ppc_dcr_register(env
, MAL0_RXEOBISR
,
2668 mal
, &dcr_read_mal
, &dcr_write_mal
);
2669 ppc_dcr_register(env
, MAL0_RXDEIR
,
2670 mal
, &dcr_read_mal
, &dcr_write_mal
);
2671 ppc_dcr_register(env
, MAL0_TXCTP0R
,
2672 mal
, &dcr_read_mal
, &dcr_write_mal
);
2673 ppc_dcr_register(env
, MAL0_TXCTP1R
,
2674 mal
, &dcr_read_mal
, &dcr_write_mal
);
2675 ppc_dcr_register(env
, MAL0_TXCTP2R
,
2676 mal
, &dcr_read_mal
, &dcr_write_mal
);
2677 ppc_dcr_register(env
, MAL0_TXCTP3R
,
2678 mal
, &dcr_read_mal
, &dcr_write_mal
);
2679 ppc_dcr_register(env
, MAL0_RXCTP0R
,
2680 mal
, &dcr_read_mal
, &dcr_write_mal
);
2681 ppc_dcr_register(env
, MAL0_RXCTP1R
,
2682 mal
, &dcr_read_mal
, &dcr_write_mal
);
2683 ppc_dcr_register(env
, MAL0_RCBS0
,
2684 mal
, &dcr_read_mal
, &dcr_write_mal
);
2685 ppc_dcr_register(env
, MAL0_RCBS1
,
2686 mal
, &dcr_read_mal
, &dcr_write_mal
);
2690 /*****************************************************************************/
2692 void ppc40x_core_reset (CPUState
*env
)
2696 printf("Reset PowerPC core\n");
2698 dbsr
= env
->spr
[SPR_40x_DBSR
];
2699 dbsr
&= ~0x00000300;
2701 env
->spr
[SPR_40x_DBSR
] = dbsr
;
2705 void ppc40x_chip_reset (CPUState
*env
)
2709 printf("Reset PowerPC chip\n");
2711 /* XXX: TODO reset all internal peripherals */
2712 dbsr
= env
->spr
[SPR_40x_DBSR
];
2713 dbsr
&= ~0x00000300;
2715 env
->spr
[SPR_40x_DBSR
] = dbsr
;
2719 void ppc40x_system_reset (CPUState
*env
)
2721 printf("Reset PowerPC system\n");
2722 qemu_system_reset_request();
2725 void store_40x_dbcr0 (CPUState
*env
, uint32_t val
)
2727 switch ((val
>> 28) & 0x3) {
2733 ppc40x_core_reset(env
);
2737 ppc40x_chip_reset(env
);
2741 ppc40x_system_reset(env
);
2746 /*****************************************************************************/
2749 PPC405CR_CPC0_PLLMR
= 0x0B0,
2750 PPC405CR_CPC0_CR0
= 0x0B1,
2751 PPC405CR_CPC0_CR1
= 0x0B2,
2752 PPC405CR_CPC0_PSR
= 0x0B4,
2753 PPC405CR_CPC0_JTAGID
= 0x0B5,
2754 PPC405CR_CPC0_ER
= 0x0B9,
2755 PPC405CR_CPC0_FR
= 0x0BA,
2756 PPC405CR_CPC0_SR
= 0x0BB,
2760 PPC405CR_CPU_CLK
= 0,
2761 PPC405CR_TMR_CLK
= 1,
2762 PPC405CR_PLB_CLK
= 2,
2763 PPC405CR_SDRAM_CLK
= 3,
2764 PPC405CR_OPB_CLK
= 4,
2765 PPC405CR_EXT_CLK
= 5,
2766 PPC405CR_UART_CLK
= 6,
2767 PPC405CR_CLK_NB
= 7,
2770 typedef struct ppc405cr_cpc_t ppc405cr_cpc_t
;
2771 struct ppc405cr_cpc_t
{
2772 clk_setup_t clk_setup
[PPC405CR_CLK_NB
];
2783 static void ppc405cr_clk_setup (ppc405cr_cpc_t
*cpc
)
2785 uint64_t VCO_out
, PLL_out
;
2786 uint32_t CPU_clk
, TMR_clk
, SDRAM_clk
, PLB_clk
, OPB_clk
, EXT_clk
, UART_clk
;
2789 D0
= ((cpc
->pllmr
>> 26) & 0x3) + 1; /* CBDV */
2790 if (cpc
->pllmr
& 0x80000000) {
2791 D1
= (((cpc
->pllmr
>> 20) - 1) & 0xF) + 1; /* FBDV */
2792 D2
= 8 - ((cpc
->pllmr
>> 16) & 0x7); /* FWDVA */
2794 VCO_out
= cpc
->sysclk
* M
;
2795 if (VCO_out
< 400000000 || VCO_out
> 800000000) {
2796 /* PLL cannot lock */
2797 cpc
->pllmr
&= ~0x80000000;
2800 PLL_out
= VCO_out
/ D2
;
2805 PLL_out
= cpc
->sysclk
* M
;
2808 if (cpc
->cr1
& 0x00800000)
2809 TMR_clk
= cpc
->sysclk
; /* Should have a separate clock */
2812 PLB_clk
= CPU_clk
/ D0
;
2813 SDRAM_clk
= PLB_clk
;
2814 D0
= ((cpc
->pllmr
>> 10) & 0x3) + 1;
2815 OPB_clk
= PLB_clk
/ D0
;
2816 D0
= ((cpc
->pllmr
>> 24) & 0x3) + 2;
2817 EXT_clk
= PLB_clk
/ D0
;
2818 D0
= ((cpc
->cr0
>> 1) & 0x1F) + 1;
2819 UART_clk
= CPU_clk
/ D0
;
2820 /* Setup CPU clocks */
2821 clk_setup(&cpc
->clk_setup
[PPC405CR_CPU_CLK
], CPU_clk
);
2822 /* Setup time-base clock */
2823 clk_setup(&cpc
->clk_setup
[PPC405CR_TMR_CLK
], TMR_clk
);
2824 /* Setup PLB clock */
2825 clk_setup(&cpc
->clk_setup
[PPC405CR_PLB_CLK
], PLB_clk
);
2826 /* Setup SDRAM clock */
2827 clk_setup(&cpc
->clk_setup
[PPC405CR_SDRAM_CLK
], SDRAM_clk
);
2828 /* Setup OPB clock */
2829 clk_setup(&cpc
->clk_setup
[PPC405CR_OPB_CLK
], OPB_clk
);
2830 /* Setup external clock */
2831 clk_setup(&cpc
->clk_setup
[PPC405CR_EXT_CLK
], EXT_clk
);
2832 /* Setup UART clock */
2833 clk_setup(&cpc
->clk_setup
[PPC405CR_UART_CLK
], UART_clk
);
2836 static target_ulong
dcr_read_crcpc (void *opaque
, int dcrn
)
2838 ppc405cr_cpc_t
*cpc
;
2843 case PPC405CR_CPC0_PLLMR
:
2846 case PPC405CR_CPC0_CR0
:
2849 case PPC405CR_CPC0_CR1
:
2852 case PPC405CR_CPC0_PSR
:
2855 case PPC405CR_CPC0_JTAGID
:
2858 case PPC405CR_CPC0_ER
:
2861 case PPC405CR_CPC0_FR
:
2864 case PPC405CR_CPC0_SR
:
2865 ret
= ~(cpc
->er
| cpc
->fr
) & 0xFFFF0000;
2868 /* Avoid gcc warning */
2876 static void dcr_write_crcpc (void *opaque
, int dcrn
, target_ulong val
)
2878 ppc405cr_cpc_t
*cpc
;
2882 case PPC405CR_CPC0_PLLMR
:
2883 cpc
->pllmr
= val
& 0xFFF77C3F;
2885 case PPC405CR_CPC0_CR0
:
2886 cpc
->cr0
= val
& 0x0FFFFFFE;
2888 case PPC405CR_CPC0_CR1
:
2889 cpc
->cr1
= val
& 0x00800000;
2891 case PPC405CR_CPC0_PSR
:
2894 case PPC405CR_CPC0_JTAGID
:
2897 case PPC405CR_CPC0_ER
:
2898 cpc
->er
= val
& 0xBFFC0000;
2900 case PPC405CR_CPC0_FR
:
2901 cpc
->fr
= val
& 0xBFFC0000;
2903 case PPC405CR_CPC0_SR
:
2909 static void ppc405cr_cpc_reset (void *opaque
)
2911 ppc405cr_cpc_t
*cpc
;
2915 /* Compute PLLMR value from PSR settings */
2916 cpc
->pllmr
= 0x80000000;
2918 switch ((cpc
->psr
>> 30) & 3) {
2921 cpc
->pllmr
&= ~0x80000000;
2925 cpc
->pllmr
|= 5 << 16;
2929 cpc
->pllmr
|= 4 << 16;
2933 cpc
->pllmr
|= 2 << 16;
2937 D
= (cpc
->psr
>> 28) & 3;
2938 cpc
->pllmr
|= (D
+ 1) << 20;
2940 D
= (cpc
->psr
>> 25) & 7;
2955 D
= (cpc
->psr
>> 23) & 3;
2956 cpc
->pllmr
|= D
<< 26;
2958 D
= (cpc
->psr
>> 21) & 3;
2959 cpc
->pllmr
|= D
<< 10;
2961 D
= (cpc
->psr
>> 17) & 3;
2962 cpc
->pllmr
|= D
<< 24;
2963 cpc
->cr0
= 0x0000003C;
2964 cpc
->cr1
= 0x2B0D8800;
2965 cpc
->er
= 0x00000000;
2966 cpc
->fr
= 0x00000000;
2967 ppc405cr_clk_setup(cpc
);
2970 static void ppc405cr_clk_init (ppc405cr_cpc_t
*cpc
)
2974 /* XXX: this should be read from IO pins */
2975 cpc
->psr
= 0x00000000; /* 8 bits ROM */
2977 D
= 0x2; /* Divide by 4 */
2978 cpc
->psr
|= D
<< 30;
2980 D
= 0x1; /* Divide by 2 */
2981 cpc
->psr
|= D
<< 28;
2983 D
= 0x1; /* Divide by 2 */
2984 cpc
->psr
|= D
<< 23;
2986 D
= 0x5; /* M = 16 */
2987 cpc
->psr
|= D
<< 25;
2989 D
= 0x1; /* Divide by 2 */
2990 cpc
->psr
|= D
<< 21;
2992 D
= 0x2; /* Divide by 4 */
2993 cpc
->psr
|= D
<< 17;
2996 static void ppc405cr_cpc_init (CPUState
*env
, clk_setup_t clk_setup
[7],
2999 ppc405cr_cpc_t
*cpc
;
3001 cpc
= qemu_mallocz(sizeof(ppc405cr_cpc_t
));
3003 memcpy(cpc
->clk_setup
, clk_setup
,
3004 PPC405CR_CLK_NB
* sizeof(clk_setup_t
));
3005 cpc
->sysclk
= sysclk
;
3006 cpc
->jtagid
= 0x42051049;
3007 ppc_dcr_register(env
, PPC405CR_CPC0_PSR
, cpc
,
3008 &dcr_read_crcpc
, &dcr_write_crcpc
);
3009 ppc_dcr_register(env
, PPC405CR_CPC0_CR0
, cpc
,
3010 &dcr_read_crcpc
, &dcr_write_crcpc
);
3011 ppc_dcr_register(env
, PPC405CR_CPC0_CR1
, cpc
,
3012 &dcr_read_crcpc
, &dcr_write_crcpc
);
3013 ppc_dcr_register(env
, PPC405CR_CPC0_JTAGID
, cpc
,
3014 &dcr_read_crcpc
, &dcr_write_crcpc
);
3015 ppc_dcr_register(env
, PPC405CR_CPC0_PLLMR
, cpc
,
3016 &dcr_read_crcpc
, &dcr_write_crcpc
);
3017 ppc_dcr_register(env
, PPC405CR_CPC0_ER
, cpc
,
3018 &dcr_read_crcpc
, &dcr_write_crcpc
);
3019 ppc_dcr_register(env
, PPC405CR_CPC0_FR
, cpc
,
3020 &dcr_read_crcpc
, &dcr_write_crcpc
);
3021 ppc_dcr_register(env
, PPC405CR_CPC0_SR
, cpc
,
3022 &dcr_read_crcpc
, &dcr_write_crcpc
);
3023 ppc405cr_clk_init(cpc
);
3024 qemu_register_reset(ppc405cr_cpc_reset
, cpc
);
3025 ppc405cr_cpc_reset(cpc
);
3029 CPUState
*ppc405cr_init (target_phys_addr_t ram_bases
[4],
3030 target_phys_addr_t ram_sizes
[4],
3031 uint32_t sysclk
, qemu_irq
**picp
,
3032 ram_addr_t
*offsetp
, int do_init
)
3034 clk_setup_t clk_setup
[PPC405CR_CLK_NB
];
3035 qemu_irq dma_irqs
[4];
3037 ppc4xx_mmio_t
*mmio
;
3038 qemu_irq
*pic
, *irqs
;
3042 memset(clk_setup
, 0, sizeof(clk_setup
));
3043 env
= ppc405_init("405cr", &clk_setup
[PPC405CR_CPU_CLK
],
3044 &clk_setup
[PPC405CR_TMR_CLK
], sysclk
);
3045 /* Memory mapped devices registers */
3046 mmio
= ppc4xx_mmio_init(env
, 0xEF600000);
3048 ppc4xx_plb_init(env
);
3049 /* PLB to OPB bridge */
3050 ppc4xx_pob_init(env
);
3052 ppc4xx_opba_init(env
, mmio
, 0x600);
3053 /* Universal interrupt controller */
3054 irqs
= qemu_mallocz(sizeof(qemu_irq
) * PPCUIC_OUTPUT_NB
);
3055 irqs
[PPCUIC_OUTPUT_INT
] =
3056 ((qemu_irq
*)env
->irq_inputs
)[PPC40x_INPUT_INT
];
3057 irqs
[PPCUIC_OUTPUT_CINT
] =
3058 ((qemu_irq
*)env
->irq_inputs
)[PPC40x_INPUT_CINT
];
3059 pic
= ppcuic_init(env
, irqs
, 0x0C0, 0, 1);
3061 /* SDRAM controller */
3062 ppc405_sdram_init(env
, pic
[14], 1, ram_bases
, ram_sizes
, do_init
);
3064 for (i
= 0; i
< 4; i
++)
3065 offset
+= ram_sizes
[i
];
3066 /* External bus controller */
3067 ppc405_ebc_init(env
);
3068 /* DMA controller */
3069 dma_irqs
[0] = pic
[26];
3070 dma_irqs
[1] = pic
[25];
3071 dma_irqs
[2] = pic
[24];
3072 dma_irqs
[3] = pic
[23];
3073 ppc405_dma_init(env
, dma_irqs
);
3075 if (serial_hds
[0] != NULL
) {
3076 ppc405_serial_init(env
, mmio
, 0x300, pic
[31], serial_hds
[0]);
3078 if (serial_hds
[1] != NULL
) {
3079 ppc405_serial_init(env
, mmio
, 0x400, pic
[30], serial_hds
[1]);
3081 /* IIC controller */
3082 ppc405_i2c_init(env
, mmio
, 0x500, pic
[29]);
3084 ppc405_gpio_init(env
, mmio
, 0x700);
3086 ppc405cr_cpc_init(env
, clk_setup
, sysclk
);
3092 /*****************************************************************************/
3096 PPC405EP_CPC0_PLLMR0
= 0x0F0,
3097 PPC405EP_CPC0_BOOT
= 0x0F1,
3098 PPC405EP_CPC0_EPCTL
= 0x0F3,
3099 PPC405EP_CPC0_PLLMR1
= 0x0F4,
3100 PPC405EP_CPC0_UCR
= 0x0F5,
3101 PPC405EP_CPC0_SRR
= 0x0F6,
3102 PPC405EP_CPC0_JTAGID
= 0x0F7,
3103 PPC405EP_CPC0_PCI
= 0x0F9,
3105 PPC405EP_CPC0_ER
= xxx
,
3106 PPC405EP_CPC0_FR
= xxx
,
3107 PPC405EP_CPC0_SR
= xxx
,
3112 PPC405EP_CPU_CLK
= 0,
3113 PPC405EP_PLB_CLK
= 1,
3114 PPC405EP_OPB_CLK
= 2,
3115 PPC405EP_EBC_CLK
= 3,
3116 PPC405EP_MAL_CLK
= 4,
3117 PPC405EP_PCI_CLK
= 5,
3118 PPC405EP_UART0_CLK
= 6,
3119 PPC405EP_UART1_CLK
= 7,
3120 PPC405EP_CLK_NB
= 8,
3123 typedef struct ppc405ep_cpc_t ppc405ep_cpc_t
;
3124 struct ppc405ep_cpc_t
{
3126 clk_setup_t clk_setup
[PPC405EP_CLK_NB
];
3134 /* Clock and power management */
3140 static void ppc405ep_compute_clocks (ppc405ep_cpc_t
*cpc
)
3142 uint32_t CPU_clk
, PLB_clk
, OPB_clk
, EBC_clk
, MAL_clk
, PCI_clk
;
3143 uint32_t UART0_clk
, UART1_clk
;
3144 uint64_t VCO_out
, PLL_out
;
3148 if ((cpc
->pllmr
[1] & 0x80000000) && !(cpc
->pllmr
[1] & 0x40000000)) {
3149 M
= (((cpc
->pllmr
[1] >> 20) - 1) & 0xF) + 1; /* FBMUL */
3150 // printf("FBMUL %01x %d\n", (cpc->pllmr[1] >> 20) & 0xF, M);
3151 D
= 8 - ((cpc
->pllmr
[1] >> 16) & 0x7); /* FWDA */
3152 // printf("FWDA %01x %d\n", (cpc->pllmr[1] >> 16) & 0x7, D);
3153 VCO_out
= cpc
->sysclk
* M
* D
;
3154 if (VCO_out
< 500000000UL || VCO_out
> 1000000000UL) {
3155 /* Error - unlock the PLL */
3156 printf("VCO out of range %" PRIu64
"\n", VCO_out
);
3158 cpc
->pllmr
[1] &= ~0x80000000;
3162 PLL_out
= VCO_out
/ D
;
3163 /* Pretend the PLL is locked */
3164 cpc
->boot
|= 0x00000001;
3169 PLL_out
= cpc
->sysclk
;
3170 if (cpc
->pllmr
[1] & 0x40000000) {
3171 /* Pretend the PLL is not locked */
3172 cpc
->boot
&= ~0x00000001;
3175 /* Now, compute all other clocks */
3176 D
= ((cpc
->pllmr
[0] >> 20) & 0x3) + 1; /* CCDV */
3178 // printf("CCDV %01x %d\n", (cpc->pllmr[0] >> 20) & 0x3, D);
3180 CPU_clk
= PLL_out
/ D
;
3181 D
= ((cpc
->pllmr
[0] >> 16) & 0x3) + 1; /* CBDV */
3183 // printf("CBDV %01x %d\n", (cpc->pllmr[0] >> 16) & 0x3, D);
3185 PLB_clk
= CPU_clk
/ D
;
3186 D
= ((cpc
->pllmr
[0] >> 12) & 0x3) + 1; /* OPDV */
3188 // printf("OPDV %01x %d\n", (cpc->pllmr[0] >> 12) & 0x3, D);
3190 OPB_clk
= PLB_clk
/ D
;
3191 D
= ((cpc
->pllmr
[0] >> 8) & 0x3) + 2; /* EPDV */
3193 // printf("EPDV %01x %d\n", (cpc->pllmr[0] >> 8) & 0x3, D);
3195 EBC_clk
= PLB_clk
/ D
;
3196 D
= ((cpc
->pllmr
[0] >> 4) & 0x3) + 1; /* MPDV */
3198 // printf("MPDV %01x %d\n", (cpc->pllmr[0] >> 4) & 0x3, D);
3200 MAL_clk
= PLB_clk
/ D
;
3201 D
= (cpc
->pllmr
[0] & 0x3) + 1; /* PPDV */
3203 // printf("PPDV %01x %d\n", cpc->pllmr[0] & 0x3, D);
3205 PCI_clk
= PLB_clk
/ D
;
3206 D
= ((cpc
->ucr
- 1) & 0x7F) + 1; /* U0DIV */
3208 // printf("U0DIV %01x %d\n", cpc->ucr & 0x7F, D);
3210 UART0_clk
= PLL_out
/ D
;
3211 D
= (((cpc
->ucr
>> 8) - 1) & 0x7F) + 1; /* U1DIV */
3213 // printf("U1DIV %01x %d\n", (cpc->ucr >> 8) & 0x7F, D);
3215 UART1_clk
= PLL_out
/ D
;
3217 printf("Setup PPC405EP clocks - sysclk %d VCO %" PRIu64
3218 " PLL out %" PRIu64
" Hz\n", cpc
->sysclk
, VCO_out
, PLL_out
);
3219 printf("CPU %d PLB %d OPB %d EBC %d MAL %d PCI %d UART0 %d UART1 %d\n",
3220 CPU_clk
, PLB_clk
, OPB_clk
, EBC_clk
, MAL_clk
, PCI_clk
,
3221 UART0_clk
, UART1_clk
);
3222 printf("CB %p opaque %p\n", cpc
->clk_setup
[PPC405EP_CPU_CLK
].cb
,
3223 cpc
->clk_setup
[PPC405EP_CPU_CLK
].opaque
);
3225 /* Setup CPU clocks */
3226 clk_setup(&cpc
->clk_setup
[PPC405EP_CPU_CLK
], CPU_clk
);
3227 /* Setup PLB clock */
3228 clk_setup(&cpc
->clk_setup
[PPC405EP_PLB_CLK
], PLB_clk
);
3229 /* Setup OPB clock */
3230 clk_setup(&cpc
->clk_setup
[PPC405EP_OPB_CLK
], OPB_clk
);
3231 /* Setup external clock */
3232 clk_setup(&cpc
->clk_setup
[PPC405EP_EBC_CLK
], EBC_clk
);
3233 /* Setup MAL clock */
3234 clk_setup(&cpc
->clk_setup
[PPC405EP_MAL_CLK
], MAL_clk
);
3235 /* Setup PCI clock */
3236 clk_setup(&cpc
->clk_setup
[PPC405EP_PCI_CLK
], PCI_clk
);
3237 /* Setup UART0 clock */
3238 clk_setup(&cpc
->clk_setup
[PPC405EP_UART0_CLK
], UART0_clk
);
3239 /* Setup UART1 clock */
3240 clk_setup(&cpc
->clk_setup
[PPC405EP_UART1_CLK
], UART1_clk
);
3243 static target_ulong
dcr_read_epcpc (void *opaque
, int dcrn
)
3245 ppc405ep_cpc_t
*cpc
;
3250 case PPC405EP_CPC0_BOOT
:
3253 case PPC405EP_CPC0_EPCTL
:
3256 case PPC405EP_CPC0_PLLMR0
:
3257 ret
= cpc
->pllmr
[0];
3259 case PPC405EP_CPC0_PLLMR1
:
3260 ret
= cpc
->pllmr
[1];
3262 case PPC405EP_CPC0_UCR
:
3265 case PPC405EP_CPC0_SRR
:
3268 case PPC405EP_CPC0_JTAGID
:
3271 case PPC405EP_CPC0_PCI
:
3275 /* Avoid gcc warning */
3283 static void dcr_write_epcpc (void *opaque
, int dcrn
, target_ulong val
)
3285 ppc405ep_cpc_t
*cpc
;
3289 case PPC405EP_CPC0_BOOT
:
3290 /* Read-only register */
3292 case PPC405EP_CPC0_EPCTL
:
3293 /* Don't care for now */
3294 cpc
->epctl
= val
& 0xC00000F3;
3296 case PPC405EP_CPC0_PLLMR0
:
3297 cpc
->pllmr
[0] = val
& 0x00633333;
3298 ppc405ep_compute_clocks(cpc
);
3300 case PPC405EP_CPC0_PLLMR1
:
3301 cpc
->pllmr
[1] = val
& 0xC0F73FFF;
3302 ppc405ep_compute_clocks(cpc
);
3304 case PPC405EP_CPC0_UCR
:
3305 /* UART control - don't care for now */
3306 cpc
->ucr
= val
& 0x003F7F7F;
3308 case PPC405EP_CPC0_SRR
:
3311 case PPC405EP_CPC0_JTAGID
:
3314 case PPC405EP_CPC0_PCI
:
3320 static void ppc405ep_cpc_reset (void *opaque
)
3322 ppc405ep_cpc_t
*cpc
= opaque
;
3324 cpc
->boot
= 0x00000010; /* Boot from PCI - IIC EEPROM disabled */
3325 cpc
->epctl
= 0x00000000;
3326 cpc
->pllmr
[0] = 0x00011010;
3327 cpc
->pllmr
[1] = 0x40000000;
3328 cpc
->ucr
= 0x00000000;
3329 cpc
->srr
= 0x00040000;
3330 cpc
->pci
= 0x00000000;
3331 cpc
->er
= 0x00000000;
3332 cpc
->fr
= 0x00000000;
3333 cpc
->sr
= 0x00000000;
3334 ppc405ep_compute_clocks(cpc
);
3337 /* XXX: sysclk should be between 25 and 100 MHz */
3338 static void ppc405ep_cpc_init (CPUState
*env
, clk_setup_t clk_setup
[8],
3341 ppc405ep_cpc_t
*cpc
;
3343 cpc
= qemu_mallocz(sizeof(ppc405ep_cpc_t
));
3345 memcpy(cpc
->clk_setup
, clk_setup
,
3346 PPC405EP_CLK_NB
* sizeof(clk_setup_t
));
3347 cpc
->jtagid
= 0x20267049;
3348 cpc
->sysclk
= sysclk
;
3349 ppc405ep_cpc_reset(cpc
);
3350 qemu_register_reset(&ppc405ep_cpc_reset
, cpc
);
3351 ppc_dcr_register(env
, PPC405EP_CPC0_BOOT
, cpc
,
3352 &dcr_read_epcpc
, &dcr_write_epcpc
);
3353 ppc_dcr_register(env
, PPC405EP_CPC0_EPCTL
, cpc
,
3354 &dcr_read_epcpc
, &dcr_write_epcpc
);
3355 ppc_dcr_register(env
, PPC405EP_CPC0_PLLMR0
, cpc
,
3356 &dcr_read_epcpc
, &dcr_write_epcpc
);
3357 ppc_dcr_register(env
, PPC405EP_CPC0_PLLMR1
, cpc
,
3358 &dcr_read_epcpc
, &dcr_write_epcpc
);
3359 ppc_dcr_register(env
, PPC405EP_CPC0_UCR
, cpc
,
3360 &dcr_read_epcpc
, &dcr_write_epcpc
);
3361 ppc_dcr_register(env
, PPC405EP_CPC0_SRR
, cpc
,
3362 &dcr_read_epcpc
, &dcr_write_epcpc
);
3363 ppc_dcr_register(env
, PPC405EP_CPC0_JTAGID
, cpc
,
3364 &dcr_read_epcpc
, &dcr_write_epcpc
);
3365 ppc_dcr_register(env
, PPC405EP_CPC0_PCI
, cpc
,
3366 &dcr_read_epcpc
, &dcr_write_epcpc
);
3368 ppc_dcr_register(env
, PPC405EP_CPC0_ER
, cpc
,
3369 &dcr_read_epcpc
, &dcr_write_epcpc
);
3370 ppc_dcr_register(env
, PPC405EP_CPC0_FR
, cpc
,
3371 &dcr_read_epcpc
, &dcr_write_epcpc
);
3372 ppc_dcr_register(env
, PPC405EP_CPC0_SR
, cpc
,
3373 &dcr_read_epcpc
, &dcr_write_epcpc
);
3378 CPUState
*ppc405ep_init (target_phys_addr_t ram_bases
[2],
3379 target_phys_addr_t ram_sizes
[2],
3380 uint32_t sysclk
, qemu_irq
**picp
,
3381 ram_addr_t
*offsetp
, int do_init
)
3383 clk_setup_t clk_setup
[PPC405EP_CLK_NB
], tlb_clk_setup
;
3384 qemu_irq dma_irqs
[4], gpt_irqs
[5], mal_irqs
[4];
3386 ppc4xx_mmio_t
*mmio
;
3387 qemu_irq
*pic
, *irqs
;
3391 memset(clk_setup
, 0, sizeof(clk_setup
));
3393 env
= ppc405_init("405ep", &clk_setup
[PPC405EP_CPU_CLK
],
3394 &tlb_clk_setup
, sysclk
);
3395 clk_setup
[PPC405EP_CPU_CLK
].cb
= tlb_clk_setup
.cb
;
3396 clk_setup
[PPC405EP_CPU_CLK
].opaque
= tlb_clk_setup
.opaque
;
3397 /* Internal devices init */
3398 /* Memory mapped devices registers */
3399 mmio
= ppc4xx_mmio_init(env
, 0xEF600000);
3401 ppc4xx_plb_init(env
);
3402 /* PLB to OPB bridge */
3403 ppc4xx_pob_init(env
);
3405 ppc4xx_opba_init(env
, mmio
, 0x600);
3406 /* Universal interrupt controller */
3407 irqs
= qemu_mallocz(sizeof(qemu_irq
) * PPCUIC_OUTPUT_NB
);
3408 irqs
[PPCUIC_OUTPUT_INT
] =
3409 ((qemu_irq
*)env
->irq_inputs
)[PPC40x_INPUT_INT
];
3410 irqs
[PPCUIC_OUTPUT_CINT
] =
3411 ((qemu_irq
*)env
->irq_inputs
)[PPC40x_INPUT_CINT
];
3412 pic
= ppcuic_init(env
, irqs
, 0x0C0, 0, 1);
3414 /* SDRAM controller */
3415 ppc405_sdram_init(env
, pic
[14], 2, ram_bases
, ram_sizes
, do_init
);
3417 for (i
= 0; i
< 2; i
++)
3418 offset
+= ram_sizes
[i
];
3419 /* External bus controller */
3420 ppc405_ebc_init(env
);
3421 /* DMA controller */
3422 dma_irqs
[0] = pic
[26];
3423 dma_irqs
[1] = pic
[25];
3424 dma_irqs
[2] = pic
[24];
3425 dma_irqs
[3] = pic
[23];
3426 ppc405_dma_init(env
, dma_irqs
);
3427 /* IIC controller */
3428 ppc405_i2c_init(env
, mmio
, 0x500, pic
[29]);
3430 ppc405_gpio_init(env
, mmio
, 0x700);
3432 if (serial_hds
[0] != NULL
) {
3433 ppc405_serial_init(env
, mmio
, 0x300, pic
[31], serial_hds
[0]);
3435 if (serial_hds
[1] != NULL
) {
3436 ppc405_serial_init(env
, mmio
, 0x400, pic
[30], serial_hds
[1]);
3439 ppc405_ocm_init(env
, ram_sizes
[0] + ram_sizes
[1]);
3442 gpt_irqs
[0] = pic
[12];
3443 gpt_irqs
[1] = pic
[11];
3444 gpt_irqs
[2] = pic
[10];
3445 gpt_irqs
[3] = pic
[9];
3446 gpt_irqs
[4] = pic
[8];
3447 ppc4xx_gpt_init(env
, mmio
, 0x000, gpt_irqs
);
3449 /* Uses pic[28], pic[15], pic[13] */
3451 mal_irqs
[0] = pic
[20];
3452 mal_irqs
[1] = pic
[19];
3453 mal_irqs
[2] = pic
[18];
3454 mal_irqs
[3] = pic
[17];
3455 ppc405_mal_init(env
, mal_irqs
);
3457 /* Uses pic[22], pic[16], pic[14] */
3459 ppc405ep_cpc_init(env
, clk_setup
, sysclk
);