Statistics
| Branch: | Revision:

root / target-cris / helper.c @ 941db528

History | View | Annotate | Download (4 kB)

1
/*
2
 *  CRIS helper routines.
3
 *
4
 *  Copyright (c) 2007 AXIS Communications AB
5
 *  Written by Edgar E. Iglesias.
6
 *
7
 * This library is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2 of the License, or (at your option) any later version.
11
 *
12
 * This library is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library; if not, write to the Free Software
19
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20
 */
21

    
22
#include <stdio.h>
23
#include <string.h>
24

    
25
#include "config.h"
26
#include "cpu.h"
27
#include "mmu.h"
28
#include "exec-all.h"
29
#include "host-utils.h"
30

    
31
#if defined(CONFIG_USER_ONLY)
32

    
33
void do_interrupt (CPUState *env)
34
{
35
  env->exception_index = -1;
36
}
37

    
38
int cpu_cris_handle_mmu_fault(CPUState * env, target_ulong address, int rw,
39
                             int mmu_idx, int is_softmmu)
40
{
41
    env->exception_index = 0xaa;
42
    env->debug1 = address;
43
    cpu_dump_state(env, stderr, fprintf, 0);
44
    printf("%s addr=%x env->pc=%x\n", __func__, address, env->pc);
45
    return 1;
46
}
47

    
48
target_phys_addr_t cpu_get_phys_page_debug(CPUState * env, target_ulong addr)
49
{
50
    return addr;
51
}
52

    
53
#else /* !CONFIG_USER_ONLY */
54

    
55
int cpu_cris_handle_mmu_fault (CPUState *env, target_ulong address, int rw,
56
                               int mmu_idx, int is_softmmu)
57
{
58
        struct cris_mmu_result_t res;
59
        int prot, miss;
60
        target_ulong phy;
61

    
62
        address &= TARGET_PAGE_MASK;
63
        prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
64
//        printf ("%s pc=%x %x w=%d smmu=%d\n", __func__, env->pc, address, rw, is_softmmu);
65
        miss = cris_mmu_translate(&res, env, address, rw, mmu_idx);
66
        if (miss)
67
        {
68
                /* handle the miss.  */
69
                phy = 0;
70
                env->exception_index = EXCP_MMU_MISS;
71
        }
72
        else
73
        {
74
                phy = res.phy;
75
        }
76
//        printf ("a=%x phy=%x\n", address, phy);
77
        return tlb_set_page(env, address, phy, prot, mmu_idx, is_softmmu);
78
}
79

    
80

    
81
static void cris_shift_ccs(CPUState *env)
82
{
83
        uint32_t ccs;
84
        /* Apply the ccs shift.  */
85
        ccs = env->pregs[SR_CCS];
86
        ccs = (ccs & 0xc0000000) | ((ccs << 12) >> 2);
87
//        printf ("ccs=%x %x\n", env->pregs[SR_CCS], ccs);
88
        env->pregs[SR_CCS] = ccs;
89
}
90

    
91
void do_interrupt(CPUState *env)
92
{
93
        uint32_t ebp, isr;
94
        int irqnum;
95

    
96
        fflush(NULL);
97

    
98
#if 0
99
        printf ("exception index=%d interrupt_req=%d\n",
100
                env->exception_index,
101
                env->interrupt_request);
102
#endif
103

    
104
        switch (env->exception_index)
105
        {
106
                case EXCP_BREAK:
107
//                        printf ("BREAK! %d\n", env->trapnr);
108
                        irqnum = env->trapnr;
109
                        ebp = env->pregs[SR_EBP];
110
                        isr = ldl_code(ebp + irqnum * 4);
111
                        env->pregs[SR_ERP] = env->pc + 2;
112
                        env->pc = isr;
113

    
114
                        cris_shift_ccs(env);
115

    
116
                        break;
117
                case EXCP_MMU_MISS:
118
//                        printf ("MMU miss\n");
119
                        irqnum = 4;
120
                        ebp = env->pregs[SR_EBP];
121
                        isr = ldl_code(ebp + irqnum * 4);
122
                        env->pregs[SR_ERP] = env->pc;
123
                        env->pc = isr;
124
                        cris_shift_ccs(env);
125
                        break;
126

    
127
                default:
128
                {
129
                        /* Maybe the irq was acked by sw before we got a
130
                           change to take it.  */
131
                        if (env->interrupt_request & CPU_INTERRUPT_HARD) {
132
                                if (!env->pending_interrupts)
133
                                        return;
134
                                if (!(env->pregs[SR_CCS] & I_FLAG)) {
135
                                        return;
136
                                }
137

    
138
                                irqnum = 31 - clz32(env->pending_interrupts);
139
                                irqnum += 0x30;
140
                                ebp = env->pregs[SR_EBP];
141
                                isr = ldl_code(ebp + irqnum * 4);
142
                                env->pregs[SR_ERP] = env->pc;
143
                                env->pc = isr;
144

    
145
                                cris_shift_ccs(env);
146
#if 0
147
                                printf ("%s ebp=%x %x isr=%x %d"
148
                                        " ir=%x pending=%x\n",
149
                                        __func__,
150
                                        ebp, ebp + irqnum * 4,
151
                                        isr, env->exception_index,
152
                                        env->interrupt_request,
153
                                        env->pending_interrupts);
154
#endif
155
                        }
156

    
157
                }
158
                break;
159
        }
160
}
161

    
162
target_phys_addr_t cpu_get_phys_page_debug(CPUState * env, target_ulong addr)
163
{
164
//        printf ("%s\n", __func__);
165
        uint32_t phy = addr;
166
        struct cris_mmu_result_t res;
167
        int miss;
168
        miss = cris_mmu_translate(&res, env, addr, 0, 0);
169
        if (!miss)
170
                phy = res.phy;
171
        return phy;
172
}
173
#endif