home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD1.iso / Emulatoren / UAE061.LZH / uae-0.6.1 / autoconf.c next >
Encoding:
C/C++ Source or Header  |  1996-08-28  |  4.0 KB  |  219 lines
  1.  /* 
  2.   * UAE - The Un*x Amiga Emulator
  3.   * 
  4.   * AutoConfig devices
  5.   *
  6.   * (c) 1995 Bernd Schmidt
  7.   * (c) 1996 Ed Hanway
  8.   */
  9.  
  10. #include "sysconfig.h"
  11. #include "sysdeps.h"
  12.  
  13. #include "config.h"
  14. #include "options.h"
  15. #include "memory.h"
  16. #include "custom.h"
  17. #include "newcpu.h"
  18. #include "disk.h"
  19. #include "xwin.h"
  20. #include "autoconf.h"
  21. #include "filesys.h"
  22. #include "hardfile.h"
  23. #include "gfxlib.h"
  24.  
  25. /* Commonly used autoconfig strings */
  26.  
  27. ULONG explibname;
  28.  
  29. /* ROM tag area memory access */
  30.  
  31. static UWORD rtarea[32768];
  32.  
  33. static ULONG rtarea_lget(CPTR) REGPARAM;
  34. static UWORD rtarea_wget(CPTR) REGPARAM;
  35. static UBYTE rtarea_bget(CPTR) REGPARAM;
  36. static void  rtarea_lput(CPTR, ULONG) REGPARAM;
  37. static void  rtarea_wput(CPTR, UWORD) REGPARAM;
  38. static void  rtarea_bput(CPTR, UBYTE) REGPARAM;
  39. static UWORD *rtarea_xlate(CPTR) REGPARAM;
  40.  
  41. addrbank rtarea_bank = {
  42.     rtarea_lget, rtarea_wget, rtarea_bget,
  43.     rtarea_lput, rtarea_wput, rtarea_bput,
  44.     rtarea_xlate, default_check
  45. };
  46.  
  47. UWORD *rtarea_xlate(CPTR addr)
  48. {
  49.     addr &= 0xFFFF;
  50.     return rtarea + (addr >> 1);
  51. }
  52.  
  53. ULONG rtarea_lget(CPTR addr)
  54. {
  55.     addr &= 0xFFFF;
  56.     return (ULONG)(rtarea_wget(addr) << 16) + rtarea_wget(addr+2);
  57. }
  58.  
  59. UWORD rtarea_wget(CPTR addr)
  60. {
  61.     addr &= 0xFFFF;
  62.     return rtarea[addr >> 1];
  63. }
  64.  
  65. UBYTE rtarea_bget(CPTR addr)
  66. {
  67.     UWORD data;
  68.     addr &= 0xFFFF;
  69.     data = rtarea[addr >> 1];
  70.     return addr & 1 ? data : data >> 8;
  71. }
  72.  
  73. void rtarea_lput(CPTR addr, ULONG value) { }
  74. void rtarea_bput(CPTR addr, UBYTE value) { }
  75.  
  76. /* Don't start at 0 -- can get bogus writes there. */
  77. static ULONG trap_base_addr = 0x00F00180; 
  78.  
  79. TrapFunction traps[256];
  80. static int max_trap = 0;
  81.  
  82. void rtarea_wput(CPTR addr, UWORD value) 
  83. {
  84.     /* Save all registers */
  85.     struct regstruct backup_regs = regs;
  86.     ULONG retval = 0;
  87.  
  88.     ULONG func = ((addr  - trap_base_addr) & 0xFFFF) >> 1;
  89.     if(func < max_trap) {
  90.     retval = (*traps[func])();
  91.     } else {
  92.     fprintf(stderr, "illegal emulator trap\n");
  93.     }
  94.     regs = backup_regs;
  95.     regs.d[0] = retval;
  96. }
  97.  
  98. /* some quick & dirty code to fill in the rt area and save me a lot of
  99.  * scratch paper
  100.  */
  101.  
  102. static int rt_addr = 0;
  103. static int rt_straddr = 0xF000/2 - 1;
  104.  
  105. ULONG
  106. addr(int ptr)
  107. {
  108.     return ((ULONG)ptr << 1) + 0x00F00000;
  109. }
  110.  
  111. void
  112. dw(UWORD data)
  113. {
  114.     rtarea[rt_addr++] = data;
  115. }
  116.  
  117. void
  118. dl(ULONG data)
  119. {
  120.     rtarea[rt_addr++] = data >> 16;
  121.     rtarea[rt_addr++] = data;
  122. }
  123.  
  124. /* store strings starting at the end of the rt area and working
  125.  * backward.  store pointer at current address
  126.  */
  127.  
  128. ULONG
  129. ds(char *str)
  130. {
  131.     UWORD data;
  132.     char c;
  133.     int start;
  134.  
  135.     int len = (strlen(str) + 1) >> 1;
  136.     rt_straddr -= len;
  137.     start = rt_straddr;
  138.     
  139.     do {
  140.     data = c = *str++;
  141.     if (c) {
  142.         data <<= 8;
  143.         c = *str++;
  144.         data |= c;
  145.     }
  146.     rtarea[start++] = data;
  147.     } while (c);
  148.     
  149.     return addr(rt_straddr--);
  150. }
  151.  
  152. void
  153. calltrap(ULONG n)
  154. {
  155.     dw(0x33C0);    /* MOVE.W D0,abs32 */
  156.     dl(n*2 + trap_base_addr);
  157. }
  158.  
  159. void
  160. org(ULONG a)
  161. {
  162.     rt_addr = (a - 0x00F00000) >> 1;
  163. }
  164.  
  165. ULONG
  166. here(void)
  167. {
  168.     return addr(rt_addr);
  169. }
  170.  
  171. int
  172. deftrap(TrapFunction func)
  173. {
  174.     int num = max_trap++;
  175.     traps[num] = func;
  176.     return num;
  177. }
  178.  
  179. void
  180. align(int b)
  181. {
  182.     rt_addr = (rt_addr + (b-1)) & ~(b-1);
  183. }
  184.  
  185. /* Ed was right when he wrote that he doesn't trust calling code that
  186.  * Wait()s. This can fail horribly if the Amiga OS switches the task
  187.  * and that task traps again into an emulation routine. I'm not even
  188.  * sure whether we can call AllocMem() safely from here.
  189.  * FIXME: Find a clever solution to prevent these problems.
  190.  */
  191.  
  192. ULONG CallLib(CPTR base, WORD offset)
  193. {
  194.     /* Make tracing through this possible */
  195.     int oldspc = specialflags & SPCFLAG_BRK;
  196.     
  197.     CPTR olda6 = regs.a[6];
  198.     CPTR oldpc = m68k_getpc();
  199.     regs.a[6] = base;
  200.     regs.a[7] -= 4;
  201.     put_long (regs.a[7], 0xF0FFFE);
  202.     m68k_setpc (base + offset);
  203.     MC68000_skip (0xF0FFFE);
  204.     regs.a[6] = olda6;
  205.     m68k_setpc (oldpc);
  206.     specialflags |= oldspc;
  207.     return regs.d[0];
  208. }
  209.  
  210. void
  211. rtarea_init()
  212. {
  213.     explibname = ds("expansion.library");
  214.  
  215.     hardfile_install();
  216.     filesys_install();
  217.     gfxlib_install();
  218. }
  219.