← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to target-microblaze/mmu.c

  • Committer: Edgar E. Iglesias
  • Date: 2009-09-03 11:04:02 UTC
  • Revision ID: git-v1:3c50a71fc933c0ffba82c95111fa780e6110d79f
microblaze: MMU shows more respect to synthesis config.

The microblaze MMU can be synthesized in different configurations.
Have the MMU model show more respect to the chosen configuration.

Signed-off-by: Edgar E. Iglesias <edgar.iglesias@gmail.com>

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-microblaze/mmu.c
127
127
            tlb_zsel = (d >> 4) & 0xf;
128
128
            t0 = mmu->regs[MMU_R_ZPR] >> (30 - (tlb_zsel * 2));
129
129
            t0 &= 0x3;
 
130
 
 
131
            if (tlb_zsel > mmu->c_mmu_zones) {
 
132
                qemu_log("tlb zone select out of range! %d\n", tlb_zsel);
 
133
                t0 = 1; /* Ignore.  */
 
134
            }
 
135
 
 
136
            if (mmu->c_mmu == 1) {
 
137
                t0 = 1; /* Zones are disabled.  */
 
138
            }
 
139
 
130
140
            switch (t0) {
131
141
                case 0:
132
142
                    if (mmu_idx == MMU_USER_IDX)
142
152
                    tlb_ex = 1;
143
153
                    tlb_wr = 1;
144
154
                    break;
 
155
                default: break;
145
156
            }
146
157
 
147
 
 
148
158
            lu->err = ERR_PROT;
149
159
            lu->prot = PAGE_READ;
150
160
            if (tlb_wr)
180
190
    unsigned int i;
181
191
    uint32_t r;
182
192
 
 
193
    if (env->mmu.c_mmu < 2 || !env->mmu.c_mmu_tlb_access) {
 
194
        qemu_log("MMU access on MMU-less system\n");
 
195
        return 0;
 
196
    }
 
197
 
183
198
    switch (rn) {
184
199
        /* Reads to HI/LO trig reads from the mmu rams.  */
185
200
        case MMU_R_TLBLO:
186
201
        case MMU_R_TLBHI:
 
202
            if (!(env->mmu.c_mmu_tlb_access & 1)) {
 
203
                qemu_log("Invalid access to MMU reg %d\n", rn);
 
204
                return 0;
 
205
            }
 
206
 
187
207
            i = env->mmu.regs[MMU_R_TLBX] & 0xff;
188
208
            r = env->mmu.rams[rn & 1][i];
189
209
            if (rn == MMU_R_TLBHI)
190
210
                env->mmu.regs[MMU_R_PID] = env->mmu.tids[i];
191
211
            break;
 
212
        case MMU_R_PID:
 
213
        case MMU_R_ZPR:
 
214
            if (!(env->mmu.c_mmu_tlb_access & 1)) {
 
215
                qemu_log("Invalid access to MMU reg %d\n", rn);
 
216
                return 0;
 
217
            }
 
218
            r = env->mmu.regs[rn];
 
219
            break;
192
220
        default:
193
221
            r = env->mmu.regs[rn];
194
222
            break;
202
230
    unsigned int i;
203
231
    D(qemu_log("%s rn=%d=%x old=%x\n", __func__, rn, v, env->mmu.regs[rn]));
204
232
 
 
233
    if (env->mmu.c_mmu < 2 || !env->mmu.c_mmu_tlb_access) {
 
234
        qemu_log("MMU access on MMU-less system\n");
 
235
        return;
 
236
    }
 
237
 
205
238
    switch (rn) {
206
239
        /* Writes to HI/LO trig writes to the mmu rams.  */
207
240
        case MMU_R_TLBLO:
219
252
            D(qemu_log("%s ram[%d][%d]=%x\n", __func__, rn & 1, i, v));
220
253
            break;
221
254
        case MMU_R_ZPR:
 
255
            if (env->mmu.c_mmu_tlb_access <= 1) {
 
256
                qemu_log("Invalid access to MMU reg %d\n", rn);
 
257
                return;
 
258
            }
 
259
 
222
260
            /* Changes to the zone protection reg flush the QEMU TLB.
223
261
               Fortunately, these are very uncommon.  */
224
262
            if (v != env->mmu.regs[rn]) {
227
265
            env->mmu.regs[rn] = v;
228
266
            break;
229
267
        case MMU_R_PID:
 
268
            if (env->mmu.c_mmu_tlb_access <= 1) {
 
269
                qemu_log("Invalid access to MMU reg %d\n", rn);
 
270
                return;
 
271
            }
 
272
 
230
273
            if (v != env->mmu.regs[rn]) {
231
274
                mmu_change_pid(env, v);
232
275
                env->mmu.regs[rn] = v;
236
279
        {
237
280
            struct microblaze_mmu_lookup lu;
238
281
            int hit;
 
282
 
 
283
            if (env->mmu.c_mmu_tlb_access <= 1) {
 
284
                qemu_log("Invalid access to MMU reg %d\n", rn);
 
285
                return;
 
286
            }
 
287
 
239
288
            hit = mmu_translate(&env->mmu, &lu,
240
289
                                v & TLB_EPN_MASK, 0, cpu_mmu_index(env));
241
290
            if (hit) {
252
301
 
253
302
void mmu_init(struct microblaze_mmu *mmu)
254
303
{
255
 
    memset(mmu, 0, sizeof *mmu);
 
304
    int i;
 
305
    for (i = 0; i < ARRAY_SIZE(mmu->regs); i++) {
 
306
        mmu->regs[i] = 0;
 
307
    }
256
308
}