?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kvm/i386: Set proper nested state format for SVM
[qemu/ar7.git] / target / m68k / helper.c
blob3ff57657958ca0b1c83f2d33be8dbbe9f43902a4
1 /*
2 * m68k op helpers
3 *
4 * Copyright (c) 2006-2007 CodeSourcery
5 * Written by Paul Brook
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.1 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, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "qemu/osdep.h"
22 #include "cpu.h"
23 #include "exec/exec-all.h"
24 #include "exec/gdbstub.h"
25 #include "exec/helper-proto.h"
26 #include "fpu/softfloat.h"
27 #include "qemu/qemu-print.h"
28
29 #define SIGNBIT (1u << 31)
30
31 /* Sort alphabetically, except for "any". */
32 static gint m68k_cpu_list_compare(gconstpointer a, gconstpointer b)
33 {
34 ObjectClass *class_a = (ObjectClass *)a;
35 ObjectClass *class_b = (ObjectClass *)b;
36 const char *name_a, *name_b;
37
38 name_a = object_class_get_name(class_a);
39 name_b = object_class_get_name(class_b);
40 if (strcmp(name_a, "any-" TYPE_M68K_CPU) == 0) {
41 return 1;
42 } else if (strcmp(name_b, "any-" TYPE_M68K_CPU) == 0) {
43 return -1;
44 } else {
45 return strcasecmp(name_a, name_b);
46 }
47 }
48
49 static void m68k_cpu_list_entry(gpointer data, gpointer user_data)
50 {
51 ObjectClass *c = data;
52 const char *typename;
53 char *name;
54
55 typename = object_class_get_name(c);
56 name = g_strndup(typename, strlen(typename) - strlen("-" TYPE_M68K_CPU));
57 qemu_printf("%s\n", name);
58 g_free(name);
59 }
60
61 void m68k_cpu_list(void)
62 {
63 GSList *list;
64
65 list = object_class_get_list(TYPE_M68K_CPU, false);
66 list = g_slist_sort(list, m68k_cpu_list_compare);
67 g_slist_foreach(list, m68k_cpu_list_entry, NULL);
68 g_slist_free(list);
69 }
70
71 static int cf_fpu_gdb_get_reg(CPUM68KState *env, GByteArray *mem_buf, int n)
72 {
73 if (n < 8) {
74 float_status s;
75 return gdb_get_float64(mem_buf,
76 floatx80_to_float64(env->fregs[n].d, &s));
77 }
78 switch (n) {
79 case 8: /* fpcontrol */
80 return gdb_get_reg32(mem_buf, env->fpcr);
81 case 9: /* fpstatus */
82 return gdb_get_reg32(mem_buf, env->fpsr);
83 case 10: /* fpiar, not implemented */
84 return gdb_get_reg32(mem_buf, 0);
85 }
86 return 0;
87 }
88
89 static int cf_fpu_gdb_set_reg(CPUM68KState *env, uint8_t *mem_buf, int n)
90 {
91 if (n < 8) {
92 float_status s;
93 env->fregs[n].d = float64_to_floatx80(ldfq_p(mem_buf), &s);
94 return 8;
95 }
96 switch (n) {
97 case 8: /* fpcontrol */
98 cpu_m68k_set_fpcr(env, ldl_p(mem_buf));
99 return 4;
100 case 9: /* fpstatus */
101 env->fpsr = ldl_p(mem_buf);
102 return 4;
103 case 10: /* fpiar, not implemented */
104 return 4;
105 }
106 return 0;
107 }
108
109 static int m68k_fpu_gdb_get_reg(CPUM68KState *env, GByteArray *mem_buf, int n)
110 {
111 if (n < 8) {
112 int len = gdb_get_reg16(mem_buf, env->fregs[n].l.upper);
113 len += gdb_get_reg16(mem_buf, 0);
114 len += gdb_get_reg64(mem_buf, env->fregs[n].l.lower);
115 return len;
116 }
117 switch (n) {
118 case 8: /* fpcontrol */
119 return gdb_get_reg32(mem_buf, env->fpcr);
120 case 9: /* fpstatus */
121 return gdb_get_reg32(mem_buf, env->fpsr);
122 case 10: /* fpiar, not implemented */
123 return gdb_get_reg32(mem_buf, 0);
124 }
125 return 0;
126 }
127
128 static int m68k_fpu_gdb_set_reg(CPUM68KState *env, uint8_t *mem_buf, int n)
129 {
130 if (n < 8) {
131 env->fregs[n].l.upper = lduw_be_p(mem_buf);
132 env->fregs[n].l.lower = ldq_be_p(mem_buf + 4);
133 return 12;
134 }
135 switch (n) {
136 case 8: /* fpcontrol */
137 cpu_m68k_set_fpcr(env, ldl_p(mem_buf));
138 return 4;
139 case 9: /* fpstatus */
140 env->fpsr = ldl_p(mem_buf);
141 return 4;
142 case 10: /* fpiar, not implemented */
143 return 4;
144 }
145 return 0;
146 }
147
148 void m68k_cpu_init_gdb(M68kCPU *cpu)
149 {
150 CPUState *cs = CPU(cpu);
151 CPUM68KState *env = &cpu->env;
152
153 if (m68k_feature(env, M68K_FEATURE_CF_FPU)) {
154 gdb_register_coprocessor(cs, cf_fpu_gdb_get_reg, cf_fpu_gdb_set_reg,
155 11, "cf-fp.xml", 18);
156 } else if (m68k_feature(env, M68K_FEATURE_FPU)) {
157 gdb_register_coprocessor(cs, m68k_fpu_gdb_get_reg,
158 m68k_fpu_gdb_set_reg, 11, "m68k-fp.xml", 18);
159 }
160 /* TODO: Add [E]MAC registers. */
161 }
162
163 void HELPER(cf_movec_to)(CPUM68KState *env, uint32_t reg, uint32_t val)
164 {
165 switch (reg) {
166 case M68K_CR_CACR:
167 env->cacr = val;
168 m68k_switch_sp(env);
169 break;
170 case M68K_CR_ACR0:
171 case M68K_CR_ACR1:
172 case M68K_CR_ACR2:
173 case M68K_CR_ACR3:
174 /* TODO: Implement Access Control Registers. */
175 break;
176 case M68K_CR_VBR:
177 env->vbr = val;
178 break;
179 /* TODO: Implement control registers. */
180 default:
181 cpu_abort(env_cpu(env),
182 "Unimplemented control register write 0x%x = 0x%x\n",
183 reg, val);
184 }
185 }
186
187 void HELPER(m68k_movec_to)(CPUM68KState *env, uint32_t reg, uint32_t val)
188 {
189 switch (reg) {
190 /* MC680[1234]0 */
191 case M68K_CR_SFC:
192 env->sfc = val & 7;
193 return;
194 case M68K_CR_DFC:
195 env->dfc = val & 7;
196 return;
197 case M68K_CR_VBR:
198 env->vbr = val;
199 return;
200 /* MC680[2346]0 */
201 case M68K_CR_CACR:
202 if (m68k_feature(env, M68K_FEATURE_M68020)) {
203 env->cacr = val & 0x0000000f;
204 } else if (m68k_feature(env, M68K_FEATURE_M68030)) {
205 env->cacr = val & 0x00003f1f;
206 } else if (m68k_feature(env, M68K_FEATURE_M68040)) {
207 env->cacr = val & 0x80008000;
208 } else if (m68k_feature(env, M68K_FEATURE_M68060)) {
209 env->cacr = val & 0xf8e0e000;
210 }
211 m68k_switch_sp(env);
212 return;
213 /* MC680[34]0 */
214 case M68K_CR_TC:
215 env->mmu.tcr = val;
216 return;
217 case M68K_CR_MMUSR:
218 env->mmu.mmusr = val;
219 return;
220 case M68K_CR_SRP:
221 env->mmu.srp = val;
222 return;
223 case M68K_CR_URP:
224 env->mmu.urp = val;
225 return;
226 case M68K_CR_USP:
227 env->sp[M68K_USP] = val;
228 return;
229 case M68K_CR_MSP:
230 env->sp[M68K_SSP] = val;
231 return;
232 case M68K_CR_ISP:
233 env->sp[M68K_ISP] = val;
234 return;
235 /* MC68040/MC68LC040 */
236 case M68K_CR_ITT0:
237 env->mmu.ttr[M68K_ITTR0] = val;
238 return;
239 case M68K_CR_ITT1:
240 env->mmu.ttr[M68K_ITTR1] = val;
241 return;
242 case M68K_CR_DTT0:
243 env->mmu.ttr[M68K_DTTR0] = val;
244 return;
245 case M68K_CR_DTT1:
246 env->mmu.ttr[M68K_DTTR1] = val;
247 return;
248 }
249 cpu_abort(env_cpu(env),
250 "Unimplemented control register write 0x%x = 0x%x\n",
251 reg, val);
252 }
253
254 uint32_t HELPER(m68k_movec_from)(CPUM68KState *env, uint32_t reg)
255 {
256 switch (reg) {
257 /* MC680[1234]0 */
258 case M68K_CR_SFC:
259 return env->sfc;
260 case M68K_CR_DFC:
261 return env->dfc;
262 case M68K_CR_VBR:
263 return env->vbr;
264 /* MC680[234]0 */
265 case M68K_CR_CACR:
266 return env->cacr;
267 /* MC680[34]0 */
268 case M68K_CR_TC:
269 return env->mmu.tcr;
270 case M68K_CR_MMUSR:
271 return env->mmu.mmusr;
272 case M68K_CR_SRP:
273 return env->mmu.srp;
274 case M68K_CR_USP:
275 return env->sp[M68K_USP];
276 case M68K_CR_MSP:
277 return env->sp[M68K_SSP];
278 case M68K_CR_ISP:
279 return env->sp[M68K_ISP];
280 /* MC68040/MC68LC040 */
281 case M68K_CR_URP:
282 return env->mmu.urp;
283 case M68K_CR_ITT0:
284 return env->mmu.ttr[M68K_ITTR0];
285 case M68K_CR_ITT1:
286 return env->mmu.ttr[M68K_ITTR1];
287 case M68K_CR_DTT0:
288 return env->mmu.ttr[M68K_DTTR0];
289 case M68K_CR_DTT1:
290 return env->mmu.ttr[M68K_DTTR1];
291 }
292 cpu_abort(env_cpu(env), "Unimplemented control register read 0x%x\n",
293 reg);
294 }
295
296 void HELPER(set_macsr)(CPUM68KState *env, uint32_t val)
297 {
298 uint32_t acc;
299 int8_t exthigh;
300 uint8_t extlow;
301 uint64_t regval;
302 int i;
303 if ((env->macsr ^ val) & (MACSR_FI | MACSR_SU)) {
304 for (i = 0; i < 4; i++) {
305 regval = env->macc[i];
306 exthigh = regval >> 40;
307 if (env->macsr & MACSR_FI) {
308 acc = regval >> 8;
309 extlow = regval;
310 } else {
311 acc = regval;
312 extlow = regval >> 32;
313 }
314 if (env->macsr & MACSR_FI) {
315 regval = (((uint64_t)acc) << 8) | extlow;
316 regval |= ((int64_t)exthigh) << 40;
317 } else if (env->macsr & MACSR_SU) {
318 regval = acc | (((int64_t)extlow) << 32);
319 regval |= ((int64_t)exthigh) << 40;
320 } else {
321 regval = acc | (((uint64_t)extlow) << 32);
322 regval |= ((uint64_t)(uint8_t)exthigh) << 40;
323 }
324 env->macc[i] = regval;
325 }
326 }
327 env->macsr = val;
328 }
329
330 void m68k_switch_sp(CPUM68KState *env)
331 {
332 int new_sp;
333
334 env->sp[env->current_sp] = env->aregs[7];
335 if (m68k_feature(env, M68K_FEATURE_M68000)) {
336 if (env->sr & SR_S) {
337 if (env->sr & SR_M) {
338 new_sp = M68K_SSP;
339 } else {
340 new_sp = M68K_ISP;
341 }
342 } else {
343 new_sp = M68K_USP;
344 }
345 } else {
346 new_sp = (env->sr & SR_S && env->cacr & M68K_CACR_EUSP)
347 ? M68K_SSP : M68K_USP;
348 }
349 env->aregs[7] = env->sp[new_sp];
350 env->current_sp = new_sp;
351 }
352
353 #if !defined(CONFIG_USER_ONLY)
354 /* MMU: 68040 only */
355
356 static void print_address_zone(uint32_t logical, uint32_t physical,
357 uint32_t size, int attr)
358 {
359 qemu_printf("%08x - %08x -> %08x - %08x %c ",
360 logical, logical + size - 1,
361 physical, physical + size - 1,
362 attr & 4 ? 'W' : '-');
363 size >>= 10;
364 if (size < 1024) {
365 qemu_printf("(%d KiB)\n", size);
366 } else {
367 size >>= 10;
368 if (size < 1024) {
369 qemu_printf("(%d MiB)\n", size);
370 } else {
371 size >>= 10;
372 qemu_printf("(%d GiB)\n", size);
373 }
374 }
375 }
376
377 static void dump_address_map(CPUM68KState *env, uint32_t root_pointer)
378 {
379 int i, j, k;
380 int tic_size, tic_shift;
381 uint32_t tib_mask;
382 uint32_t tia, tib, tic;
383 uint32_t logical = 0xffffffff, physical = 0xffffffff;
384 uint32_t first_logical = 0xffffffff, first_physical = 0xffffffff;
385 uint32_t last_logical, last_physical;
386 int32_t size;
387 int last_attr = -1, attr = -1;
388 CPUState *cs = env_cpu(env);
389 MemTxResult txres;
390
391 if (env->mmu.tcr & M68K_TCR_PAGE_8K) {
392 /* 8k page */
393 tic_size = 32;
394 tic_shift = 13;
395 tib_mask = M68K_8K_PAGE_MASK;
396 } else {
397 /* 4k page */
398 tic_size = 64;
399 tic_shift = 12;
400 tib_mask = M68K_4K_PAGE_MASK;
401 }
402 for (i = 0; i < M68K_ROOT_POINTER_ENTRIES; i++) {
403 tia = address_space_ldl(cs->as, M68K_POINTER_BASE(root_pointer) + i * 4,
404 MEMTXATTRS_UNSPECIFIED, &txres);
405 if (txres != MEMTX_OK || !M68K_UDT_VALID(tia)) {
406 continue;
407 }
408 for (j = 0; j < M68K_ROOT_POINTER_ENTRIES; j++) {
409 tib = address_space_ldl(cs->as, M68K_POINTER_BASE(tia) + j * 4,
410 MEMTXATTRS_UNSPECIFIED, &txres);
411 if (txres != MEMTX_OK || !M68K_UDT_VALID(tib)) {
412 continue;
413 }
414 for (k = 0; k < tic_size; k++) {
415 tic = address_space_ldl(cs->as, (tib & tib_mask) + k * 4,
416 MEMTXATTRS_UNSPECIFIED, &txres);
417 if (txres != MEMTX_OK || !M68K_PDT_VALID(tic)) {
418 continue;
419 }
420 if (M68K_PDT_INDIRECT(tic)) {
421 tic = address_space_ldl(cs->as, M68K_INDIRECT_POINTER(tic),
422 MEMTXATTRS_UNSPECIFIED, &txres);
423 if (txres != MEMTX_OK) {
424 continue;
425 }
426 }
427
428 last_logical = logical;
429 logical = (i << M68K_TTS_ROOT_SHIFT) |
430 (j << M68K_TTS_POINTER_SHIFT) |
431 (k << tic_shift);
432
433 last_physical = physical;
434 physical = tic & ~((1 << tic_shift) - 1);
435
436 last_attr = attr;
437 attr = tic & ((1 << tic_shift) - 1);
438
439 if ((logical != (last_logical + (1 << tic_shift))) ||
440 (physical != (last_physical + (1 << tic_shift))) ||
441 (attr & 4) != (last_attr & 4)) {
442
443 if (first_logical != 0xffffffff) {
444 size = last_logical + (1 << tic_shift) -
445 first_logical;
446 print_address_zone(first_logical,
447 first_physical, size, last_attr);
448 }
449 first_logical = logical;
450 first_physical = physical;
451 }
452 }
453 }
454 }
455 if (first_logical != logical || (attr & 4) != (last_attr & 4)) {
456 size = logical + (1 << tic_shift) - first_logical;
457 print_address_zone(first_logical, first_physical, size, last_attr);
458 }
459 }
460
461 #define DUMP_CACHEFLAGS(a) \
462 switch (a & M68K_DESC_CACHEMODE) { \
463 case M68K_DESC_CM_WRTHRU: /* cachable, write-through */ \
464 qemu_printf("T"); \
465 break; \
466 case M68K_DESC_CM_COPYBK: /* cachable, copyback */ \
467 qemu_printf("C"); \
468 break; \
469 case M68K_DESC_CM_SERIAL: /* noncachable, serialized */ \
470 qemu_printf("S"); \
471 break; \
472 case M68K_DESC_CM_NCACHE: /* noncachable */ \
473 qemu_printf("N"); \
474 break; \
475 }
476
477 static void dump_ttr(uint32_t ttr)
478 {
479 if ((ttr & M68K_TTR_ENABLED) == 0) {
480 qemu_printf("disabled\n");
481 return;
482 }
483 qemu_printf("Base: 0x%08x Mask: 0x%08x Control: ",
484 ttr & M68K_TTR_ADDR_BASE,
485 (ttr & M68K_TTR_ADDR_MASK) << M68K_TTR_ADDR_MASK_SHIFT);
486 switch (ttr & M68K_TTR_SFIELD) {
487 case M68K_TTR_SFIELD_USER:
488 qemu_printf("U");
489 break;
490 case M68K_TTR_SFIELD_SUPER:
491 qemu_printf("S");
492 break;
493 default:
494 qemu_printf("*");
495 break;
496 }
497 DUMP_CACHEFLAGS(ttr);
498 if (ttr & M68K_DESC_WRITEPROT) {
499 qemu_printf("R");
500 } else {
501 qemu_printf("W");
502 }
503 qemu_printf(" U: %d\n", (ttr & M68K_DESC_USERATTR) >>
504 M68K_DESC_USERATTR_SHIFT);
505 }
506
507 void dump_mmu(CPUM68KState *env)
508 {
509 if ((env->mmu.tcr & M68K_TCR_ENABLED) == 0) {
510 qemu_printf("Translation disabled\n");
511 return;
512 }
513 qemu_printf("Page Size: ");
514 if (env->mmu.tcr & M68K_TCR_PAGE_8K) {
515 qemu_printf("8kB\n");
516 } else {
517 qemu_printf("4kB\n");
518 }
519
520 qemu_printf("MMUSR: ");
521 if (env->mmu.mmusr & M68K_MMU_B_040) {
522 qemu_printf("BUS ERROR\n");
523 } else {
524 qemu_printf("Phy=%08x Flags: ", env->mmu.mmusr & 0xfffff000);
525 /* flags found on the page descriptor */
526 if (env->mmu.mmusr & M68K_MMU_G_040) {
527 qemu_printf("G"); /* Global */
528 } else {
529 qemu_printf(".");
530 }
531 if (env->mmu.mmusr & M68K_MMU_S_040) {
532 qemu_printf("S"); /* Supervisor */
533 } else {
534 qemu_printf(".");
535 }
536 if (env->mmu.mmusr & M68K_MMU_M_040) {
537 qemu_printf("M"); /* Modified */
538 } else {
539 qemu_printf(".");
540 }
541 if (env->mmu.mmusr & M68K_MMU_WP_040) {
542 qemu_printf("W"); /* Write protect */
543 } else {
544 qemu_printf(".");
545 }
546 if (env->mmu.mmusr & M68K_MMU_T_040) {
547 qemu_printf("T"); /* Transparent */
548 } else {
549 qemu_printf(".");
550 }
551 if (env->mmu.mmusr & M68K_MMU_R_040) {
552 qemu_printf("R"); /* Resident */
553 } else {
554 qemu_printf(".");
555 }
556 qemu_printf(" Cache: ");
557 DUMP_CACHEFLAGS(env->mmu.mmusr);
558 qemu_printf(" U: %d\n", (env->mmu.mmusr >> 8) & 3);
559 qemu_printf("\n");
560 }
561
562 qemu_printf("ITTR0: ");
563 dump_ttr(env->mmu.ttr[M68K_ITTR0]);
564 qemu_printf("ITTR1: ");
565 dump_ttr(env->mmu.ttr[M68K_ITTR1]);
566 qemu_printf("DTTR0: ");
567 dump_ttr(env->mmu.ttr[M68K_DTTR0]);
568 qemu_printf("DTTR1: ");
569 dump_ttr(env->mmu.ttr[M68K_DTTR1]);
570
571 qemu_printf("SRP: 0x%08x\n", env->mmu.srp);
572 dump_address_map(env, env->mmu.srp);
573
574 qemu_printf("URP: 0x%08x\n", env->mmu.urp);
575 dump_address_map(env, env->mmu.urp);
576 }
577
578 static int check_TTR(uint32_t ttr, int *prot, target_ulong addr,
579 int access_type)
580 {
581 uint32_t base, mask;
582
583 /* check if transparent translation is enabled */
584 if ((ttr & M68K_TTR_ENABLED) == 0) {
585 return 0;
586 }
587
588 /* check mode access */
589 switch (ttr & M68K_TTR_SFIELD) {
590 case M68K_TTR_SFIELD_USER:
591 /* match only if user */
592 if ((access_type & ACCESS_SUPER) != 0) {
593 return 0;
594 }
595 break;
596 case M68K_TTR_SFIELD_SUPER:
597 /* match only if supervisor */
598 if ((access_type & ACCESS_SUPER) == 0) {
599 return 0;
600 }
601 break;
602 default:
603 /* all other values disable mode matching (FC2) */
604 break;
605 }
606
607 /* check address matching */
608
609 base = ttr & M68K_TTR_ADDR_BASE;
610 mask = (ttr & M68K_TTR_ADDR_MASK) ^ M68K_TTR_ADDR_MASK;
611 mask <<= M68K_TTR_ADDR_MASK_SHIFT;
612
613 if ((addr & mask) != (base & mask)) {
614 return 0;
615 }
616
617 *prot = PAGE_READ | PAGE_EXEC;
618 if ((ttr & M68K_DESC_WRITEPROT) == 0) {
619 *prot |= PAGE_WRITE;
620 }
621
622 return 1;
623 }
624
625 static int get_physical_address(CPUM68KState *env, hwaddr *physical,
626 int *prot, target_ulong address,
627 int access_type, target_ulong *page_size)
628 {
629 CPUState *cs = env_cpu(env);
630 uint32_t entry;
631 uint32_t next;
632 target_ulong page_mask;
633 bool debug = access_type & ACCESS_DEBUG;
634 int page_bits;
635 int i;
636 MemTxResult txres;
637
638 /* Transparent Translation (physical = logical) */
639 for (i = 0; i < M68K_MAX_TTR; i++) {
640 if (check_TTR(env->mmu.TTR(access_type, i),
641 prot, address, access_type)) {
642 if (access_type & ACCESS_PTEST) {
643 /* Transparent Translation Register bit */
644 env->mmu.mmusr = M68K_MMU_T_040 | M68K_MMU_R_040;
645 }
646 *physical = address;
647 *page_size = TARGET_PAGE_SIZE;
648 return 0;
649 }
650 }
651
652 /* Page Table Root Pointer */
653 *prot = PAGE_READ | PAGE_WRITE;
654 if (access_type & ACCESS_CODE) {
655 *prot |= PAGE_EXEC;
656 }
657 if (access_type & ACCESS_SUPER) {
658 next = env->mmu.srp;
659 } else {
660 next = env->mmu.urp;
661 }
662
663 /* Root Index */
664 entry = M68K_POINTER_BASE(next) | M68K_ROOT_INDEX(address);
665
666 next = address_space_ldl(cs->as, entry, MEMTXATTRS_UNSPECIFIED, &txres);
667 if (txres != MEMTX_OK) {
668 goto txfail;
669 }
670 if (!M68K_UDT_VALID(next)) {
671 return -1;
672 }
673 if (!(next & M68K_DESC_USED) && !debug) {
674 address_space_stl(cs->as, entry, next | M68K_DESC_USED,
675 MEMTXATTRS_UNSPECIFIED, &txres);
676 if (txres != MEMTX_OK) {
677 goto txfail;
678 }
679 }
680 if (next & M68K_DESC_WRITEPROT) {
681 if (access_type & ACCESS_PTEST) {
682 env->mmu.mmusr |= M68K_MMU_WP_040;
683 }
684 *prot &= ~PAGE_WRITE;
685 if (access_type & ACCESS_STORE) {
686 return -1;
687 }
688 }
689
690 /* Pointer Index */
691 entry = M68K_POINTER_BASE(next) | M68K_POINTER_INDEX(address);
692
693 next = address_space_ldl(cs->as, entry, MEMTXATTRS_UNSPECIFIED, &txres);
694 if (txres != MEMTX_OK) {
695 goto txfail;
696 }
697 if (!M68K_UDT_VALID(next)) {
698 return -1;
699 }
700 if (!(next & M68K_DESC_USED) && !debug) {
701 address_space_stl(cs->as, entry, next | M68K_DESC_USED,
702 MEMTXATTRS_UNSPECIFIED, &txres);
703 if (txres != MEMTX_OK) {
704 goto txfail;
705 }
706 }
707 if (next & M68K_DESC_WRITEPROT) {
708 if (access_type & ACCESS_PTEST) {
709 env->mmu.mmusr |= M68K_MMU_WP_040;
710 }
711 *prot &= ~PAGE_WRITE;
712 if (access_type & ACCESS_STORE) {
713 return -1;
714 }
715 }
716
717 /* Page Index */
718 if (env->mmu.tcr & M68K_TCR_PAGE_8K) {
719 entry = M68K_8K_PAGE_BASE(next) | M68K_8K_PAGE_INDEX(address);
720 } else {
721 entry = M68K_4K_PAGE_BASE(next) | M68K_4K_PAGE_INDEX(address);
722 }
723
724 next = address_space_ldl(cs->as, entry, MEMTXATTRS_UNSPECIFIED, &txres);
725 if (txres != MEMTX_OK) {
726 goto txfail;
727 }
728
729 if (!M68K_PDT_VALID(next)) {
730 return -1;
731 }
732 if (M68K_PDT_INDIRECT(next)) {
733 next = address_space_ldl(cs->as, M68K_INDIRECT_POINTER(next),
734 MEMTXATTRS_UNSPECIFIED, &txres);
735 if (txres != MEMTX_OK) {
736 goto txfail;
737 }
738 }
739 if (access_type & ACCESS_STORE) {
740 if (next & M68K_DESC_WRITEPROT) {
741 if (!(next & M68K_DESC_USED) && !debug) {
742 address_space_stl(cs->as, entry, next | M68K_DESC_USED,
743 MEMTXATTRS_UNSPECIFIED, &txres);
744 if (txres != MEMTX_OK) {
745 goto txfail;
746 }
747 }
748 } else if ((next & (M68K_DESC_MODIFIED | M68K_DESC_USED)) !=
749 (M68K_DESC_MODIFIED | M68K_DESC_USED) && !debug) {
750 address_space_stl(cs->as, entry,
751 next | (M68K_DESC_MODIFIED | M68K_DESC_USED),
752 MEMTXATTRS_UNSPECIFIED, &txres);
753 if (txres != MEMTX_OK) {
754 goto txfail;
755 }
756 }
757 } else {
758 if (!(next & M68K_DESC_USED) && !debug) {
759 address_space_stl(cs->as, entry, next | M68K_DESC_USED,
760 MEMTXATTRS_UNSPECIFIED, &txres);
761 if (txres != MEMTX_OK) {
762 goto txfail;
763 }
764 }
765 }
766
767 if (env->mmu.tcr & M68K_TCR_PAGE_8K) {
768 page_bits = 13;
769 } else {
770 page_bits = 12;
771 }
772 *page_size = 1 << page_bits;
773 page_mask = ~(*page_size - 1);
774 *physical = (next & page_mask) + (address & (*page_size - 1));
775
776 if (access_type & ACCESS_PTEST) {
777 env->mmu.mmusr |= next & M68K_MMU_SR_MASK_040;
778 env->mmu.mmusr |= *physical & 0xfffff000;
779 env->mmu.mmusr |= M68K_MMU_R_040;
780 }
781
782 if (next & M68K_DESC_WRITEPROT) {
783 *prot &= ~PAGE_WRITE;
784 if (access_type & ACCESS_STORE) {
785 return -1;
786 }
787 }
788 if (next & M68K_DESC_SUPERONLY) {
789 if ((access_type & ACCESS_SUPER) == 0) {
790 return -1;
791 }
792 }
793
794 return 0;
795
796 txfail:
797 /*
798 * A page table load/store failed. TODO: we should really raise a
799 * suitable guest fault here if this is not a debug access.
800 * For now just return that the translation failed.
801 */
802 return -1;
803 }
804
805 hwaddr m68k_cpu_get_phys_page_debug(CPUState *cs, vaddr addr)
806 {
807 M68kCPU *cpu = M68K_CPU(cs);
808 CPUM68KState *env = &cpu->env;
809 hwaddr phys_addr;
810 int prot;
811 int access_type;
812 target_ulong page_size;
813
814 if ((env->mmu.tcr & M68K_TCR_ENABLED) == 0) {
815 /* MMU disabled */
816 return addr;
817 }
818
819 access_type = ACCESS_DATA | ACCESS_DEBUG;
820 if (env->sr & SR_S) {
821 access_type |= ACCESS_SUPER;
822 }
823
824 if (get_physical_address(env, &phys_addr, &prot,
825 addr, access_type, &page_size) != 0) {
826 return -1;
827 }
828
829 return phys_addr;
830 }
831
832 /*
833 * Notify CPU of a pending interrupt. Prioritization and vectoring should
834 * be handled by the interrupt controller. Real hardware only requests
835 * the vector when the interrupt is acknowledged by the CPU. For
836 * simplicity we calculate it when the interrupt is signalled.
837 */
838 void m68k_set_irq_level(M68kCPU *cpu, int level, uint8_t vector)
839 {
840 CPUState *cs = CPU(cpu);
841 CPUM68KState *env = &cpu->env;
842
843 env->pending_level = level;
844 env->pending_vector = vector;
845 if (level) {
846 cpu_interrupt(cs, CPU_INTERRUPT_HARD);
847 } else {
848 cpu_reset_interrupt(cs, CPU_INTERRUPT_HARD);
849 }
850 }
851
852 #endif
853
854 bool m68k_cpu_tlb_fill(CPUState *cs, vaddr address, int size,
855 MMUAccessType qemu_access_type, int mmu_idx,
856 bool probe, uintptr_t retaddr)
857 {
858 M68kCPU *cpu = M68K_CPU(cs);
859 CPUM68KState *env = &cpu->env;
860
861 #ifndef CONFIG_USER_ONLY
862 hwaddr physical;
863 int prot;
864 int access_type;
865 int ret;
866 target_ulong page_size;
867
868 if ((env->mmu.tcr & M68K_TCR_ENABLED) == 0) {
869 /* MMU disabled */
870 tlb_set_page(cs, address & TARGET_PAGE_MASK,
871 address & TARGET_PAGE_MASK,
872 PAGE_READ | PAGE_WRITE | PAGE_EXEC,
873 mmu_idx, TARGET_PAGE_SIZE);
874 return true;
875 }
876
877 if (qemu_access_type == MMU_INST_FETCH) {
878 access_type = ACCESS_CODE;
879 } else {
880 access_type = ACCESS_DATA;
881 if (qemu_access_type == MMU_DATA_STORE) {
882 access_type |= ACCESS_STORE;
883 }
884 }
885 if (mmu_idx != MMU_USER_IDX) {
886 access_type |= ACCESS_SUPER;
887 }
888
889 ret = get_physical_address(&cpu->env, &physical, &prot,
890 address, access_type, &page_size);
891 if (likely(ret == 0)) {
892 tlb_set_page(cs, address & TARGET_PAGE_MASK,
893 physical & TARGET_PAGE_MASK, prot, mmu_idx, page_size);
894 return true;
895 }
896
897 if (probe) {
898 return false;
899 }
900
901 /* page fault */
902 env->mmu.ssw = M68K_ATC_040;
903 switch (size) {
904 case 1:
905 env->mmu.ssw |= M68K_BA_SIZE_BYTE;
906 break;
907 case 2:
908 env->mmu.ssw |= M68K_BA_SIZE_WORD;
909 break;
910 case 4:
911 env->mmu.ssw |= M68K_BA_SIZE_LONG;
912 break;
913 }
914 if (access_type & ACCESS_SUPER) {
915 env->mmu.ssw |= M68K_TM_040_SUPER;
916 }
917 if (access_type & ACCESS_CODE) {
918 env->mmu.ssw |= M68K_TM_040_CODE;
919 } else {
920 env->mmu.ssw |= M68K_TM_040_DATA;
921 }
922 if (!(access_type & ACCESS_STORE)) {
923 env->mmu.ssw |= M68K_RW_040;
924 }
925 #endif
926
927 cs->exception_index = EXCP_ACCESS;
928 env->mmu.ar = address;
929 cpu_loop_exit_restore(cs, retaddr);
930 }
931
932 uint32_t HELPER(bitrev)(uint32_t x)
933 {
934 x = ((x >> 1) & 0x55555555u) | ((x << 1) & 0xaaaaaaaau);
935 x = ((x >> 2) & 0x33333333u) | ((x << 2) & 0xccccccccu);
936 x = ((x >> 4) & 0x0f0f0f0fu) | ((x << 4) & 0xf0f0f0f0u);
937 return bswap32(x);
938 }
939
940 uint32_t HELPER(ff1)(uint32_t x)
941 {
942 int n;
943 for (n = 32; x; n--)
944 x >>= 1;
945 return n;
946 }
947
948 uint32_t HELPER(sats)(uint32_t val, uint32_t v)
949 {
950 /* The result has the opposite sign to the original value. */
951 if ((int32_t)v < 0) {
952 val = (((int32_t)val) >> 31) ^ SIGNBIT;
953 }
954 return val;
955 }
956
957 void cpu_m68k_set_sr(CPUM68KState *env, uint32_t sr)
958 {
959 env->sr = sr & 0xffe0;
960 cpu_m68k_set_ccr(env, sr);
961 m68k_switch_sp(env);
962 }
963
964 void HELPER(set_sr)(CPUM68KState *env, uint32_t val)
965 {
966 cpu_m68k_set_sr(env, val);
967 }
968
969 /* MAC unit. */
970 /*
971 * FIXME: The MAC unit implementation is a bit of a mess. Some helpers
972 * take values, others take register numbers and manipulate the contents
973 * in-place.
974 */
975 void HELPER(mac_move)(CPUM68KState *env, uint32_t dest, uint32_t src)
976 {
977 uint32_t mask;
978 env->macc[dest] = env->macc[src];
979 mask = MACSR_PAV0 << dest;
980 if (env->macsr & (MACSR_PAV0 << src))
981 env->macsr |= mask;
982 else
983 env->macsr &= ~mask;
984 }
985
986 uint64_t HELPER(macmuls)(CPUM68KState *env, uint32_t op1, uint32_t op2)
987 {
988 int64_t product;
989 int64_t res;
990
991 product = (uint64_t)op1 * op2;
992 res = (product << 24) >> 24;
993 if (res != product) {
994 env->macsr |= MACSR_V;
995 if (env->macsr & MACSR_OMC) {
996 /* Make sure the accumulate operation overflows. */
997 if (product < 0)
998 res = ~(1ll << 50);
999 else
1000 res = 1ll << 50;
1001 }
1002 }
1003 return res;
1004 }
1005
1006 uint64_t HELPER(macmulu)(CPUM68KState *env, uint32_t op1, uint32_t op2)
1007 {
1008 uint64_t product;
1009
1010 product = (uint64_t)op1 * op2;
1011 if (product & (0xffffffull << 40)) {
1012 env->macsr |= MACSR_V;
1013 if (env->macsr & MACSR_OMC) {
1014 /* Make sure the accumulate operation overflows. */
1015 product = 1ll << 50;
1016 } else {
1017 product &= ((1ull << 40) - 1);
1018 }
1019 }
1020 return product;
1021 }
1022
1023 uint64_t HELPER(macmulf)(CPUM68KState *env, uint32_t op1, uint32_t op2)
1024 {
1025 uint64_t product;
1026 uint32_t remainder;
1027
1028 product = (uint64_t)op1 * op2;
1029 if (env->macsr & MACSR_RT) {
1030 remainder = product & 0xffffff;
1031 product >>= 24;
1032 if (remainder > 0x800000)
1033 product++;
1034 else if (remainder == 0x800000)
1035 product += (product & 1);
1036 } else {
1037 product >>= 24;
1038 }
1039 return product;
1040 }
1041
1042 void HELPER(macsats)(CPUM68KState *env, uint32_t acc)
1043 {
1044 int64_t tmp;
1045 int64_t result;
1046 tmp = env->macc[acc];
1047 result = ((tmp << 16) >> 16);
1048 if (result != tmp) {
1049 env->macsr |= MACSR_V;
1050 }
1051 if (env->macsr & MACSR_V) {
1052 env->macsr |= MACSR_PAV0 << acc;
1053 if (env->macsr & MACSR_OMC) {
1054 /*
1055 * The result is saturated to 32 bits, despite overflow occurring
1056 * at 48 bits. Seems weird, but that's what the hardware docs
1057 * say.
1058 */
1059 result = (result >> 63) ^ 0x7fffffff;
1060 }
1061 }
1062 env->macc[acc] = result;
1063 }
1064
1065 void HELPER(macsatu)(CPUM68KState *env, uint32_t acc)
1066 {
1067 uint64_t val;
1068
1069 val = env->macc[acc];
1070 if (val & (0xffffull << 48)) {
1071 env->macsr |= MACSR_V;
1072 }
1073 if (env->macsr & MACSR_V) {
1074 env->macsr |= MACSR_PAV0 << acc;
1075 if (env->macsr & MACSR_OMC) {
1076 if (val > (1ull << 53))
1077 val = 0;
1078 else
1079 val = (1ull << 48) - 1;
1080 } else {
1081 val &= ((1ull << 48) - 1);
1082 }
1083 }
1084 env->macc[acc] = val;
1085 }
1086
1087 void HELPER(macsatf)(CPUM68KState *env, uint32_t acc)
1088 {
1089 int64_t sum;
1090 int64_t result;
1091
1092 sum = env->macc[acc];
1093 result = (sum << 16) >> 16;
1094 if (result != sum) {
1095 env->macsr |= MACSR_V;
1096 }
1097 if (env->macsr & MACSR_V) {
1098 env->macsr |= MACSR_PAV0 << acc;
1099 if (env->macsr & MACSR_OMC) {
1100 result = (result >> 63) ^ 0x7fffffffffffll;
1101 }
1102 }
1103 env->macc[acc] = result;
1104 }
1105
1106 void HELPER(mac_set_flags)(CPUM68KState *env, uint32_t acc)
1107 {
1108 uint64_t val;
1109 val = env->macc[acc];
1110 if (val == 0) {
1111 env->macsr |= MACSR_Z;
1112 } else if (val & (1ull << 47)) {
1113 env->macsr |= MACSR_N;
1114 }
1115 if (env->macsr & (MACSR_PAV0 << acc)) {
1116 env->macsr |= MACSR_V;
1117 }
1118 if (env->macsr & MACSR_FI) {
1119 val = ((int64_t)val) >> 40;
1120 if (val != 0 && val != -1)
1121 env->macsr |= MACSR_EV;
1122 } else if (env->macsr & MACSR_SU) {
1123 val = ((int64_t)val) >> 32;
1124 if (val != 0 && val != -1)
1125 env->macsr |= MACSR_EV;
1126 } else {
1127 if ((val >> 32) != 0)
1128 env->macsr |= MACSR_EV;
1129 }
1130 }
1131
1132 #define EXTSIGN(val, index) ( \
1133 (index == 0) ? (int8_t)(val) : ((index == 1) ? (int16_t)(val) : (val)) \
1134 )
1135
1136 #define COMPUTE_CCR(op, x, n, z, v, c) { \
1137 switch (op) { \
1138 case CC_OP_FLAGS: \
1139 /* Everything in place. */ \
1140 break; \
1141 case CC_OP_ADDB: \
1142 case CC_OP_ADDW: \
1143 case CC_OP_ADDL: \
1144 res = n; \
1145 src2 = v; \
1146 src1 = EXTSIGN(res - src2, op - CC_OP_ADDB); \
1147 c = x; \
1148 z = n; \
1149 v = (res ^ src1) & ~(src1 ^ src2); \
1150 break; \
1151 case CC_OP_SUBB: \
1152 case CC_OP_SUBW: \
1153 case CC_OP_SUBL: \
1154 res = n; \
1155 src2 = v; \
1156 src1 = EXTSIGN(res + src2, op - CC_OP_SUBB); \
1157 c = x; \
1158 z = n; \
1159 v = (res ^ src1) & (src1 ^ src2); \
1160 break; \
1161 case CC_OP_CMPB: \
1162 case CC_OP_CMPW: \
1163 case CC_OP_CMPL: \
1164 src1 = n; \
1165 src2 = v; \
1166 res = EXTSIGN(src1 - src2, op - CC_OP_CMPB); \
1167 n = res; \
1168 z = res; \
1169 c = src1 < src2; \
1170 v = (res ^ src1) & (src1 ^ src2); \
1171 break; \
1172 case CC_OP_LOGIC: \
1173 c = v = 0; \
1174 z = n; \
1175 break; \
1176 default: \
1177 cpu_abort(env_cpu(env), "Bad CC_OP %d", op); \
1178 } \
1179 } while (0)
1180
1181 uint32_t cpu_m68k_get_ccr(CPUM68KState *env)
1182 {
1183 uint32_t x, c, n, z, v;
1184 uint32_t res, src1, src2;
1185
1186 x = env->cc_x;
1187 n = env->cc_n;
1188 z = env->cc_z;
1189 v = env->cc_v;
1190 c = env->cc_c;
1191
1192 COMPUTE_CCR(env->cc_op, x, n, z, v, c);
1193
1194 n = n >> 31;
1195 z = (z == 0);
1196 v = v >> 31;
1197
1198 return x * CCF_X + n * CCF_N + z * CCF_Z + v * CCF_V + c * CCF_C;
1199 }
1200
1201 uint32_t HELPER(get_ccr)(CPUM68KState *env)
1202 {
1203 return cpu_m68k_get_ccr(env);
1204 }
1205
1206 void cpu_m68k_set_ccr(CPUM68KState *env, uint32_t ccr)
1207 {
1208 env->cc_x = (ccr & CCF_X ? 1 : 0);
1209 env->cc_n = (ccr & CCF_N ? -1 : 0);
1210 env->cc_z = (ccr & CCF_Z ? 0 : 1);
1211 env->cc_v = (ccr & CCF_V ? -1 : 0);
1212 env->cc_c = (ccr & CCF_C ? 1 : 0);
1213 env->cc_op = CC_OP_FLAGS;
1214 }
1215
1216 void HELPER(set_ccr)(CPUM68KState *env, uint32_t ccr)
1217 {
1218 cpu_m68k_set_ccr(env, ccr);
1219 }
1220
1221 void HELPER(flush_flags)(CPUM68KState *env, uint32_t cc_op)
1222 {
1223 uint32_t res, src1, src2;
1224
1225 COMPUTE_CCR(cc_op, env->cc_x, env->cc_n, env->cc_z, env->cc_v, env->cc_c);
1226 env->cc_op = CC_OP_FLAGS;
1227 }
1228
1229 uint32_t HELPER(get_macf)(CPUM68KState *env, uint64_t val)
1230 {
1231 int rem;
1232 uint32_t result;
1233
1234 if (env->macsr & MACSR_SU) {
1235 /* 16-bit rounding. */
1236 rem = val & 0xffffff;
1237 val = (val >> 24) & 0xffffu;
1238 if (rem > 0x800000)
1239 val++;
1240 else if (rem == 0x800000)
1241 val += (val & 1);
1242 } else if (env->macsr & MACSR_RT) {
1243 /* 32-bit rounding. */
1244 rem = val & 0xff;
1245 val >>= 8;
1246 if (rem > 0x80)
1247 val++;
1248 else if (rem == 0x80)
1249 val += (val & 1);
1250 } else {
1251 /* No rounding. */
1252 val >>= 8;
1253 }
1254 if (env->macsr & MACSR_OMC) {
1255 /* Saturate. */
1256 if (env->macsr & MACSR_SU) {
1257 if (val != (uint16_t) val) {
1258 result = ((val >> 63) ^ 0x7fff) & 0xffff;
1259 } else {
1260 result = val & 0xffff;
1261 }
1262 } else {
1263 if (val != (uint32_t)val) {
1264 result = ((uint32_t)(val >> 63) & 0x7fffffff);
1265 } else {
1266 result = (uint32_t)val;
1267 }
1268 }
1269 } else {
1270 /* No saturation. */
1271 if (env->macsr & MACSR_SU) {
1272 result = val & 0xffff;
1273 } else {
1274 result = (uint32_t)val;
1275 }
1276 }
1277 return result;
1278 }
1279
1280 uint32_t HELPER(get_macs)(uint64_t val)
1281 {
1282 if (val == (int32_t)val) {
1283 return (int32_t)val;
1284 } else {
1285 return (val >> 61) ^ ~SIGNBIT;
1286 }
1287 }
1288
1289 uint32_t HELPER(get_macu)(uint64_t val)
1290 {
1291 if ((val >> 32) == 0) {
1292 return (uint32_t)val;
1293 } else {
1294 return 0xffffffffu;
1295 }
1296 }
1297
1298 uint32_t HELPER(get_mac_extf)(CPUM68KState *env, uint32_t acc)
1299 {
1300 uint32_t val;
1301 val = env->macc[acc] & 0x00ff;
1302 val |= (env->macc[acc] >> 32) & 0xff00;
1303 val |= (env->macc[acc + 1] << 16) & 0x00ff0000;
1304 val |= (env->macc[acc + 1] >> 16) & 0xff000000;
1305 return val;
1306 }
1307
1308 uint32_t HELPER(get_mac_exti)(CPUM68KState *env, uint32_t acc)
1309 {
1310 uint32_t val;
1311 val = (env->macc[acc] >> 32) & 0xffff;
1312 val |= (env->macc[acc + 1] >> 16) & 0xffff0000;
1313 return val;
1314 }
1315
1316 void HELPER(set_mac_extf)(CPUM68KState *env, uint32_t val, uint32_t acc)
1317 {
1318 int64_t res;
1319 int32_t tmp;
1320 res = env->macc[acc] & 0xffffffff00ull;
1321 tmp = (int16_t)(val & 0xff00);
1322 res |= ((int64_t)tmp) << 32;
1323 res |= val & 0xff;
1324 env->macc[acc] = res;
1325 res = env->macc[acc + 1] & 0xffffffff00ull;
1326 tmp = (val & 0xff000000);
1327 res |= ((int64_t)tmp) << 16;
1328 res |= (val >> 16) & 0xff;
1329 env->macc[acc + 1] = res;
1330 }
1331
1332 void HELPER(set_mac_exts)(CPUM68KState *env, uint32_t val, uint32_t acc)
1333 {
1334 int64_t res;
1335 int32_t tmp;
1336 res = (uint32_t)env->macc[acc];
1337 tmp = (int16_t)val;
1338 res |= ((int64_t)tmp) << 32;
1339 env->macc[acc] = res;
1340 res = (uint32_t)env->macc[acc + 1];
1341 tmp = val & 0xffff0000;
1342 res |= (int64_t)tmp << 16;
1343 env->macc[acc + 1] = res;
1344 }
1345
1346 void HELPER(set_mac_extu)(CPUM68KState *env, uint32_t val, uint32_t acc)
1347 {
1348 uint64_t res;
1349 res = (uint32_t)env->macc[acc];
1350 res |= ((uint64_t)(val & 0xffff)) << 32;
1351 env->macc[acc] = res;
1352 res = (uint32_t)env->macc[acc + 1];
1353 res |= (uint64_t)(val & 0xffff0000) << 16;
1354 env->macc[acc + 1] = res;
1355 }
1356
1357 #if defined(CONFIG_SOFTMMU)
1358 void HELPER(ptest)(CPUM68KState *env, uint32_t addr, uint32_t is_read)
1359 {
1360 hwaddr physical;
1361 int access_type;
1362 int prot;
1363 int ret;
1364 target_ulong page_size;
1365
1366 access_type = ACCESS_PTEST;
1367 if (env->dfc & 4) {
1368 access_type |= ACCESS_SUPER;
1369 }
1370 if ((env->dfc & 3) == 2) {
1371 access_type |= ACCESS_CODE;
1372 }
1373 if (!is_read) {
1374 access_type |= ACCESS_STORE;
1375 }
1376
1377 env->mmu.mmusr = 0;
1378 env->mmu.ssw = 0;
1379 ret = get_physical_address(env, &physical, &prot, addr,
1380 access_type, &page_size);
1381 if (ret == 0) {
1382 tlb_set_page(env_cpu(env), addr & TARGET_PAGE_MASK,
1383 physical & TARGET_PAGE_MASK,
1384 prot, access_type & ACCESS_SUPER ?
1385 MMU_KERNEL_IDX : MMU_USER_IDX, page_size);
1386 }
1387 }
1388
1389 void HELPER(pflush)(CPUM68KState *env, uint32_t addr, uint32_t opmode)
1390 {
1391 CPUState *cs = env_cpu(env);
1392
1393 switch (opmode) {
1394 case 0: /* Flush page entry if not global */
1395 case 1: /* Flush page entry */
1396 tlb_flush_page(cs, addr);
1397 break;
1398 case 2: /* Flush all except global entries */
1399 tlb_flush(cs);
1400 break;
1401 case 3: /* Flush all entries */
1402 tlb_flush(cs);
1403 break;
1404 }
1405 }
1406
1407 void HELPER(reset)(CPUM68KState *env)
1408 {
1409 /* FIXME: reset all except CPU */
1410 }
1411 #endif
AR7 emulation for QEMU