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 qemu_register_reset(&cpu_ppc_reset
, env
);
55 register_savevm("cpu", 0, 3, cpu_save
, cpu_load
, env
);
56 ppc_find_by_name(cpu_model
, &def
);
58 cpu_abort(env
, "Unable to find PowerPC %s CPU definition\n",
61 cpu_ppc_register(env
, def
);
62 cpu_clk
->cb
= NULL
; /* We don't care about CPU clock frequency changes */
63 cpu_clk
->opaque
= env
;
64 /* Set time-base frequency to sysclk */
65 tb_clk
->cb
= ppc_emb_timers_init(env
, sysclk
);
67 ppc_dcr_init(env
, NULL
, NULL
);
72 ram_addr_t
ppc405_set_bootinfo (CPUState
*env
, ppc4xx_bd_info_t
*bd
)
77 /* We put the bd structure at the top of memory */
78 bdloc
= bd
->bi_memsize
- sizeof(struct ppc4xx_bd_info_t
);
79 stl_raw(phys_ram_base
+ bdloc
+ 0x00, bd
->bi_memstart
);
80 stl_raw(phys_ram_base
+ bdloc
+ 0x04, bd
->bi_memsize
);
81 stl_raw(phys_ram_base
+ bdloc
+ 0x08, bd
->bi_flashstart
);
82 stl_raw(phys_ram_base
+ bdloc
+ 0x0C, bd
->bi_flashsize
);
83 stl_raw(phys_ram_base
+ bdloc
+ 0x10, bd
->bi_flashoffset
);
84 stl_raw(phys_ram_base
+ bdloc
+ 0x14, bd
->bi_sramstart
);
85 stl_raw(phys_ram_base
+ bdloc
+ 0x18, bd
->bi_sramsize
);
86 stl_raw(phys_ram_base
+ bdloc
+ 0x1C, bd
->bi_bootflags
);
87 stl_raw(phys_ram_base
+ bdloc
+ 0x20, bd
->bi_ipaddr
);
88 for (i
= 0; i
< 6; i
++)
89 stb_raw(phys_ram_base
+ bdloc
+ 0x24 + i
, bd
->bi_enetaddr
[i
]);
90 stw_raw(phys_ram_base
+ bdloc
+ 0x2A, bd
->bi_ethspeed
);
91 stl_raw(phys_ram_base
+ bdloc
+ 0x2C, bd
->bi_intfreq
);
92 stl_raw(phys_ram_base
+ bdloc
+ 0x30, bd
->bi_busfreq
);
93 stl_raw(phys_ram_base
+ bdloc
+ 0x34, bd
->bi_baudrate
);
94 for (i
= 0; i
< 4; i
++)
95 stb_raw(phys_ram_base
+ bdloc
+ 0x38 + i
, bd
->bi_s_version
[i
]);
96 for (i
= 0; i
< 32; i
++)
97 stb_raw(phys_ram_base
+ bdloc
+ 0x3C + i
, bd
->bi_s_version
[i
]);
98 stl_raw(phys_ram_base
+ bdloc
+ 0x5C, bd
->bi_plb_busfreq
);
99 stl_raw(phys_ram_base
+ bdloc
+ 0x60, bd
->bi_pci_busfreq
);
100 for (i
= 0; i
< 6; i
++)
101 stb_raw(phys_ram_base
+ bdloc
+ 0x64 + i
, bd
->bi_pci_enetaddr
[i
]);
103 if (env
->spr
[SPR_PVR
] == CPU_PPC_405EP
) {
104 for (i
= 0; i
< 6; i
++)
105 stb_raw(phys_ram_base
+ bdloc
+ n
++, bd
->bi_pci_enetaddr2
[i
]);
107 stl_raw(phys_ram_base
+ bdloc
+ n
, bd
->bi_opbfreq
);
109 for (i
= 0; i
< 2; i
++) {
110 stl_raw(phys_ram_base
+ bdloc
+ n
, bd
->bi_iic_fast
[i
]);
117 /*****************************************************************************/
118 /* Shared peripherals */
120 /*****************************************************************************/
121 /* Fake device used to map multiple devices in a single memory page */
122 #define MMIO_AREA_BITS 8
123 #define MMIO_AREA_LEN (1 << MMIO_AREA_BITS)
124 #define MMIO_AREA_NB (1 << (TARGET_PAGE_BITS - MMIO_AREA_BITS))
125 #define MMIO_IDX(addr) (((addr) >> MMIO_AREA_BITS) & (MMIO_AREA_NB - 1))
126 struct ppc4xx_mmio_t
{
127 target_phys_addr_t base
;
128 CPUReadMemoryFunc
**mem_read
[MMIO_AREA_NB
];
129 CPUWriteMemoryFunc
**mem_write
[MMIO_AREA_NB
];
130 void *opaque
[MMIO_AREA_NB
];
133 static uint32_t unassigned_mmio_readb (void *opaque
, target_phys_addr_t addr
)
135 #ifdef DEBUG_UNASSIGNED
139 printf("Unassigned mmio read 0x" PADDRX
" base " PADDRX
"\n",
146 static void unassigned_mmio_writeb (void *opaque
,
147 target_phys_addr_t addr
, uint32_t val
)
149 #ifdef DEBUG_UNASSIGNED
153 printf("Unassigned mmio write 0x" PADDRX
" = 0x%x base " PADDRX
"\n",
154 addr
, val
, mmio
->base
);
158 static CPUReadMemoryFunc
*unassigned_mmio_read
[3] = {
159 unassigned_mmio_readb
,
160 unassigned_mmio_readb
,
161 unassigned_mmio_readb
,
164 static CPUWriteMemoryFunc
*unassigned_mmio_write
[3] = {
165 unassigned_mmio_writeb
,
166 unassigned_mmio_writeb
,
167 unassigned_mmio_writeb
,
170 static uint32_t mmio_readlen (ppc4xx_mmio_t
*mmio
,
171 target_phys_addr_t addr
, int len
)
173 CPUReadMemoryFunc
**mem_read
;
177 idx
= MMIO_IDX(addr
- mmio
->base
);
178 #if defined(DEBUG_MMIO)
179 printf("%s: mmio %p len %d addr " PADDRX
" idx %d\n", __func__
,
180 mmio
, len
, addr
, idx
);
182 mem_read
= mmio
->mem_read
[idx
];
183 ret
= (*mem_read
[len
])(mmio
->opaque
[idx
], addr
- mmio
->base
);
188 static void mmio_writelen (ppc4xx_mmio_t
*mmio
,
189 target_phys_addr_t addr
, uint32_t value
, int len
)
191 CPUWriteMemoryFunc
**mem_write
;
194 idx
= MMIO_IDX(addr
- mmio
->base
);
195 #if defined(DEBUG_MMIO)
196 printf("%s: mmio %p len %d addr " PADDRX
" idx %d value %08x\n", __func__
,
197 mmio
, len
, addr
, idx
, value
);
199 mem_write
= mmio
->mem_write
[idx
];
200 (*mem_write
[len
])(mmio
->opaque
[idx
], addr
- mmio
->base
, value
);
203 static uint32_t mmio_readb (void *opaque
, target_phys_addr_t addr
)
205 #if defined(DEBUG_MMIO)
206 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
209 return mmio_readlen(opaque
, addr
, 0);
212 static void mmio_writeb (void *opaque
,
213 target_phys_addr_t addr
, uint32_t value
)
215 #if defined(DEBUG_MMIO)
216 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
218 mmio_writelen(opaque
, addr
, value
, 0);
221 static uint32_t mmio_readw (void *opaque
, target_phys_addr_t addr
)
223 #if defined(DEBUG_MMIO)
224 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
227 return mmio_readlen(opaque
, addr
, 1);
230 static void mmio_writew (void *opaque
,
231 target_phys_addr_t addr
, uint32_t value
)
233 #if defined(DEBUG_MMIO)
234 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
236 mmio_writelen(opaque
, addr
, value
, 1);
239 static uint32_t mmio_readl (void *opaque
, target_phys_addr_t addr
)
241 #if defined(DEBUG_MMIO)
242 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
245 return mmio_readlen(opaque
, addr
, 2);
248 static void mmio_writel (void *opaque
,
249 target_phys_addr_t addr
, uint32_t value
)
251 #if defined(DEBUG_MMIO)
252 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
254 mmio_writelen(opaque
, addr
, value
, 2);
257 static CPUReadMemoryFunc
*mmio_read
[] = {
263 static CPUWriteMemoryFunc
*mmio_write
[] = {
269 int ppc4xx_mmio_register (CPUState
*env
, ppc4xx_mmio_t
*mmio
,
270 target_phys_addr_t offset
, uint32_t len
,
271 CPUReadMemoryFunc
**mem_read
,
272 CPUWriteMemoryFunc
**mem_write
, void *opaque
)
277 if ((offset
+ len
) > TARGET_PAGE_SIZE
)
279 idx
= MMIO_IDX(offset
);
280 end
= offset
+ len
- 1;
281 eidx
= MMIO_IDX(end
);
282 #if defined(DEBUG_MMIO)
283 printf("%s: offset %08x len %08x %08x %d %d\n", __func__
, offset
, len
,
286 for (; idx
<= eidx
; idx
++) {
287 mmio
->mem_read
[idx
] = mem_read
;
288 mmio
->mem_write
[idx
] = mem_write
;
289 mmio
->opaque
[idx
] = opaque
;
295 ppc4xx_mmio_t
*ppc4xx_mmio_init (CPUState
*env
, target_phys_addr_t base
)
300 mmio
= qemu_mallocz(sizeof(ppc4xx_mmio_t
));
303 mmio_memory
= cpu_register_io_memory(0, mmio_read
, mmio_write
, mmio
);
304 #if defined(DEBUG_MMIO)
305 printf("%s: %p base %08x len %08x %d\n", __func__
,
306 mmio
, base
, TARGET_PAGE_SIZE
, mmio_memory
);
308 cpu_register_physical_memory(base
, TARGET_PAGE_SIZE
, mmio_memory
);
309 ppc4xx_mmio_register(env
, mmio
, 0, TARGET_PAGE_SIZE
,
310 unassigned_mmio_read
, unassigned_mmio_write
,
317 /*****************************************************************************/
318 /* Peripheral local bus arbitrer */
325 typedef struct ppc4xx_plb_t ppc4xx_plb_t
;
326 struct ppc4xx_plb_t
{
332 static target_ulong
dcr_read_plb (void *opaque
, int dcrn
)
349 /* Avoid gcc warning */
357 static void dcr_write_plb (void *opaque
, int dcrn
, target_ulong val
)
364 /* We don't care about the actual parameters written as
365 * we don't manage any priorities on the bus
367 plb
->acr
= val
& 0xF8000000;
379 static void ppc4xx_plb_reset (void *opaque
)
384 plb
->acr
= 0x00000000;
385 plb
->bear
= 0x00000000;
386 plb
->besr
= 0x00000000;
389 void ppc4xx_plb_init (CPUState
*env
)
393 plb
= qemu_mallocz(sizeof(ppc4xx_plb_t
));
395 ppc_dcr_register(env
, PLB0_ACR
, plb
, &dcr_read_plb
, &dcr_write_plb
);
396 ppc_dcr_register(env
, PLB0_BEAR
, plb
, &dcr_read_plb
, &dcr_write_plb
);
397 ppc_dcr_register(env
, PLB0_BESR
, plb
, &dcr_read_plb
, &dcr_write_plb
);
398 ppc4xx_plb_reset(plb
);
399 qemu_register_reset(ppc4xx_plb_reset
, plb
);
403 /*****************************************************************************/
404 /* PLB to OPB bridge */
411 typedef struct ppc4xx_pob_t ppc4xx_pob_t
;
412 struct ppc4xx_pob_t
{
417 static target_ulong
dcr_read_pob (void *opaque
, int dcrn
)
429 ret
= pob
->besr
[dcrn
- POB0_BESR0
];
432 /* Avoid gcc warning */
440 static void dcr_write_pob (void *opaque
, int dcrn
, target_ulong val
)
452 pob
->besr
[dcrn
- POB0_BESR0
] &= ~val
;
457 static void ppc4xx_pob_reset (void *opaque
)
463 pob
->bear
= 0x00000000;
464 pob
->besr
[0] = 0x0000000;
465 pob
->besr
[1] = 0x0000000;
468 void ppc4xx_pob_init (CPUState
*env
)
472 pob
= qemu_mallocz(sizeof(ppc4xx_pob_t
));
474 ppc_dcr_register(env
, POB0_BEAR
, pob
, &dcr_read_pob
, &dcr_write_pob
);
475 ppc_dcr_register(env
, POB0_BESR0
, pob
, &dcr_read_pob
, &dcr_write_pob
);
476 ppc_dcr_register(env
, POB0_BESR1
, pob
, &dcr_read_pob
, &dcr_write_pob
);
477 qemu_register_reset(ppc4xx_pob_reset
, pob
);
478 ppc4xx_pob_reset(env
);
482 /*****************************************************************************/
484 typedef struct ppc4xx_opba_t ppc4xx_opba_t
;
485 struct ppc4xx_opba_t
{
486 target_phys_addr_t base
;
491 static uint32_t opba_readb (void *opaque
, target_phys_addr_t addr
)
497 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
500 switch (addr
- opba
->base
) {
515 static void opba_writeb (void *opaque
,
516 target_phys_addr_t addr
, uint32_t value
)
521 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
524 switch (addr
- opba
->base
) {
526 opba
->cr
= value
& 0xF8;
529 opba
->pr
= value
& 0xFF;
536 static uint32_t opba_readw (void *opaque
, target_phys_addr_t addr
)
541 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
543 ret
= opba_readb(opaque
, addr
) << 8;
544 ret
|= opba_readb(opaque
, addr
+ 1);
549 static void opba_writew (void *opaque
,
550 target_phys_addr_t addr
, uint32_t value
)
553 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
555 opba_writeb(opaque
, addr
, value
>> 8);
556 opba_writeb(opaque
, addr
+ 1, value
);
559 static uint32_t opba_readl (void *opaque
, target_phys_addr_t addr
)
564 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
566 ret
= opba_readb(opaque
, addr
) << 24;
567 ret
|= opba_readb(opaque
, addr
+ 1) << 16;
572 static void opba_writel (void *opaque
,
573 target_phys_addr_t addr
, uint32_t value
)
576 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
578 opba_writeb(opaque
, addr
, value
>> 24);
579 opba_writeb(opaque
, addr
+ 1, value
>> 16);
582 static CPUReadMemoryFunc
*opba_read
[] = {
588 static CPUWriteMemoryFunc
*opba_write
[] = {
594 static void ppc4xx_opba_reset (void *opaque
)
599 opba
->cr
= 0x00; /* No dynamic priorities - park disabled */
603 void ppc4xx_opba_init (CPUState
*env
, ppc4xx_mmio_t
*mmio
,
604 target_phys_addr_t offset
)
608 opba
= qemu_mallocz(sizeof(ppc4xx_opba_t
));
612 printf("%s: offset=" PADDRX
"\n", __func__
, offset
);
614 ppc4xx_mmio_register(env
, mmio
, offset
, 0x002,
615 opba_read
, opba_write
, opba
);
616 qemu_register_reset(ppc4xx_opba_reset
, opba
);
617 ppc4xx_opba_reset(opba
);
621 /*****************************************************************************/
622 /* "Universal" Interrupt controller */
636 #define UIC_MAX_IRQ 32
637 typedef struct ppcuic_t ppcuic_t
;
641 uint32_t uicsr
; /* Status register */
642 uint32_t uicer
; /* Enable register */
643 uint32_t uiccr
; /* Critical register */
644 uint32_t uicpr
; /* Polarity register */
645 uint32_t uictr
; /* Triggering register */
646 uint32_t uicvcr
; /* Vector configuration register */
651 static void ppcuic_trigger_irq (ppcuic_t
*uic
)
654 int start
, end
, inc
, i
;
656 /* Trigger interrupt if any is pending */
657 ir
= uic
->uicsr
& uic
->uicer
& (~uic
->uiccr
);
658 cr
= uic
->uicsr
& uic
->uicer
& uic
->uiccr
;
660 if (loglevel
& CPU_LOG_INT
) {
661 fprintf(logfile
, "%s: uicsr %08x uicer %08x uiccr %08x\n"
662 " %08x ir %08x cr %08x\n", __func__
,
663 uic
->uicsr
, uic
->uicer
, uic
->uiccr
,
664 uic
->uicsr
& uic
->uicer
, ir
, cr
);
667 if (ir
!= 0x0000000) {
669 if (loglevel
& CPU_LOG_INT
) {
670 fprintf(logfile
, "Raise UIC interrupt\n");
673 qemu_irq_raise(uic
->irqs
[PPCUIC_OUTPUT_INT
]);
676 if (loglevel
& CPU_LOG_INT
) {
677 fprintf(logfile
, "Lower UIC interrupt\n");
680 qemu_irq_lower(uic
->irqs
[PPCUIC_OUTPUT_INT
]);
682 /* Trigger critical interrupt if any is pending and update vector */
683 if (cr
!= 0x0000000) {
684 qemu_irq_raise(uic
->irqs
[PPCUIC_OUTPUT_CINT
]);
685 if (uic
->use_vectors
) {
686 /* Compute critical IRQ vector */
687 if (uic
->uicvcr
& 1) {
696 uic
->uicvr
= uic
->uicvcr
& 0xFFFFFFFC;
697 for (i
= start
; i
<= end
; i
+= inc
) {
699 uic
->uicvr
+= (i
- start
) * 512 * inc
;
705 if (loglevel
& CPU_LOG_INT
) {
706 fprintf(logfile
, "Raise UIC critical interrupt - vector %08x\n",
712 if (loglevel
& CPU_LOG_INT
) {
713 fprintf(logfile
, "Lower UIC critical interrupt\n");
716 qemu_irq_lower(uic
->irqs
[PPCUIC_OUTPUT_CINT
]);
717 uic
->uicvr
= 0x00000000;
721 static void ppcuic_set_irq (void *opaque
, int irq_num
, int level
)
729 if (loglevel
& CPU_LOG_INT
) {
730 fprintf(logfile
, "%s: irq %d level %d uicsr %08x mask %08x => %08x "
731 "%08x\n", __func__
, irq_num
, level
,
732 uic
->uicsr
, mask
, uic
->uicsr
& mask
, level
<< irq_num
);
735 if (irq_num
< 0 || irq_num
> 31)
738 if (!(uic
->uicpr
& mask
)) {
739 /* Negatively asserted IRQ */
740 level
= level
== 0 ? 1 : 0;
742 /* Update status register */
743 if (uic
->uictr
& mask
) {
744 /* Edge sensitive interrupt */
748 /* Level sensitive interrupt */
755 if (loglevel
& CPU_LOG_INT
) {
756 fprintf(logfile
, "%s: irq %d level %d sr %08x => %08x\n", __func__
,
757 irq_num
, level
, uic
->uicsr
, sr
);
760 if (sr
!= uic
->uicsr
)
761 ppcuic_trigger_irq(uic
);
764 static target_ulong
dcr_read_uic (void *opaque
, int dcrn
)
770 dcrn
-= uic
->dcr_base
;
789 ret
= uic
->uicsr
& uic
->uicer
;
792 if (!uic
->use_vectors
)
797 if (!uic
->use_vectors
)
810 static void dcr_write_uic (void *opaque
, int dcrn
, target_ulong val
)
815 dcrn
-= uic
->dcr_base
;
817 if (loglevel
& CPU_LOG_INT
) {
818 fprintf(logfile
, "%s: dcr %d val " ADDRX
"\n", __func__
, dcrn
, val
);
824 ppcuic_trigger_irq(uic
);
828 ppcuic_trigger_irq(uic
);
832 ppcuic_trigger_irq(uic
);
836 ppcuic_trigger_irq(uic
);
840 ppcuic_trigger_irq(uic
);
844 ppcuic_trigger_irq(uic
);
851 uic
->uicvcr
= val
& 0xFFFFFFFD;
852 ppcuic_trigger_irq(uic
);
857 static void ppcuic_reset (void *opaque
)
862 uic
->uiccr
= 0x00000000;
863 uic
->uicer
= 0x00000000;
864 uic
->uicpr
= 0x00000000;
865 uic
->uicsr
= 0x00000000;
866 uic
->uictr
= 0x00000000;
867 if (uic
->use_vectors
) {
868 uic
->uicvcr
= 0x00000000;
869 uic
->uicvr
= 0x0000000;
873 qemu_irq
*ppcuic_init (CPUState
*env
, qemu_irq
*irqs
,
874 uint32_t dcr_base
, int has_ssr
, int has_vr
)
879 uic
= qemu_mallocz(sizeof(ppcuic_t
));
881 uic
->dcr_base
= dcr_base
;
884 uic
->use_vectors
= 1;
885 for (i
= 0; i
< DCR_UICMAX
; i
++) {
886 ppc_dcr_register(env
, dcr_base
+ i
, uic
,
887 &dcr_read_uic
, &dcr_write_uic
);
889 qemu_register_reset(ppcuic_reset
, uic
);
893 return qemu_allocate_irqs(&ppcuic_set_irq
, uic
, UIC_MAX_IRQ
);
896 /*****************************************************************************/
897 /* Code decompression controller */
900 /*****************************************************************************/
901 /* SDRAM controller */
902 typedef struct ppc4xx_sdram_t ppc4xx_sdram_t
;
903 struct ppc4xx_sdram_t
{
906 target_ulong ram_bases
[4];
907 target_ulong ram_sizes
[4];
923 SDRAM0_CFGADDR
= 0x010,
924 SDRAM0_CFGDATA
= 0x011,
927 static uint32_t sdram_bcr (target_ulong ram_base
, target_ulong ram_size
)
932 case (4 * 1024 * 1024):
935 case (8 * 1024 * 1024):
938 case (16 * 1024 * 1024):
941 case (32 * 1024 * 1024):
944 case (64 * 1024 * 1024):
947 case (128 * 1024 * 1024):
950 case (256 * 1024 * 1024):
954 printf("%s: invalid RAM size " TARGET_FMT_ld
"\n", __func__
, ram_size
);
957 bcr
|= ram_base
& 0xFF800000;
963 static inline target_ulong
sdram_base (uint32_t bcr
)
965 return bcr
& 0xFF800000;
968 static target_ulong
sdram_size (uint32_t bcr
)
973 sh
= (bcr
>> 17) & 0x7;
977 size
= (4 * 1024 * 1024) << sh
;
982 static void sdram_set_bcr (uint32_t *bcrp
, uint32_t bcr
, int enabled
)
984 if (*bcrp
& 0x00000001) {
987 printf("%s: unmap RAM area " ADDRX
" " ADDRX
"\n", __func__
,
988 sdram_base(*bcrp
), sdram_size(*bcrp
));
990 cpu_register_physical_memory(sdram_base(*bcrp
), sdram_size(*bcrp
),
993 *bcrp
= bcr
& 0xFFDEE001;
994 if (enabled
&& (bcr
& 0x00000001)) {
996 printf("%s: Map RAM area " ADDRX
" " ADDRX
"\n", __func__
,
997 sdram_base(bcr
), sdram_size(bcr
));
999 cpu_register_physical_memory(sdram_base(bcr
), sdram_size(bcr
),
1000 sdram_base(bcr
) | IO_MEM_RAM
);
1004 static void sdram_map_bcr (ppc4xx_sdram_t
*sdram
)
1008 for (i
= 0; i
< sdram
->nbanks
; i
++) {
1009 if (sdram
->ram_sizes
[i
] != 0) {
1010 sdram_set_bcr(&sdram
->bcr
[i
],
1011 sdram_bcr(sdram
->ram_bases
[i
], sdram
->ram_sizes
[i
]),
1014 sdram_set_bcr(&sdram
->bcr
[i
], 0x00000000, 0);
1019 static void sdram_unmap_bcr (ppc4xx_sdram_t
*sdram
)
1023 for (i
= 0; i
< sdram
->nbanks
; i
++) {
1025 printf("%s: Unmap RAM area " ADDRX
" " ADDRX
"\n", __func__
,
1026 sdram_base(sdram
->bcr
[i
]), sdram_size(sdram
->bcr
[i
]));
1028 cpu_register_physical_memory(sdram_base(sdram
->bcr
[i
]),
1029 sdram_size(sdram
->bcr
[i
]),
1034 static target_ulong
dcr_read_sdram (void *opaque
, int dcrn
)
1036 ppc4xx_sdram_t
*sdram
;
1041 case SDRAM0_CFGADDR
:
1044 case SDRAM0_CFGDATA
:
1045 switch (sdram
->addr
) {
1046 case 0x00: /* SDRAM_BESR0 */
1049 case 0x08: /* SDRAM_BESR1 */
1052 case 0x10: /* SDRAM_BEAR */
1055 case 0x20: /* SDRAM_CFG */
1058 case 0x24: /* SDRAM_STATUS */
1059 ret
= sdram
->status
;
1061 case 0x30: /* SDRAM_RTR */
1064 case 0x34: /* SDRAM_PMIT */
1067 case 0x40: /* SDRAM_B0CR */
1068 ret
= sdram
->bcr
[0];
1070 case 0x44: /* SDRAM_B1CR */
1071 ret
= sdram
->bcr
[1];
1073 case 0x48: /* SDRAM_B2CR */
1074 ret
= sdram
->bcr
[2];
1076 case 0x4C: /* SDRAM_B3CR */
1077 ret
= sdram
->bcr
[3];
1079 case 0x80: /* SDRAM_TR */
1082 case 0x94: /* SDRAM_ECCCFG */
1083 ret
= sdram
->ecccfg
;
1085 case 0x98: /* SDRAM_ECCESR */
1086 ret
= sdram
->eccesr
;
1088 default: /* Error */
1094 /* Avoid gcc warning */
1102 static void dcr_write_sdram (void *opaque
, int dcrn
, target_ulong val
)
1104 ppc4xx_sdram_t
*sdram
;
1108 case SDRAM0_CFGADDR
:
1111 case SDRAM0_CFGDATA
:
1112 switch (sdram
->addr
) {
1113 case 0x00: /* SDRAM_BESR0 */
1114 sdram
->besr0
&= ~val
;
1116 case 0x08: /* SDRAM_BESR1 */
1117 sdram
->besr1
&= ~val
;
1119 case 0x10: /* SDRAM_BEAR */
1122 case 0x20: /* SDRAM_CFG */
1124 if (!(sdram
->cfg
& 0x80000000) && (val
& 0x80000000)) {
1126 printf("%s: enable SDRAM controller\n", __func__
);
1128 /* validate all RAM mappings */
1129 sdram_map_bcr(sdram
);
1130 sdram
->status
&= ~0x80000000;
1131 } else if ((sdram
->cfg
& 0x80000000) && !(val
& 0x80000000)) {
1133 printf("%s: disable SDRAM controller\n", __func__
);
1135 /* invalidate all RAM mappings */
1136 sdram_unmap_bcr(sdram
);
1137 sdram
->status
|= 0x80000000;
1139 if (!(sdram
->cfg
& 0x40000000) && (val
& 0x40000000))
1140 sdram
->status
|= 0x40000000;
1141 else if ((sdram
->cfg
& 0x40000000) && !(val
& 0x40000000))
1142 sdram
->status
&= ~0x40000000;
1145 case 0x24: /* SDRAM_STATUS */
1146 /* Read-only register */
1148 case 0x30: /* SDRAM_RTR */
1149 sdram
->rtr
= val
& 0x3FF80000;
1151 case 0x34: /* SDRAM_PMIT */
1152 sdram
->pmit
= (val
& 0xF8000000) | 0x07C00000;
1154 case 0x40: /* SDRAM_B0CR */
1155 sdram_set_bcr(&sdram
->bcr
[0], val
, sdram
->cfg
& 0x80000000);
1157 case 0x44: /* SDRAM_B1CR */
1158 sdram_set_bcr(&sdram
->bcr
[1], val
, sdram
->cfg
& 0x80000000);
1160 case 0x48: /* SDRAM_B2CR */
1161 sdram_set_bcr(&sdram
->bcr
[2], val
, sdram
->cfg
& 0x80000000);
1163 case 0x4C: /* SDRAM_B3CR */
1164 sdram_set_bcr(&sdram
->bcr
[3], val
, sdram
->cfg
& 0x80000000);
1166 case 0x80: /* SDRAM_TR */
1167 sdram
->tr
= val
& 0x018FC01F;
1169 case 0x94: /* SDRAM_ECCCFG */
1170 sdram
->ecccfg
= val
& 0x00F00000;
1172 case 0x98: /* SDRAM_ECCESR */
1174 if (sdram
->eccesr
== 0 && val
!= 0)
1175 qemu_irq_raise(sdram
->irq
);
1176 else if (sdram
->eccesr
!= 0 && val
== 0)
1177 qemu_irq_lower(sdram
->irq
);
1178 sdram
->eccesr
= val
;
1180 default: /* Error */
1187 static void sdram_reset (void *opaque
)
1189 ppc4xx_sdram_t
*sdram
;
1192 sdram
->addr
= 0x00000000;
1193 sdram
->bear
= 0x00000000;
1194 sdram
->besr0
= 0x00000000; /* No error */
1195 sdram
->besr1
= 0x00000000; /* No error */
1196 sdram
->cfg
= 0x00000000;
1197 sdram
->ecccfg
= 0x00000000; /* No ECC */
1198 sdram
->eccesr
= 0x00000000; /* No error */
1199 sdram
->pmit
= 0x07C00000;
1200 sdram
->rtr
= 0x05F00000;
1201 sdram
->tr
= 0x00854009;
1202 /* We pre-initialize RAM banks */
1203 sdram
->status
= 0x00000000;
1204 sdram
->cfg
= 0x00800000;
1205 sdram_unmap_bcr(sdram
);
1208 void ppc405_sdram_init (CPUState
*env
, qemu_irq irq
, int nbanks
,
1209 target_ulong
*ram_bases
, target_ulong
*ram_sizes
,
1212 ppc4xx_sdram_t
*sdram
;
1214 sdram
= qemu_mallocz(sizeof(ppc4xx_sdram_t
));
1215 if (sdram
!= NULL
) {
1217 sdram
->nbanks
= nbanks
;
1218 memset(sdram
->ram_bases
, 0, 4 * sizeof(target_ulong
));
1219 memcpy(sdram
->ram_bases
, ram_bases
, nbanks
* sizeof(target_ulong
));
1220 memset(sdram
->ram_sizes
, 0, 4 * sizeof(target_ulong
));
1221 memcpy(sdram
->ram_sizes
, ram_sizes
, nbanks
* sizeof(target_ulong
));
1223 qemu_register_reset(&sdram_reset
, sdram
);
1224 ppc_dcr_register(env
, SDRAM0_CFGADDR
,
1225 sdram
, &dcr_read_sdram
, &dcr_write_sdram
);
1226 ppc_dcr_register(env
, SDRAM0_CFGDATA
,
1227 sdram
, &dcr_read_sdram
, &dcr_write_sdram
);
1229 sdram_map_bcr(sdram
);
1233 /*****************************************************************************/
1234 /* Peripheral controller */
1235 typedef struct ppc4xx_ebc_t ppc4xx_ebc_t
;
1236 struct ppc4xx_ebc_t
{
1247 EBC0_CFGADDR
= 0x012,
1248 EBC0_CFGDATA
= 0x013,
1251 static target_ulong
dcr_read_ebc (void *opaque
, int dcrn
)
1262 switch (ebc
->addr
) {
1263 case 0x00: /* B0CR */
1266 case 0x01: /* B1CR */
1269 case 0x02: /* B2CR */
1272 case 0x03: /* B3CR */
1275 case 0x04: /* B4CR */
1278 case 0x05: /* B5CR */
1281 case 0x06: /* B6CR */
1284 case 0x07: /* B7CR */
1287 case 0x10: /* B0AP */
1290 case 0x11: /* B1AP */
1293 case 0x12: /* B2AP */
1296 case 0x13: /* B3AP */
1299 case 0x14: /* B4AP */
1302 case 0x15: /* B5AP */
1305 case 0x16: /* B6AP */
1308 case 0x17: /* B7AP */
1311 case 0x20: /* BEAR */
1314 case 0x21: /* BESR0 */
1317 case 0x22: /* BESR1 */
1320 case 0x23: /* CFG */
1335 static void dcr_write_ebc (void *opaque
, int dcrn
, target_ulong val
)
1345 switch (ebc
->addr
) {
1346 case 0x00: /* B0CR */
1348 case 0x01: /* B1CR */
1350 case 0x02: /* B2CR */
1352 case 0x03: /* B3CR */
1354 case 0x04: /* B4CR */
1356 case 0x05: /* B5CR */
1358 case 0x06: /* B6CR */
1360 case 0x07: /* B7CR */
1362 case 0x10: /* B0AP */
1364 case 0x11: /* B1AP */
1366 case 0x12: /* B2AP */
1368 case 0x13: /* B3AP */
1370 case 0x14: /* B4AP */
1372 case 0x15: /* B5AP */
1374 case 0x16: /* B6AP */
1376 case 0x17: /* B7AP */
1378 case 0x20: /* BEAR */
1380 case 0x21: /* BESR0 */
1382 case 0x22: /* BESR1 */
1384 case 0x23: /* CFG */
1395 static void ebc_reset (void *opaque
)
1401 ebc
->addr
= 0x00000000;
1402 ebc
->bap
[0] = 0x7F8FFE80;
1403 ebc
->bcr
[0] = 0xFFE28000;
1404 for (i
= 0; i
< 8; i
++) {
1405 ebc
->bap
[i
] = 0x00000000;
1406 ebc
->bcr
[i
] = 0x00000000;
1408 ebc
->besr0
= 0x00000000;
1409 ebc
->besr1
= 0x00000000;
1410 ebc
->cfg
= 0x80400000;
1413 void ppc405_ebc_init (CPUState
*env
)
1417 ebc
= qemu_mallocz(sizeof(ppc4xx_ebc_t
));
1420 qemu_register_reset(&ebc_reset
, ebc
);
1421 ppc_dcr_register(env
, EBC0_CFGADDR
,
1422 ebc
, &dcr_read_ebc
, &dcr_write_ebc
);
1423 ppc_dcr_register(env
, EBC0_CFGDATA
,
1424 ebc
, &dcr_read_ebc
, &dcr_write_ebc
);
1428 /*****************************************************************************/
1429 /* DMA controller */
1457 typedef struct ppc405_dma_t ppc405_dma_t
;
1458 struct ppc405_dma_t
{
1471 static target_ulong
dcr_read_dma (void *opaque
, int dcrn
)
1480 static void dcr_write_dma (void *opaque
, int dcrn
, target_ulong val
)
1487 static void ppc405_dma_reset (void *opaque
)
1493 for (i
= 0; i
< 4; i
++) {
1494 dma
->cr
[i
] = 0x00000000;
1495 dma
->ct
[i
] = 0x00000000;
1496 dma
->da
[i
] = 0x00000000;
1497 dma
->sa
[i
] = 0x00000000;
1498 dma
->sg
[i
] = 0x00000000;
1500 dma
->sr
= 0x00000000;
1501 dma
->sgc
= 0x00000000;
1502 dma
->slp
= 0x7C000000;
1503 dma
->pol
= 0x00000000;
1506 void ppc405_dma_init (CPUState
*env
, qemu_irq irqs
[4])
1510 dma
= qemu_mallocz(sizeof(ppc405_dma_t
));
1512 memcpy(dma
->irqs
, irqs
, 4 * sizeof(qemu_irq
));
1513 ppc405_dma_reset(dma
);
1514 qemu_register_reset(&ppc405_dma_reset
, dma
);
1515 ppc_dcr_register(env
, DMA0_CR0
,
1516 dma
, &dcr_read_dma
, &dcr_write_dma
);
1517 ppc_dcr_register(env
, DMA0_CT0
,
1518 dma
, &dcr_read_dma
, &dcr_write_dma
);
1519 ppc_dcr_register(env
, DMA0_DA0
,
1520 dma
, &dcr_read_dma
, &dcr_write_dma
);
1521 ppc_dcr_register(env
, DMA0_SA0
,
1522 dma
, &dcr_read_dma
, &dcr_write_dma
);
1523 ppc_dcr_register(env
, DMA0_SG0
,
1524 dma
, &dcr_read_dma
, &dcr_write_dma
);
1525 ppc_dcr_register(env
, DMA0_CR1
,
1526 dma
, &dcr_read_dma
, &dcr_write_dma
);
1527 ppc_dcr_register(env
, DMA0_CT1
,
1528 dma
, &dcr_read_dma
, &dcr_write_dma
);
1529 ppc_dcr_register(env
, DMA0_DA1
,
1530 dma
, &dcr_read_dma
, &dcr_write_dma
);
1531 ppc_dcr_register(env
, DMA0_SA1
,
1532 dma
, &dcr_read_dma
, &dcr_write_dma
);
1533 ppc_dcr_register(env
, DMA0_SG1
,
1534 dma
, &dcr_read_dma
, &dcr_write_dma
);
1535 ppc_dcr_register(env
, DMA0_CR2
,
1536 dma
, &dcr_read_dma
, &dcr_write_dma
);
1537 ppc_dcr_register(env
, DMA0_CT2
,
1538 dma
, &dcr_read_dma
, &dcr_write_dma
);
1539 ppc_dcr_register(env
, DMA0_DA2
,
1540 dma
, &dcr_read_dma
, &dcr_write_dma
);
1541 ppc_dcr_register(env
, DMA0_SA2
,
1542 dma
, &dcr_read_dma
, &dcr_write_dma
);
1543 ppc_dcr_register(env
, DMA0_SG2
,
1544 dma
, &dcr_read_dma
, &dcr_write_dma
);
1545 ppc_dcr_register(env
, DMA0_CR3
,
1546 dma
, &dcr_read_dma
, &dcr_write_dma
);
1547 ppc_dcr_register(env
, DMA0_CT3
,
1548 dma
, &dcr_read_dma
, &dcr_write_dma
);
1549 ppc_dcr_register(env
, DMA0_DA3
,
1550 dma
, &dcr_read_dma
, &dcr_write_dma
);
1551 ppc_dcr_register(env
, DMA0_SA3
,
1552 dma
, &dcr_read_dma
, &dcr_write_dma
);
1553 ppc_dcr_register(env
, DMA0_SG3
,
1554 dma
, &dcr_read_dma
, &dcr_write_dma
);
1555 ppc_dcr_register(env
, DMA0_SR
,
1556 dma
, &dcr_read_dma
, &dcr_write_dma
);
1557 ppc_dcr_register(env
, DMA0_SGC
,
1558 dma
, &dcr_read_dma
, &dcr_write_dma
);
1559 ppc_dcr_register(env
, DMA0_SLP
,
1560 dma
, &dcr_read_dma
, &dcr_write_dma
);
1561 ppc_dcr_register(env
, DMA0_POL
,
1562 dma
, &dcr_read_dma
, &dcr_write_dma
);
1566 /*****************************************************************************/
1568 typedef struct ppc405_gpio_t ppc405_gpio_t
;
1569 struct ppc405_gpio_t
{
1570 target_phys_addr_t base
;
1584 static uint32_t ppc405_gpio_readb (void *opaque
, target_phys_addr_t addr
)
1586 ppc405_gpio_t
*gpio
;
1590 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
1596 static void ppc405_gpio_writeb (void *opaque
,
1597 target_phys_addr_t addr
, uint32_t value
)
1599 ppc405_gpio_t
*gpio
;
1603 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
1607 static uint32_t ppc405_gpio_readw (void *opaque
, target_phys_addr_t addr
)
1609 ppc405_gpio_t
*gpio
;
1613 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
1619 static void ppc405_gpio_writew (void *opaque
,
1620 target_phys_addr_t addr
, uint32_t value
)
1622 ppc405_gpio_t
*gpio
;
1626 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
1630 static uint32_t ppc405_gpio_readl (void *opaque
, target_phys_addr_t addr
)
1632 ppc405_gpio_t
*gpio
;
1636 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
1642 static void ppc405_gpio_writel (void *opaque
,
1643 target_phys_addr_t addr
, uint32_t value
)
1645 ppc405_gpio_t
*gpio
;
1649 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
1653 static CPUReadMemoryFunc
*ppc405_gpio_read
[] = {
1659 static CPUWriteMemoryFunc
*ppc405_gpio_write
[] = {
1660 &ppc405_gpio_writeb
,
1661 &ppc405_gpio_writew
,
1662 &ppc405_gpio_writel
,
1665 static void ppc405_gpio_reset (void *opaque
)
1667 ppc405_gpio_t
*gpio
;
1672 void ppc405_gpio_init (CPUState
*env
, ppc4xx_mmio_t
*mmio
,
1673 target_phys_addr_t offset
)
1675 ppc405_gpio_t
*gpio
;
1677 gpio
= qemu_mallocz(sizeof(ppc405_gpio_t
));
1679 gpio
->base
= offset
;
1680 ppc405_gpio_reset(gpio
);
1681 qemu_register_reset(&ppc405_gpio_reset
, gpio
);
1683 printf("%s: offset=" PADDRX
"\n", __func__
, offset
);
1685 ppc4xx_mmio_register(env
, mmio
, offset
, 0x038,
1686 ppc405_gpio_read
, ppc405_gpio_write
, gpio
);
1690 /*****************************************************************************/
1692 static CPUReadMemoryFunc
*serial_mm_read
[] = {
1698 static CPUWriteMemoryFunc
*serial_mm_write
[] = {
1704 void ppc405_serial_init (CPUState
*env
, ppc4xx_mmio_t
*mmio
,
1705 target_phys_addr_t offset
, qemu_irq irq
,
1706 CharDriverState
*chr
)
1711 printf("%s: offset=" PADDRX
"\n", __func__
, offset
);
1713 serial
= serial_mm_init(offset
, 0, irq
, chr
, 0);
1714 ppc4xx_mmio_register(env
, mmio
, offset
, 0x008,
1715 serial_mm_read
, serial_mm_write
, serial
);
1718 /*****************************************************************************/
1719 /* On Chip Memory */
1722 OCM0_ISACNTL
= 0x019,
1724 OCM0_DSACNTL
= 0x01B,
1727 typedef struct ppc405_ocm_t ppc405_ocm_t
;
1728 struct ppc405_ocm_t
{
1729 target_ulong offset
;
1736 static void ocm_update_mappings (ppc405_ocm_t
*ocm
,
1737 uint32_t isarc
, uint32_t isacntl
,
1738 uint32_t dsarc
, uint32_t dsacntl
)
1741 printf("OCM update ISA %08x %08x (%08x %08x) DSA %08x %08x (%08x %08x)\n",
1742 isarc
, isacntl
, dsarc
, dsacntl
,
1743 ocm
->isarc
, ocm
->isacntl
, ocm
->dsarc
, ocm
->dsacntl
);
1745 if (ocm
->isarc
!= isarc
||
1746 (ocm
->isacntl
& 0x80000000) != (isacntl
& 0x80000000)) {
1747 if (ocm
->isacntl
& 0x80000000) {
1748 /* Unmap previously assigned memory region */
1749 printf("OCM unmap ISA %08x\n", ocm
->isarc
);
1750 cpu_register_physical_memory(ocm
->isarc
, 0x04000000,
1753 if (isacntl
& 0x80000000) {
1754 /* Map new instruction memory region */
1756 printf("OCM map ISA %08x\n", isarc
);
1758 cpu_register_physical_memory(isarc
, 0x04000000,
1759 ocm
->offset
| IO_MEM_RAM
);
1762 if (ocm
->dsarc
!= dsarc
||
1763 (ocm
->dsacntl
& 0x80000000) != (dsacntl
& 0x80000000)) {
1764 if (ocm
->dsacntl
& 0x80000000) {
1765 /* Beware not to unmap the region we just mapped */
1766 if (!(isacntl
& 0x80000000) || ocm
->dsarc
!= isarc
) {
1767 /* Unmap previously assigned memory region */
1769 printf("OCM unmap DSA %08x\n", ocm
->dsarc
);
1771 cpu_register_physical_memory(ocm
->dsarc
, 0x04000000,
1775 if (dsacntl
& 0x80000000) {
1776 /* Beware not to remap the region we just mapped */
1777 if (!(isacntl
& 0x80000000) || dsarc
!= isarc
) {
1778 /* Map new data memory region */
1780 printf("OCM map DSA %08x\n", dsarc
);
1782 cpu_register_physical_memory(dsarc
, 0x04000000,
1783 ocm
->offset
| IO_MEM_RAM
);
1789 static target_ulong
dcr_read_ocm (void *opaque
, int dcrn
)
1816 static void dcr_write_ocm (void *opaque
, int dcrn
, target_ulong val
)
1819 uint32_t isarc
, dsarc
, isacntl
, dsacntl
;
1824 isacntl
= ocm
->isacntl
;
1825 dsacntl
= ocm
->dsacntl
;
1828 isarc
= val
& 0xFC000000;
1831 isacntl
= val
& 0xC0000000;
1834 isarc
= val
& 0xFC000000;
1837 isacntl
= val
& 0xC0000000;
1840 ocm_update_mappings(ocm
, isarc
, isacntl
, dsarc
, dsacntl
);
1843 ocm
->isacntl
= isacntl
;
1844 ocm
->dsacntl
= dsacntl
;
1847 static void ocm_reset (void *opaque
)
1850 uint32_t isarc
, dsarc
, isacntl
, dsacntl
;
1854 isacntl
= 0x00000000;
1856 dsacntl
= 0x00000000;
1857 ocm_update_mappings(ocm
, isarc
, isacntl
, dsarc
, dsacntl
);
1860 ocm
->isacntl
= isacntl
;
1861 ocm
->dsacntl
= dsacntl
;
1864 void ppc405_ocm_init (CPUState
*env
, unsigned long offset
)
1868 ocm
= qemu_mallocz(sizeof(ppc405_ocm_t
));
1870 ocm
->offset
= offset
;
1872 qemu_register_reset(&ocm_reset
, ocm
);
1873 ppc_dcr_register(env
, OCM0_ISARC
,
1874 ocm
, &dcr_read_ocm
, &dcr_write_ocm
);
1875 ppc_dcr_register(env
, OCM0_ISACNTL
,
1876 ocm
, &dcr_read_ocm
, &dcr_write_ocm
);
1877 ppc_dcr_register(env
, OCM0_DSARC
,
1878 ocm
, &dcr_read_ocm
, &dcr_write_ocm
);
1879 ppc_dcr_register(env
, OCM0_DSACNTL
,
1880 ocm
, &dcr_read_ocm
, &dcr_write_ocm
);
1884 /*****************************************************************************/
1885 /* I2C controller */
1886 typedef struct ppc4xx_i2c_t ppc4xx_i2c_t
;
1887 struct ppc4xx_i2c_t
{
1888 target_phys_addr_t base
;
1907 static uint32_t ppc4xx_i2c_readb (void *opaque
, target_phys_addr_t addr
)
1913 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
1916 switch (addr
- i2c
->base
) {
1918 // i2c_readbyte(&i2c->mdata);
1958 ret
= i2c
->xtcntlss
;
1961 ret
= i2c
->directcntl
;
1968 printf("%s: addr " PADDRX
" %02x\n", __func__
, addr
, ret
);
1974 static void ppc4xx_i2c_writeb (void *opaque
,
1975 target_phys_addr_t addr
, uint32_t value
)
1980 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
1983 switch (addr
- i2c
->base
) {
1986 // i2c_sendbyte(&i2c->mdata);
2001 i2c
->mdcntl
= value
& 0xDF;
2004 i2c
->sts
&= ~(value
& 0x0A);
2007 i2c
->extsts
&= ~(value
& 0x8F);
2016 i2c
->clkdiv
= value
;
2019 i2c
->intrmsk
= value
;
2022 i2c
->xfrcnt
= value
& 0x77;
2025 i2c
->xtcntlss
= value
;
2028 i2c
->directcntl
= value
& 0x7;
2033 static uint32_t ppc4xx_i2c_readw (void *opaque
, target_phys_addr_t addr
)
2038 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
2040 ret
= ppc4xx_i2c_readb(opaque
, addr
) << 8;
2041 ret
|= ppc4xx_i2c_readb(opaque
, addr
+ 1);
2046 static void ppc4xx_i2c_writew (void *opaque
,
2047 target_phys_addr_t addr
, uint32_t value
)
2050 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
2052 ppc4xx_i2c_writeb(opaque
, addr
, value
>> 8);
2053 ppc4xx_i2c_writeb(opaque
, addr
+ 1, value
);
2056 static uint32_t ppc4xx_i2c_readl (void *opaque
, target_phys_addr_t addr
)
2061 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
2063 ret
= ppc4xx_i2c_readb(opaque
, addr
) << 24;
2064 ret
|= ppc4xx_i2c_readb(opaque
, addr
+ 1) << 16;
2065 ret
|= ppc4xx_i2c_readb(opaque
, addr
+ 2) << 8;
2066 ret
|= ppc4xx_i2c_readb(opaque
, addr
+ 3);
2071 static void ppc4xx_i2c_writel (void *opaque
,
2072 target_phys_addr_t addr
, uint32_t value
)
2075 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
2077 ppc4xx_i2c_writeb(opaque
, addr
, value
>> 24);
2078 ppc4xx_i2c_writeb(opaque
, addr
+ 1, value
>> 16);
2079 ppc4xx_i2c_writeb(opaque
, addr
+ 2, value
>> 8);
2080 ppc4xx_i2c_writeb(opaque
, addr
+ 3, value
);
2083 static CPUReadMemoryFunc
*i2c_read
[] = {
2089 static CPUWriteMemoryFunc
*i2c_write
[] = {
2095 static void ppc4xx_i2c_reset (void *opaque
)
2108 i2c
->directcntl
= 0x0F;
2111 void ppc405_i2c_init (CPUState
*env
, ppc4xx_mmio_t
*mmio
,
2112 target_phys_addr_t offset
, qemu_irq irq
)
2116 i2c
= qemu_mallocz(sizeof(ppc4xx_i2c_t
));
2120 ppc4xx_i2c_reset(i2c
);
2122 printf("%s: offset=" PADDRX
"\n", __func__
, offset
);
2124 ppc4xx_mmio_register(env
, mmio
, offset
, 0x011,
2125 i2c_read
, i2c_write
, i2c
);
2126 qemu_register_reset(ppc4xx_i2c_reset
, i2c
);
2130 /*****************************************************************************/
2131 /* General purpose timers */
2132 typedef struct ppc4xx_gpt_t ppc4xx_gpt_t
;
2133 struct ppc4xx_gpt_t
{
2134 target_phys_addr_t base
;
2137 struct QEMUTimer
*timer
;
2148 static uint32_t ppc4xx_gpt_readb (void *opaque
, target_phys_addr_t addr
)
2151 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
2153 /* XXX: generate a bus fault */
2157 static void ppc4xx_gpt_writeb (void *opaque
,
2158 target_phys_addr_t addr
, uint32_t value
)
2161 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
2163 /* XXX: generate a bus fault */
2166 static uint32_t ppc4xx_gpt_readw (void *opaque
, target_phys_addr_t addr
)
2169 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
2171 /* XXX: generate a bus fault */
2175 static void ppc4xx_gpt_writew (void *opaque
,
2176 target_phys_addr_t addr
, uint32_t value
)
2179 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
2181 /* XXX: generate a bus fault */
2184 static int ppc4xx_gpt_compare (ppc4xx_gpt_t
*gpt
, int n
)
2190 static void ppc4xx_gpt_set_output (ppc4xx_gpt_t
*gpt
, int n
, int level
)
2195 static void ppc4xx_gpt_set_outputs (ppc4xx_gpt_t
*gpt
)
2201 for (i
= 0; i
< 5; i
++) {
2202 if (gpt
->oe
& mask
) {
2203 /* Output is enabled */
2204 if (ppc4xx_gpt_compare(gpt
, i
)) {
2205 /* Comparison is OK */
2206 ppc4xx_gpt_set_output(gpt
, i
, gpt
->ol
& mask
);
2208 /* Comparison is KO */
2209 ppc4xx_gpt_set_output(gpt
, i
, gpt
->ol
& mask
? 0 : 1);
2217 static void ppc4xx_gpt_set_irqs (ppc4xx_gpt_t
*gpt
)
2223 for (i
= 0; i
< 5; i
++) {
2224 if (gpt
->is
& gpt
->im
& mask
)
2225 qemu_irq_raise(gpt
->irqs
[i
]);
2227 qemu_irq_lower(gpt
->irqs
[i
]);
2233 static void ppc4xx_gpt_compute_timer (ppc4xx_gpt_t
*gpt
)
2238 static uint32_t ppc4xx_gpt_readl (void *opaque
, target_phys_addr_t addr
)
2245 printf("%s: addr " PADDRX
"\n", __func__
, addr
);
2248 switch (addr
- gpt
->base
) {
2250 /* Time base counter */
2251 ret
= muldiv64(qemu_get_clock(vm_clock
) + gpt
->tb_offset
,
2252 gpt
->tb_freq
, ticks_per_sec
);
2263 /* Interrupt mask */
2268 /* Interrupt status */
2272 /* Interrupt enable */
2277 idx
= ((addr
- gpt
->base
) - 0x80) >> 2;
2278 ret
= gpt
->comp
[idx
];
2282 idx
= ((addr
- gpt
->base
) - 0xC0) >> 2;
2283 ret
= gpt
->mask
[idx
];
2293 static void ppc4xx_gpt_writel (void *opaque
,
2294 target_phys_addr_t addr
, uint32_t value
)
2300 printf("%s: addr " PADDRX
" val %08x\n", __func__
, addr
, value
);
2303 switch (addr
- gpt
->base
) {
2305 /* Time base counter */
2306 gpt
->tb_offset
= muldiv64(value
, ticks_per_sec
, gpt
->tb_freq
)
2307 - qemu_get_clock(vm_clock
);
2308 ppc4xx_gpt_compute_timer(gpt
);
2312 gpt
->oe
= value
& 0xF8000000;
2313 ppc4xx_gpt_set_outputs(gpt
);
2317 gpt
->ol
= value
& 0xF8000000;
2318 ppc4xx_gpt_set_outputs(gpt
);
2321 /* Interrupt mask */
2322 gpt
->im
= value
& 0x0000F800;
2325 /* Interrupt status set */
2326 gpt
->is
|= value
& 0x0000F800;
2327 ppc4xx_gpt_set_irqs(gpt
);
2330 /* Interrupt status clear */
2331 gpt
->is
&= ~(value
& 0x0000F800);
2332 ppc4xx_gpt_set_irqs(gpt
);
2335 /* Interrupt enable */
2336 gpt
->ie
= value
& 0x0000F800;
2337 ppc4xx_gpt_set_irqs(gpt
);
2341 idx
= ((addr
- gpt
->base
) - 0x80) >> 2;
2342 gpt
->comp
[idx
] = value
& 0xF8000000;
2343 ppc4xx_gpt_compute_timer(gpt
);
2347 idx
= ((addr
- gpt
->base
) - 0xC0) >> 2;
2348 gpt
->mask
[idx
] = value
& 0xF8000000;
2349 ppc4xx_gpt_compute_timer(gpt
);
2354 static CPUReadMemoryFunc
*gpt_read
[] = {
2360 static CPUWriteMemoryFunc
*gpt_write
[] = {
2366 static void ppc4xx_gpt_cb (void *opaque
)
2371 ppc4xx_gpt_set_irqs(gpt
);
2372 ppc4xx_gpt_set_outputs(gpt
);
2373 ppc4xx_gpt_compute_timer(gpt
);
2376 static void ppc4xx_gpt_reset (void *opaque
)
2382 qemu_del_timer(gpt
->timer
);
2383 gpt
->oe
= 0x00000000;
2384 gpt
->ol
= 0x00000000;
2385 gpt
->im
= 0x00000000;
2386 gpt
->is
= 0x00000000;
2387 gpt
->ie
= 0x00000000;
2388 for (i
= 0; i
< 5; i
++) {
2389 gpt
->comp
[i
] = 0x00000000;
2390 gpt
->mask
[i
] = 0x00000000;
2394 void ppc4xx_gpt_init (CPUState
*env
, ppc4xx_mmio_t
*mmio
,
2395 target_phys_addr_t offset
, qemu_irq irqs
[5])
2400 gpt
= qemu_mallocz(sizeof(ppc4xx_gpt_t
));
2403 for (i
= 0; i
< 5; i
++)
2404 gpt
->irqs
[i
] = irqs
[i
];
2405 gpt
->timer
= qemu_new_timer(vm_clock
, &ppc4xx_gpt_cb
, gpt
);
2406 ppc4xx_gpt_reset(gpt
);
2408 printf("%s: offset=" PADDRX
"\n", __func__
, offset
);
2410 ppc4xx_mmio_register(env
, mmio
, offset
, 0x0D4,
2411 gpt_read
, gpt_write
, gpt
);
2412 qemu_register_reset(ppc4xx_gpt_reset
, gpt
);
2416 /*****************************************************************************/
2422 MAL0_TXCASR
= 0x184,
2423 MAL0_TXCARR
= 0x185,
2424 MAL0_TXEOBISR
= 0x186,
2425 MAL0_TXDEIR
= 0x187,
2426 MAL0_RXCASR
= 0x190,
2427 MAL0_RXCARR
= 0x191,
2428 MAL0_RXEOBISR
= 0x192,
2429 MAL0_RXDEIR
= 0x193,
2430 MAL0_TXCTP0R
= 0x1A0,
2431 MAL0_TXCTP1R
= 0x1A1,
2432 MAL0_TXCTP2R
= 0x1A2,
2433 MAL0_TXCTP3R
= 0x1A3,
2434 MAL0_RXCTP0R
= 0x1C0,
2435 MAL0_RXCTP1R
= 0x1C1,
2440 typedef struct ppc40x_mal_t ppc40x_mal_t
;
2441 struct ppc40x_mal_t
{
2459 static void ppc40x_mal_reset (void *opaque
);
2461 static target_ulong
dcr_read_mal (void *opaque
, int dcrn
)
2484 ret
= mal
->txeobisr
;
2496 ret
= mal
->rxeobisr
;
2502 ret
= mal
->txctpr
[0];
2505 ret
= mal
->txctpr
[1];
2508 ret
= mal
->txctpr
[2];
2511 ret
= mal
->txctpr
[3];
2514 ret
= mal
->rxctpr
[0];
2517 ret
= mal
->rxctpr
[1];
2533 static void dcr_write_mal (void *opaque
, int dcrn
, target_ulong val
)
2541 if (val
& 0x80000000)
2542 ppc40x_mal_reset(mal
);
2543 mal
->cfg
= val
& 0x00FFC087;
2550 mal
->ier
= val
& 0x0000001F;
2553 mal
->txcasr
= val
& 0xF0000000;
2556 mal
->txcarr
= val
& 0xF0000000;
2560 mal
->txeobisr
&= ~val
;
2564 mal
->txdeir
&= ~val
;
2567 mal
->rxcasr
= val
& 0xC0000000;
2570 mal
->rxcarr
= val
& 0xC0000000;
2574 mal
->rxeobisr
&= ~val
;
2578 mal
->rxdeir
&= ~val
;
2592 mal
->txctpr
[idx
] = val
;
2600 mal
->rxctpr
[idx
] = val
;
2604 goto update_rx_size
;
2608 mal
->rcbs
[idx
] = val
& 0x000000FF;
2613 static void ppc40x_mal_reset (void *opaque
)
2618 mal
->cfg
= 0x0007C000;
2619 mal
->esr
= 0x00000000;
2620 mal
->ier
= 0x00000000;
2621 mal
->rxcasr
= 0x00000000;
2622 mal
->rxdeir
= 0x00000000;
2623 mal
->rxeobisr
= 0x00000000;
2624 mal
->txcasr
= 0x00000000;
2625 mal
->txdeir
= 0x00000000;
2626 mal
->txeobisr
= 0x00000000;
2629 void ppc405_mal_init (CPUState
*env
, qemu_irq irqs
[4])
2634 mal
= qemu_mallocz(sizeof(ppc40x_mal_t
));
2636 for (i
= 0; i
< 4; i
++)
2637 mal
->irqs
[i
] = irqs
[i
];
2638 ppc40x_mal_reset(mal
);
2639 qemu_register_reset(&ppc40x_mal_reset
, mal
);
2640 ppc_dcr_register(env
, MAL0_CFG
,
2641 mal
, &dcr_read_mal
, &dcr_write_mal
);
2642 ppc_dcr_register(env
, MAL0_ESR
,
2643 mal
, &dcr_read_mal
, &dcr_write_mal
);
2644 ppc_dcr_register(env
, MAL0_IER
,
2645 mal
, &dcr_read_mal
, &dcr_write_mal
);
2646 ppc_dcr_register(env
, MAL0_TXCASR
,
2647 mal
, &dcr_read_mal
, &dcr_write_mal
);
2648 ppc_dcr_register(env
, MAL0_TXCARR
,
2649 mal
, &dcr_read_mal
, &dcr_write_mal
);
2650 ppc_dcr_register(env
, MAL0_TXEOBISR
,
2651 mal
, &dcr_read_mal
, &dcr_write_mal
);
2652 ppc_dcr_register(env
, MAL0_TXDEIR
,
2653 mal
, &dcr_read_mal
, &dcr_write_mal
);
2654 ppc_dcr_register(env
, MAL0_RXCASR
,
2655 mal
, &dcr_read_mal
, &dcr_write_mal
);
2656 ppc_dcr_register(env
, MAL0_RXCARR
,
2657 mal
, &dcr_read_mal
, &dcr_write_mal
);
2658 ppc_dcr_register(env
, MAL0_RXEOBISR
,
2659 mal
, &dcr_read_mal
, &dcr_write_mal
);
2660 ppc_dcr_register(env
, MAL0_RXDEIR
,
2661 mal
, &dcr_read_mal
, &dcr_write_mal
);
2662 ppc_dcr_register(env
, MAL0_TXCTP0R
,
2663 mal
, &dcr_read_mal
, &dcr_write_mal
);
2664 ppc_dcr_register(env
, MAL0_TXCTP1R
,
2665 mal
, &dcr_read_mal
, &dcr_write_mal
);
2666 ppc_dcr_register(env
, MAL0_TXCTP2R
,
2667 mal
, &dcr_read_mal
, &dcr_write_mal
);
2668 ppc_dcr_register(env
, MAL0_TXCTP3R
,
2669 mal
, &dcr_read_mal
, &dcr_write_mal
);
2670 ppc_dcr_register(env
, MAL0_RXCTP0R
,
2671 mal
, &dcr_read_mal
, &dcr_write_mal
);
2672 ppc_dcr_register(env
, MAL0_RXCTP1R
,
2673 mal
, &dcr_read_mal
, &dcr_write_mal
);
2674 ppc_dcr_register(env
, MAL0_RCBS0
,
2675 mal
, &dcr_read_mal
, &dcr_write_mal
);
2676 ppc_dcr_register(env
, MAL0_RCBS1
,
2677 mal
, &dcr_read_mal
, &dcr_write_mal
);
2681 /*****************************************************************************/
2683 void ppc40x_core_reset (CPUState
*env
)
2687 printf("Reset PowerPC core\n");
2689 dbsr
= env
->spr
[SPR_40x_DBSR
];
2690 dbsr
&= ~0x00000300;
2692 env
->spr
[SPR_40x_DBSR
] = dbsr
;
2696 void ppc40x_chip_reset (CPUState
*env
)
2700 printf("Reset PowerPC chip\n");
2702 /* XXX: TODO reset all internal peripherals */
2703 dbsr
= env
->spr
[SPR_40x_DBSR
];
2704 dbsr
&= ~0x00000300;
2706 env
->spr
[SPR_40x_DBSR
] = dbsr
;
2710 void ppc40x_system_reset (CPUState
*env
)
2712 printf("Reset PowerPC system\n");
2713 qemu_system_reset_request();
2716 void store_40x_dbcr0 (CPUState
*env
, uint32_t val
)
2718 switch ((val
>> 28) & 0x3) {
2724 ppc40x_core_reset(env
);
2728 ppc40x_chip_reset(env
);
2732 ppc40x_system_reset(env
);
2737 /*****************************************************************************/
2740 PPC405CR_CPC0_PLLMR
= 0x0B0,
2741 PPC405CR_CPC0_CR0
= 0x0B1,
2742 PPC405CR_CPC0_CR1
= 0x0B2,
2743 PPC405CR_CPC0_PSR
= 0x0B4,
2744 PPC405CR_CPC0_JTAGID
= 0x0B5,
2745 PPC405CR_CPC0_ER
= 0x0B9,
2746 PPC405CR_CPC0_FR
= 0x0BA,
2747 PPC405CR_CPC0_SR
= 0x0BB,
2751 PPC405CR_CPU_CLK
= 0,
2752 PPC405CR_TMR_CLK
= 1,
2753 PPC405CR_PLB_CLK
= 2,
2754 PPC405CR_SDRAM_CLK
= 3,
2755 PPC405CR_OPB_CLK
= 4,
2756 PPC405CR_EXT_CLK
= 5,
2757 PPC405CR_UART_CLK
= 6,
2758 PPC405CR_CLK_NB
= 7,
2761 typedef struct ppc405cr_cpc_t ppc405cr_cpc_t
;
2762 struct ppc405cr_cpc_t
{
2763 clk_setup_t clk_setup
[PPC405CR_CLK_NB
];
2774 static void ppc405cr_clk_setup (ppc405cr_cpc_t
*cpc
)
2776 uint64_t VCO_out
, PLL_out
;
2777 uint32_t CPU_clk
, TMR_clk
, SDRAM_clk
, PLB_clk
, OPB_clk
, EXT_clk
, UART_clk
;
2780 D0
= ((cpc
->pllmr
>> 26) & 0x3) + 1; /* CBDV */
2781 if (cpc
->pllmr
& 0x80000000) {
2782 D1
= (((cpc
->pllmr
>> 20) - 1) & 0xF) + 1; /* FBDV */
2783 D2
= 8 - ((cpc
->pllmr
>> 16) & 0x7); /* FWDVA */
2785 VCO_out
= cpc
->sysclk
* M
;
2786 if (VCO_out
< 400000000 || VCO_out
> 800000000) {
2787 /* PLL cannot lock */
2788 cpc
->pllmr
&= ~0x80000000;
2791 PLL_out
= VCO_out
/ D2
;
2796 PLL_out
= cpc
->sysclk
* M
;
2799 if (cpc
->cr1
& 0x00800000)
2800 TMR_clk
= cpc
->sysclk
; /* Should have a separate clock */
2803 PLB_clk
= CPU_clk
/ D0
;
2804 SDRAM_clk
= PLB_clk
;
2805 D0
= ((cpc
->pllmr
>> 10) & 0x3) + 1;
2806 OPB_clk
= PLB_clk
/ D0
;
2807 D0
= ((cpc
->pllmr
>> 24) & 0x3) + 2;
2808 EXT_clk
= PLB_clk
/ D0
;
2809 D0
= ((cpc
->cr0
>> 1) & 0x1F) + 1;
2810 UART_clk
= CPU_clk
/ D0
;
2811 /* Setup CPU clocks */
2812 clk_setup(&cpc
->clk_setup
[PPC405CR_CPU_CLK
], CPU_clk
);
2813 /* Setup time-base clock */
2814 clk_setup(&cpc
->clk_setup
[PPC405CR_TMR_CLK
], TMR_clk
);
2815 /* Setup PLB clock */
2816 clk_setup(&cpc
->clk_setup
[PPC405CR_PLB_CLK
], PLB_clk
);
2817 /* Setup SDRAM clock */
2818 clk_setup(&cpc
->clk_setup
[PPC405CR_SDRAM_CLK
], SDRAM_clk
);
2819 /* Setup OPB clock */
2820 clk_setup(&cpc
->clk_setup
[PPC405CR_OPB_CLK
], OPB_clk
);
2821 /* Setup external clock */
2822 clk_setup(&cpc
->clk_setup
[PPC405CR_EXT_CLK
], EXT_clk
);
2823 /* Setup UART clock */
2824 clk_setup(&cpc
->clk_setup
[PPC405CR_UART_CLK
], UART_clk
);
2827 static target_ulong
dcr_read_crcpc (void *opaque
, int dcrn
)
2829 ppc405cr_cpc_t
*cpc
;
2834 case PPC405CR_CPC0_PLLMR
:
2837 case PPC405CR_CPC0_CR0
:
2840 case PPC405CR_CPC0_CR1
:
2843 case PPC405CR_CPC0_PSR
:
2846 case PPC405CR_CPC0_JTAGID
:
2849 case PPC405CR_CPC0_ER
:
2852 case PPC405CR_CPC0_FR
:
2855 case PPC405CR_CPC0_SR
:
2856 ret
= ~(cpc
->er
| cpc
->fr
) & 0xFFFF0000;
2859 /* Avoid gcc warning */
2867 static void dcr_write_crcpc (void *opaque
, int dcrn
, target_ulong val
)
2869 ppc405cr_cpc_t
*cpc
;
2873 case PPC405CR_CPC0_PLLMR
:
2874 cpc
->pllmr
= val
& 0xFFF77C3F;
2876 case PPC405CR_CPC0_CR0
:
2877 cpc
->cr0
= val
& 0x0FFFFFFE;
2879 case PPC405CR_CPC0_CR1
:
2880 cpc
->cr1
= val
& 0x00800000;
2882 case PPC405CR_CPC0_PSR
:
2885 case PPC405CR_CPC0_JTAGID
:
2888 case PPC405CR_CPC0_ER
:
2889 cpc
->er
= val
& 0xBFFC0000;
2891 case PPC405CR_CPC0_FR
:
2892 cpc
->fr
= val
& 0xBFFC0000;
2894 case PPC405CR_CPC0_SR
:
2900 static void ppc405cr_cpc_reset (void *opaque
)
2902 ppc405cr_cpc_t
*cpc
;
2906 /* Compute PLLMR value from PSR settings */
2907 cpc
->pllmr
= 0x80000000;
2909 switch ((cpc
->psr
>> 30) & 3) {
2912 cpc
->pllmr
&= ~0x80000000;
2916 cpc
->pllmr
|= 5 << 16;
2920 cpc
->pllmr
|= 4 << 16;
2924 cpc
->pllmr
|= 2 << 16;
2928 D
= (cpc
->psr
>> 28) & 3;
2929 cpc
->pllmr
|= (D
+ 1) << 20;
2931 D
= (cpc
->psr
>> 25) & 7;
2946 D
= (cpc
->psr
>> 23) & 3;
2947 cpc
->pllmr
|= D
<< 26;
2949 D
= (cpc
->psr
>> 21) & 3;
2950 cpc
->pllmr
|= D
<< 10;
2952 D
= (cpc
->psr
>> 17) & 3;
2953 cpc
->pllmr
|= D
<< 24;
2954 cpc
->cr0
= 0x0000003C;
2955 cpc
->cr1
= 0x2B0D8800;
2956 cpc
->er
= 0x00000000;
2957 cpc
->fr
= 0x00000000;
2958 ppc405cr_clk_setup(cpc
);
2961 static void ppc405cr_clk_init (ppc405cr_cpc_t
*cpc
)
2965 /* XXX: this should be read from IO pins */
2966 cpc
->psr
= 0x00000000; /* 8 bits ROM */
2968 D
= 0x2; /* Divide by 4 */
2969 cpc
->psr
|= D
<< 30;
2971 D
= 0x1; /* Divide by 2 */
2972 cpc
->psr
|= D
<< 28;
2974 D
= 0x1; /* Divide by 2 */
2975 cpc
->psr
|= D
<< 23;
2977 D
= 0x5; /* M = 16 */
2978 cpc
->psr
|= D
<< 25;
2980 D
= 0x1; /* Divide by 2 */
2981 cpc
->psr
|= D
<< 21;
2983 D
= 0x2; /* Divide by 4 */
2984 cpc
->psr
|= D
<< 17;
2987 static void ppc405cr_cpc_init (CPUState
*env
, clk_setup_t clk_setup
[7],
2990 ppc405cr_cpc_t
*cpc
;
2992 cpc
= qemu_mallocz(sizeof(ppc405cr_cpc_t
));
2994 memcpy(cpc
->clk_setup
, clk_setup
,
2995 PPC405CR_CLK_NB
* sizeof(clk_setup_t
));
2996 cpc
->sysclk
= sysclk
;
2997 cpc
->jtagid
= 0x42051049;
2998 ppc_dcr_register(env
, PPC405CR_CPC0_PSR
, cpc
,
2999 &dcr_read_crcpc
, &dcr_write_crcpc
);
3000 ppc_dcr_register(env
, PPC405CR_CPC0_CR0
, cpc
,
3001 &dcr_read_crcpc
, &dcr_write_crcpc
);
3002 ppc_dcr_register(env
, PPC405CR_CPC0_CR1
, cpc
,
3003 &dcr_read_crcpc
, &dcr_write_crcpc
);
3004 ppc_dcr_register(env
, PPC405CR_CPC0_JTAGID
, cpc
,
3005 &dcr_read_crcpc
, &dcr_write_crcpc
);
3006 ppc_dcr_register(env
, PPC405CR_CPC0_PLLMR
, cpc
,
3007 &dcr_read_crcpc
, &dcr_write_crcpc
);
3008 ppc_dcr_register(env
, PPC405CR_CPC0_ER
, cpc
,
3009 &dcr_read_crcpc
, &dcr_write_crcpc
);
3010 ppc_dcr_register(env
, PPC405CR_CPC0_FR
, cpc
,
3011 &dcr_read_crcpc
, &dcr_write_crcpc
);
3012 ppc_dcr_register(env
, PPC405CR_CPC0_SR
, cpc
,
3013 &dcr_read_crcpc
, &dcr_write_crcpc
);
3014 ppc405cr_clk_init(cpc
);
3015 qemu_register_reset(ppc405cr_cpc_reset
, cpc
);
3016 ppc405cr_cpc_reset(cpc
);
3020 CPUState
*ppc405cr_init (target_ulong ram_bases
[4], target_ulong ram_sizes
[4],
3021 uint32_t sysclk
, qemu_irq
**picp
,
3022 ram_addr_t
*offsetp
, int do_init
)
3024 clk_setup_t clk_setup
[PPC405CR_CLK_NB
];
3025 qemu_irq dma_irqs
[4];
3027 ppc4xx_mmio_t
*mmio
;
3028 qemu_irq
*pic
, *irqs
;
3032 memset(clk_setup
, 0, sizeof(clk_setup
));
3033 env
= ppc405_init("405cr", &clk_setup
[PPC405CR_CPU_CLK
],
3034 &clk_setup
[PPC405CR_TMR_CLK
], sysclk
);
3035 /* Memory mapped devices registers */
3036 mmio
= ppc4xx_mmio_init(env
, 0xEF600000);
3038 ppc4xx_plb_init(env
);
3039 /* PLB to OPB bridge */
3040 ppc4xx_pob_init(env
);
3042 ppc4xx_opba_init(env
, mmio
, 0x600);
3043 /* Universal interrupt controller */
3044 irqs
= qemu_mallocz(sizeof(qemu_irq
) * PPCUIC_OUTPUT_NB
);
3045 irqs
[PPCUIC_OUTPUT_INT
] =
3046 ((qemu_irq
*)env
->irq_inputs
)[PPC405_INPUT_INT
];
3047 irqs
[PPCUIC_OUTPUT_CINT
] =
3048 ((qemu_irq
*)env
->irq_inputs
)[PPC405_INPUT_CINT
];
3049 pic
= ppcuic_init(env
, irqs
, 0x0C0, 0, 1);
3051 /* SDRAM controller */
3052 ppc405_sdram_init(env
, pic
[14], 1, ram_bases
, ram_sizes
, do_init
);
3054 for (i
= 0; i
< 4; i
++)
3055 offset
+= ram_sizes
[i
];
3056 /* External bus controller */
3057 ppc405_ebc_init(env
);
3058 /* DMA controller */
3059 dma_irqs
[0] = pic
[26];
3060 dma_irqs
[1] = pic
[25];
3061 dma_irqs
[2] = pic
[24];
3062 dma_irqs
[3] = pic
[23];
3063 ppc405_dma_init(env
, dma_irqs
);
3065 if (serial_hds
[0] != NULL
) {
3066 ppc405_serial_init(env
, mmio
, 0x300, pic
[31], serial_hds
[0]);
3068 if (serial_hds
[1] != NULL
) {
3069 ppc405_serial_init(env
, mmio
, 0x400, pic
[30], serial_hds
[1]);
3071 /* IIC controller */
3072 ppc405_i2c_init(env
, mmio
, 0x500, pic
[29]);
3074 ppc405_gpio_init(env
, mmio
, 0x700);
3076 ppc405cr_cpc_init(env
, clk_setup
, sysclk
);
3082 /*****************************************************************************/
3086 PPC405EP_CPC0_PLLMR0
= 0x0F0,
3087 PPC405EP_CPC0_BOOT
= 0x0F1,
3088 PPC405EP_CPC0_EPCTL
= 0x0F3,
3089 PPC405EP_CPC0_PLLMR1
= 0x0F4,
3090 PPC405EP_CPC0_UCR
= 0x0F5,
3091 PPC405EP_CPC0_SRR
= 0x0F6,
3092 PPC405EP_CPC0_JTAGID
= 0x0F7,
3093 PPC405EP_CPC0_PCI
= 0x0F9,
3095 PPC405EP_CPC0_ER
= xxx
,
3096 PPC405EP_CPC0_FR
= xxx
,
3097 PPC405EP_CPC0_SR
= xxx
,
3102 PPC405EP_CPU_CLK
= 0,
3103 PPC405EP_PLB_CLK
= 1,
3104 PPC405EP_OPB_CLK
= 2,
3105 PPC405EP_EBC_CLK
= 3,
3106 PPC405EP_MAL_CLK
= 4,
3107 PPC405EP_PCI_CLK
= 5,
3108 PPC405EP_UART0_CLK
= 6,
3109 PPC405EP_UART1_CLK
= 7,
3110 PPC405EP_CLK_NB
= 8,
3113 typedef struct ppc405ep_cpc_t ppc405ep_cpc_t
;
3114 struct ppc405ep_cpc_t
{
3116 clk_setup_t clk_setup
[PPC405EP_CLK_NB
];
3124 /* Clock and power management */
3130 static void ppc405ep_compute_clocks (ppc405ep_cpc_t
*cpc
)
3132 uint32_t CPU_clk
, PLB_clk
, OPB_clk
, EBC_clk
, MAL_clk
, PCI_clk
;
3133 uint32_t UART0_clk
, UART1_clk
;
3134 uint64_t VCO_out
, PLL_out
;
3138 if ((cpc
->pllmr
[1] & 0x80000000) && !(cpc
->pllmr
[1] & 0x40000000)) {
3139 M
= (((cpc
->pllmr
[1] >> 20) - 1) & 0xF) + 1; /* FBMUL */
3140 // printf("FBMUL %01x %d\n", (cpc->pllmr[1] >> 20) & 0xF, M);
3141 D
= 8 - ((cpc
->pllmr
[1] >> 16) & 0x7); /* FWDA */
3142 // printf("FWDA %01x %d\n", (cpc->pllmr[1] >> 16) & 0x7, D);
3143 VCO_out
= cpc
->sysclk
* M
* D
;
3144 if (VCO_out
< 500000000UL || VCO_out
> 1000000000UL) {
3145 /* Error - unlock the PLL */
3146 printf("VCO out of range %" PRIu64
"\n", VCO_out
);
3148 cpc
->pllmr
[1] &= ~0x80000000;
3152 PLL_out
= VCO_out
/ D
;
3153 /* Pretend the PLL is locked */
3154 cpc
->boot
|= 0x00000001;
3159 PLL_out
= cpc
->sysclk
;
3160 if (cpc
->pllmr
[1] & 0x40000000) {
3161 /* Pretend the PLL is not locked */
3162 cpc
->boot
&= ~0x00000001;
3165 /* Now, compute all other clocks */
3166 D
= ((cpc
->pllmr
[0] >> 20) & 0x3) + 1; /* CCDV */
3168 // printf("CCDV %01x %d\n", (cpc->pllmr[0] >> 20) & 0x3, D);
3170 CPU_clk
= PLL_out
/ D
;
3171 D
= ((cpc
->pllmr
[0] >> 16) & 0x3) + 1; /* CBDV */
3173 // printf("CBDV %01x %d\n", (cpc->pllmr[0] >> 16) & 0x3, D);
3175 PLB_clk
= CPU_clk
/ D
;
3176 D
= ((cpc
->pllmr
[0] >> 12) & 0x3) + 1; /* OPDV */
3178 // printf("OPDV %01x %d\n", (cpc->pllmr[0] >> 12) & 0x3, D);
3180 OPB_clk
= PLB_clk
/ D
;
3181 D
= ((cpc
->pllmr
[0] >> 8) & 0x3) + 2; /* EPDV */
3183 // printf("EPDV %01x %d\n", (cpc->pllmr[0] >> 8) & 0x3, D);
3185 EBC_clk
= PLB_clk
/ D
;
3186 D
= ((cpc
->pllmr
[0] >> 4) & 0x3) + 1; /* MPDV */
3188 // printf("MPDV %01x %d\n", (cpc->pllmr[0] >> 4) & 0x3, D);
3190 MAL_clk
= PLB_clk
/ D
;
3191 D
= (cpc
->pllmr
[0] & 0x3) + 1; /* PPDV */
3193 // printf("PPDV %01x %d\n", cpc->pllmr[0] & 0x3, D);
3195 PCI_clk
= PLB_clk
/ D
;
3196 D
= ((cpc
->ucr
- 1) & 0x7F) + 1; /* U0DIV */
3198 // printf("U0DIV %01x %d\n", cpc->ucr & 0x7F, D);
3200 UART0_clk
= PLL_out
/ D
;
3201 D
= (((cpc
->ucr
>> 8) - 1) & 0x7F) + 1; /* U1DIV */
3203 // printf("U1DIV %01x %d\n", (cpc->ucr >> 8) & 0x7F, D);
3205 UART1_clk
= PLL_out
/ D
;
3207 printf("Setup PPC405EP clocks - sysclk %d VCO %" PRIu64
3208 " PLL out %" PRIu64
" Hz\n", cpc
->sysclk
, VCO_out
, PLL_out
);
3209 printf("CPU %d PLB %d OPB %d EBC %d MAL %d PCI %d UART0 %d UART1 %d\n",
3210 CPU_clk
, PLB_clk
, OPB_clk
, EBC_clk
, MAL_clk
, PCI_clk
,
3211 UART0_clk
, UART1_clk
);
3212 printf("CB %p opaque %p\n", cpc
->clk_setup
[PPC405EP_CPU_CLK
].cb
,
3213 cpc
->clk_setup
[PPC405EP_CPU_CLK
].opaque
);
3215 /* Setup CPU clocks */
3216 clk_setup(&cpc
->clk_setup
[PPC405EP_CPU_CLK
], CPU_clk
);
3217 /* Setup PLB clock */
3218 clk_setup(&cpc
->clk_setup
[PPC405EP_PLB_CLK
], PLB_clk
);
3219 /* Setup OPB clock */
3220 clk_setup(&cpc
->clk_setup
[PPC405EP_OPB_CLK
], OPB_clk
);
3221 /* Setup external clock */
3222 clk_setup(&cpc
->clk_setup
[PPC405EP_EBC_CLK
], EBC_clk
);
3223 /* Setup MAL clock */
3224 clk_setup(&cpc
->clk_setup
[PPC405EP_MAL_CLK
], MAL_clk
);
3225 /* Setup PCI clock */
3226 clk_setup(&cpc
->clk_setup
[PPC405EP_PCI_CLK
], PCI_clk
);
3227 /* Setup UART0 clock */
3228 clk_setup(&cpc
->clk_setup
[PPC405EP_UART0_CLK
], UART0_clk
);
3229 /* Setup UART1 clock */
3230 clk_setup(&cpc
->clk_setup
[PPC405EP_UART1_CLK
], UART1_clk
);
3233 static target_ulong
dcr_read_epcpc (void *opaque
, int dcrn
)
3235 ppc405ep_cpc_t
*cpc
;
3240 case PPC405EP_CPC0_BOOT
:
3243 case PPC405EP_CPC0_EPCTL
:
3246 case PPC405EP_CPC0_PLLMR0
:
3247 ret
= cpc
->pllmr
[0];
3249 case PPC405EP_CPC0_PLLMR1
:
3250 ret
= cpc
->pllmr
[1];
3252 case PPC405EP_CPC0_UCR
:
3255 case PPC405EP_CPC0_SRR
:
3258 case PPC405EP_CPC0_JTAGID
:
3261 case PPC405EP_CPC0_PCI
:
3265 /* Avoid gcc warning */
3273 static void dcr_write_epcpc (void *opaque
, int dcrn
, target_ulong val
)
3275 ppc405ep_cpc_t
*cpc
;
3279 case PPC405EP_CPC0_BOOT
:
3280 /* Read-only register */
3282 case PPC405EP_CPC0_EPCTL
:
3283 /* Don't care for now */
3284 cpc
->epctl
= val
& 0xC00000F3;
3286 case PPC405EP_CPC0_PLLMR0
:
3287 cpc
->pllmr
[0] = val
& 0x00633333;
3288 ppc405ep_compute_clocks(cpc
);
3290 case PPC405EP_CPC0_PLLMR1
:
3291 cpc
->pllmr
[1] = val
& 0xC0F73FFF;
3292 ppc405ep_compute_clocks(cpc
);
3294 case PPC405EP_CPC0_UCR
:
3295 /* UART control - don't care for now */
3296 cpc
->ucr
= val
& 0x003F7F7F;
3298 case PPC405EP_CPC0_SRR
:
3301 case PPC405EP_CPC0_JTAGID
:
3304 case PPC405EP_CPC0_PCI
:
3310 static void ppc405ep_cpc_reset (void *opaque
)
3312 ppc405ep_cpc_t
*cpc
= opaque
;
3314 cpc
->boot
= 0x00000010; /* Boot from PCI - IIC EEPROM disabled */
3315 cpc
->epctl
= 0x00000000;
3316 cpc
->pllmr
[0] = 0x00011010;
3317 cpc
->pllmr
[1] = 0x40000000;
3318 cpc
->ucr
= 0x00000000;
3319 cpc
->srr
= 0x00040000;
3320 cpc
->pci
= 0x00000000;
3321 cpc
->er
= 0x00000000;
3322 cpc
->fr
= 0x00000000;
3323 cpc
->sr
= 0x00000000;
3324 ppc405ep_compute_clocks(cpc
);
3327 /* XXX: sysclk should be between 25 and 100 MHz */
3328 static void ppc405ep_cpc_init (CPUState
*env
, clk_setup_t clk_setup
[8],
3331 ppc405ep_cpc_t
*cpc
;
3333 cpc
= qemu_mallocz(sizeof(ppc405ep_cpc_t
));
3335 memcpy(cpc
->clk_setup
, clk_setup
,
3336 PPC405EP_CLK_NB
* sizeof(clk_setup_t
));
3337 cpc
->jtagid
= 0x20267049;
3338 cpc
->sysclk
= sysclk
;
3339 ppc405ep_cpc_reset(cpc
);
3340 qemu_register_reset(&ppc405ep_cpc_reset
, cpc
);
3341 ppc_dcr_register(env
, PPC405EP_CPC0_BOOT
, cpc
,
3342 &dcr_read_epcpc
, &dcr_write_epcpc
);
3343 ppc_dcr_register(env
, PPC405EP_CPC0_EPCTL
, cpc
,
3344 &dcr_read_epcpc
, &dcr_write_epcpc
);
3345 ppc_dcr_register(env
, PPC405EP_CPC0_PLLMR0
, cpc
,
3346 &dcr_read_epcpc
, &dcr_write_epcpc
);
3347 ppc_dcr_register(env
, PPC405EP_CPC0_PLLMR1
, cpc
,
3348 &dcr_read_epcpc
, &dcr_write_epcpc
);
3349 ppc_dcr_register(env
, PPC405EP_CPC0_UCR
, cpc
,
3350 &dcr_read_epcpc
, &dcr_write_epcpc
);
3351 ppc_dcr_register(env
, PPC405EP_CPC0_SRR
, cpc
,
3352 &dcr_read_epcpc
, &dcr_write_epcpc
);
3353 ppc_dcr_register(env
, PPC405EP_CPC0_JTAGID
, cpc
,
3354 &dcr_read_epcpc
, &dcr_write_epcpc
);
3355 ppc_dcr_register(env
, PPC405EP_CPC0_PCI
, cpc
,
3356 &dcr_read_epcpc
, &dcr_write_epcpc
);
3358 ppc_dcr_register(env
, PPC405EP_CPC0_ER
, cpc
,
3359 &dcr_read_epcpc
, &dcr_write_epcpc
);
3360 ppc_dcr_register(env
, PPC405EP_CPC0_FR
, cpc
,
3361 &dcr_read_epcpc
, &dcr_write_epcpc
);
3362 ppc_dcr_register(env
, PPC405EP_CPC0_SR
, cpc
,
3363 &dcr_read_epcpc
, &dcr_write_epcpc
);
3368 CPUState
*ppc405ep_init (target_ulong ram_bases
[2], target_ulong ram_sizes
[2],
3369 uint32_t sysclk
, qemu_irq
**picp
,
3370 ram_addr_t
*offsetp
, int do_init
)
3372 clk_setup_t clk_setup
[PPC405EP_CLK_NB
], tlb_clk_setup
;
3373 qemu_irq dma_irqs
[4], gpt_irqs
[5], mal_irqs
[4];
3375 ppc4xx_mmio_t
*mmio
;
3376 qemu_irq
*pic
, *irqs
;
3380 memset(clk_setup
, 0, sizeof(clk_setup
));
3382 env
= ppc405_init("405ep", &clk_setup
[PPC405EP_CPU_CLK
],
3383 &tlb_clk_setup
, sysclk
);
3384 clk_setup
[PPC405EP_CPU_CLK
].cb
= tlb_clk_setup
.cb
;
3385 clk_setup
[PPC405EP_CPU_CLK
].opaque
= tlb_clk_setup
.opaque
;
3386 /* Internal devices init */
3387 /* Memory mapped devices registers */
3388 mmio
= ppc4xx_mmio_init(env
, 0xEF600000);
3390 ppc4xx_plb_init(env
);
3391 /* PLB to OPB bridge */
3392 ppc4xx_pob_init(env
);
3394 ppc4xx_opba_init(env
, mmio
, 0x600);
3395 /* Universal interrupt controller */
3396 irqs
= qemu_mallocz(sizeof(qemu_irq
) * PPCUIC_OUTPUT_NB
);
3397 irqs
[PPCUIC_OUTPUT_INT
] =
3398 ((qemu_irq
*)env
->irq_inputs
)[PPC405_INPUT_INT
];
3399 irqs
[PPCUIC_OUTPUT_CINT
] =
3400 ((qemu_irq
*)env
->irq_inputs
)[PPC405_INPUT_CINT
];
3401 pic
= ppcuic_init(env
, irqs
, 0x0C0, 0, 1);
3403 /* SDRAM controller */
3404 ppc405_sdram_init(env
, pic
[14], 2, ram_bases
, ram_sizes
, do_init
);
3406 for (i
= 0; i
< 2; i
++)
3407 offset
+= ram_sizes
[i
];
3408 /* External bus controller */
3409 ppc405_ebc_init(env
);
3410 /* DMA controller */
3411 dma_irqs
[0] = pic
[26];
3412 dma_irqs
[1] = pic
[25];
3413 dma_irqs
[2] = pic
[24];
3414 dma_irqs
[3] = pic
[23];
3415 ppc405_dma_init(env
, dma_irqs
);
3416 /* IIC controller */
3417 ppc405_i2c_init(env
, mmio
, 0x500, pic
[29]);
3419 ppc405_gpio_init(env
, mmio
, 0x700);
3421 if (serial_hds
[0] != NULL
) {
3422 ppc405_serial_init(env
, mmio
, 0x300, pic
[31], serial_hds
[0]);
3424 if (serial_hds
[1] != NULL
) {
3425 ppc405_serial_init(env
, mmio
, 0x400, pic
[30], serial_hds
[1]);
3428 ppc405_ocm_init(env
, ram_sizes
[0] + ram_sizes
[1]);
3431 gpt_irqs
[0] = pic
[12];
3432 gpt_irqs
[1] = pic
[11];
3433 gpt_irqs
[2] = pic
[10];
3434 gpt_irqs
[3] = pic
[9];
3435 gpt_irqs
[4] = pic
[8];
3436 ppc4xx_gpt_init(env
, mmio
, 0x000, gpt_irqs
);
3438 /* Uses pic[28], pic[15], pic[13] */
3440 mal_irqs
[0] = pic
[20];
3441 mal_irqs
[1] = pic
[19];
3442 mal_irqs
[2] = pic
[18];
3443 mal_irqs
[3] = pic
[17];
3444 ppc405_mal_init(env
, mal_irqs
);
3446 /* Uses pic[22], pic[16], pic[14] */
3448 ppc405ep_cpc_init(env
, clk_setup
, sysclk
);