home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / C / Applications / Portable Patmos / src / portable kernel / mac / probe.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-31  |  10.1 KB  |  537 lines  |  [TEXT/KAHL]
  1. #ifdef THINK_C
  2. #include <LoMem.h>
  3. #include <THINK.h>
  4. #define get_time() TimeLM
  5. #define get_ticks() Ticks
  6. #else
  7. #include <Types.h>
  8. #include <Errors.h>
  9. #include <Memory.h>
  10. #include <OSUtils.h>
  11. #include <SegLoad.h>
  12. #include <Quickdraw.h>
  13. #include <Files.h>
  14. #include <Menus.h>
  15. #include <Fonts.h>
  16. #include <Resources.h>
  17. #include <GestaltEqu.h>
  18. #include <Traps.h>
  19. #include <Aliases.h>
  20. #include <Packages.h>
  21. #include <Processes.h>
  22. #include <AppleEvents.h>
  23. #include <ToolUtils.h>
  24. #include <SysEqu.h>
  25. #define get_time() (*(long *)TimeLM)
  26. #define get_ticks() (*(long *)Ticks)
  27. enum {FALSE,TRUE};
  28. #endif
  29. #include <Dialogs.h>
  30. #include <GestaltEqu.h>
  31. #include <StandardFile.h>
  32. #include <Memory.h>
  33. #include "proc_mmu.h"
  34.  
  35. #define TrapMask 0x0800
  36.  
  37. static short NumToolboxTraps( void )
  38. {
  39.     if (GetToolTrapAddress(0xA86E) ==
  40.             GetToolTrapAddress(0xAA6E))
  41.         return(0x0200);
  42.     else
  43.         return(0x0400);
  44. }
  45.  
  46. static TrapType GetTrapType(short theTrap)
  47. {
  48.  
  49.     if ((theTrap & TrapMask) > 0)
  50.         return(ToolTrap);
  51.     else
  52.         return(OSTrap);
  53.  
  54. }
  55.  
  56. Boolean TrapAvailable(short theTrap)
  57. {
  58.  
  59.     TrapType    tType;
  60.  
  61.     tType = GetTrapType(theTrap);
  62.     if (tType == ToolTrap)
  63.         theTrap = theTrap & 0x07FF;
  64.     if (theTrap >= NumToolboxTraps())
  65.         theTrap = 0xA89F;
  66.  
  67.     return ((tType == ToolTrap?GetToolTrapAddress(theTrap):GetOSTrapAddress(theTrap))!=
  68.             GetToolTrapAddress(0xA89F));
  69. }
  70.  
  71. #ifdef PROTECTED
  72. long mmutype;
  73. int virtual = 0;
  74. #endif
  75.  
  76. int get_page_size(void)
  77.     {
  78.     long gestaltAnswer;
  79.     Gestalt(gestaltLogicalPageSize, &gestaltAnswer);
  80. #ifdef PROTECTED
  81.     if (virtual)
  82. #endif
  83.         {
  84.         return gestaltAnswer;
  85.         }
  86. #ifdef PROTECTED
  87.     switch(mmutype)
  88.         {
  89.         case  gestalt68030MMU:
  90.             return 1<<((get_68030_tc()>>20)&15);
  91.             break;
  92.         case  gestalt68040MMU:
  93.             return get_68040_tc()&16384?8192:4096;
  94.             break;
  95.         default:
  96.             return gestaltAnswer;
  97.         }
  98. #endif
  99.     }
  100.  
  101. void probe()
  102.     {
  103.     Str255 name,name2;
  104.     int major = 5,minor,cnt;
  105.     long gestaltAnswer,physram,logram;
  106.     if (TrapAvailable(0xA1AD))
  107.         {
  108.         Gestalt(gestaltSystemVersion, &gestaltAnswer);
  109.         major = gestaltAnswer>>8;
  110.         minor = gestaltAnswer&255;
  111.         }
  112.     if (major < 7)
  113.         {
  114.         ParamText((unsigned char *)"\p, Sorry, System 7 required",0,0,0);
  115.         Alert(129, 0);
  116.         ExitToShell();        
  117.         }
  118. #ifdef PROTECTED
  119.     Gestalt(gestaltMMUType, &mmutype);
  120.     if ((mmutype != gestalt68030MMU) && (mmutype != gestalt68040MMU))
  121. #if 1
  122.         mmutype = -1;
  123. #else
  124.         {
  125.         ParamText("\pSorry, Only the 68030/68040","\pMMUs are supported","\pin this version",0);
  126.         Alert(129, 0);
  127.         ExitToShell();        
  128.         }
  129. #endif
  130.     Gestalt(gestaltAddressingModeAttr, &gestaltAnswer);
  131.     if (~gestaltAnswer & ((1<<gestalt32BitAddressing)|(1<<gestalt32BitSysZone)|(1<<gestalt32BitCapable)))
  132.         {
  133.         ParamText("\pIdeally, you should","\pReboot in 32-bit mode",0,0);
  134.         Alert(129, 0);
  135. //        ExitToShell();        
  136.         }
  137. #endif
  138. #if 0
  139.     Gestalt(gestaltLogicalPageSize, &gestaltAnswer);
  140.     if (gestaltAnswer != 8192)
  141.         {
  142.         ParamText("\pSupport for page sizes","\pother than 8K is untested","\pcontinue at your own risk!",0);
  143.         Alert(129, 0);
  144.         }
  145. #else
  146.     Gestalt(gestaltMMUType, &gestaltAnswer);
  147.     switch(gestaltAnswer)
  148.         {
  149.         int vec[2];
  150.         case gestalt68030MMU:
  151.             get_68030_srp(vec);
  152.             put_68030_crp(vec);
  153.             break;
  154.         case  gestalt68040MMU:
  155.             get_68040_srp(vec);
  156.             put_68040_crp(vec);
  157.             break;
  158.         }
  159. #endif
  160.     Gestalt(gestaltLogicalRAMSize, &logram);
  161.     Gestalt(gestaltPhysicalRAMSize, &physram);
  162.     if (logram > physram)
  163.         {
  164.         ParamText("\pSorry, virtual memory","\pis not supported","\pin this version",0);
  165.         Alert(129, 0);
  166.         ExitToShell();        
  167.         }
  168. #if 0
  169.     Gestalt(gestaltMachineType, &gestaltAnswer);
  170.     GetIndString(name, kMachineNameStrID, gestaltAnswer);
  171.     cnt = 0;
  172.     do
  173.         {
  174.         GetIndString(name2, 128, ++cnt);
  175.         if (!memcmp(name, name2, *name)) gestaltAnswer = 0;
  176.         }
  177.     while (*name2 && gestaltAnswer);
  178.     if (gestaltAnswer)
  179.         {
  180.         ParamText("\pThis program is untested on",name,"\pdon't blame me","\pif it crashes");
  181.         Alert(129, 0);
  182.         }
  183. #endif
  184.     page_size = get_page_size();
  185. //    for (ccnt = 8; ccnt--; ) nxt[ccnt] = (CursHandle)GetCursor(128+ccnt);
  186. //    InstallVBL();
  187.     patch_traps();
  188.     old_ticks = get_ticks();
  189.     }
  190.  
  191. long trap_patch_0()
  192.     {
  193. #ifdef PROTECTED
  194.     switch(mmutype)
  195.         {
  196.         case  gestalt68030MMU:
  197.             return (long)trap_patch_68030_0;
  198.             break;
  199.         case  gestalt68040MMU:
  200.             return (long)trap_patch_68040_0;
  201.             break;
  202.         default:
  203. #else
  204.         {
  205. #endif
  206.             return (long)trap_patch_68020_0;
  207.         }    
  208.     }
  209.  
  210. long trap_patch_1()
  211.     {
  212. #ifdef PROTECTED
  213.     switch(mmutype)
  214.         {
  215.         case  gestalt68030MMU:
  216.             return (long)trap_patch_68030_1;
  217.             break;
  218.         case  gestalt68040MMU:
  219.             return (long)trap_patch_68040_1;
  220.             break;
  221.         default:
  222. #else
  223.         {
  224. #endif
  225.             return (long)trap_patch_68020_1;
  226.         }    
  227.     }
  228.  
  229. #ifdef PROTECTED
  230.  
  231. long get_user_root()
  232.     {
  233.     long vec[2];
  234.     switch(mmutype)
  235.         {
  236.         case  gestalt68030MMU:
  237.             get_68030_crp(vec);
  238.             return vec[1];
  239.             break;
  240.         case  gestalt68040MMU:
  241.             get_68040_crp(vec);
  242.             return vec[1];
  243.             break;
  244.         default:
  245.             return 0;
  246.         }        
  247.     }
  248.  
  249. long get_supervisor_root()
  250.     {
  251.     long vec[2];
  252.     switch(mmutype)
  253.         {
  254.         case  gestalt68030MMU:
  255.             get_68030_srp(vec);
  256.             return vec[1];
  257.             break;
  258.         case  gestalt68040MMU:
  259.             get_68040_srp(vec);
  260.             return vec[1];
  261.             break;
  262.         default:
  263.             return 0;
  264.         }        
  265.     }
  266.  
  267. void put_user_root(struct mmu *rootptr)
  268.     {
  269.     long addr = (long)rootptr;
  270.     long vec[2];
  271.     if (virtual) return;
  272. #if 0
  273.     if (!rootptr->sbreak)
  274.         {
  275.         addr = get_supervisor_root();
  276.         }
  277. #endif
  278.     switch(mmutype)
  279.         {
  280.         case  gestalt68030MMU:
  281.             get_68030_crp(vec);
  282.             vec[1] = addr;
  283.             put_68030_crp(vec);
  284.             break;
  285.         case  gestalt68040MMU:
  286.             vec[1] = addr;
  287.             put_68040_crp(vec);
  288.             break;
  289.         }        
  290.     }
  291.  
  292. void flush_caches()
  293.     {
  294.     switch(mmutype)
  295.         {
  296.         case  gestalt68030MMU:
  297.             flush_68030_caches();
  298.             break;
  299.         case  gestalt68040MMU:
  300.             flush_68040_caches();
  301.             break;
  302.         }    
  303.     }
  304.  
  305. void flush_mmu_caches()
  306.     {
  307.     switch(mmutype)
  308.         {
  309.         case  gestalt68030MMU:
  310.             flush_68030_mmu_caches();
  311.             break;
  312.         case  gestalt68040MMU:
  313.             flush_68040_mmu_caches();
  314.             break;
  315.         }    
  316.     }
  317.  
  318. void    *logical_to_physical(struct mmu *crp, unsigned long addr)
  319.     {
  320.     switch(mmutype)
  321.         {
  322.         case  gestalt68030MMU:
  323.             {
  324.             long    level2 = crp->u.u3.level2[(addr>>22)&1023]&~255;
  325.             if ((level2 >= (long)(crp->u.u3.level3)) 
  326.                 && (level2 < sizeof(crp->u.u3.level3)+(long)(crp->u.u3.level3)))
  327.                 {
  328.                 long    level3 = ((long *)level2)[(addr&((1<<22)-1))/page_size]&~255;
  329.                 if (level3)
  330.                     return (void *)(level3+(addr&(page_size-1)));
  331.                 }
  332.             }
  333.         break;
  334.         case  gestalt68040MMU:
  335.             {
  336.             long    level1 = crp->u.u4.level1[addr>>25]&~255;
  337.             if
  338.                 (
  339.                  (level1 >= (long)(crp->u.u4.level2)
  340.                  ) 
  341.                 && 
  342.                  (level1 < sizeof(crp->u.u4.level2)+(long)(crp->u.u4.level2)
  343.                  )
  344.                 )
  345.                 {
  346.                 long    level2 = ((long *)level1)[(addr>>18)&127]&~255;
  347.                 if ((level2 >= (long)(crp->u.u4.level3)) 
  348.                     && (level2 < sizeof(crp->u.u4.level3)+(long)(crp->u.u4.level3)))
  349.                     {
  350.                     long    level3 = ((long *)level2)[(addr&((1<<18)-1))/page_size]&~255;
  351.                     if (level3)
  352.                         return (void *)(level3+(addr&(page_size-1)));
  353.                     }
  354.                 }
  355.             return((void *)-1);
  356.             }
  357.         break;
  358.         }    
  359.     return((void *)-1);
  360.     }
  361.     
  362. int    upper_space(struct mmu *crp, long size)
  363.     {
  364.     long addr,level2;
  365.     switch(mmutype)
  366.         {
  367.         case  gestalt68030MMU:
  368.             {
  369.             for (level2 = 8; level2--; )
  370.                 {
  371.                 for (addr = (1<<22)/page_size; addr--; )
  372.                     {
  373.                     if (!crp->u.u3.level3[level2][addr])
  374.                         {
  375.                         long page = page_alloc();
  376.                         if (page) crp->u.u3.level3[level2][addr] = 0x1 + page;
  377.                         else return -1;
  378.                         }
  379.                     size -= page_size;
  380.                     if (size <= 0) return 0;
  381.                     }
  382.                 }
  383.             return -1;
  384.             }
  385.         case  gestalt68040MMU:
  386.             {
  387.             for (level2 = 128; level2--; )
  388.                 {
  389.                 for (addr = (1<<18)/page_size; addr--; )
  390.                     {
  391.                     if (!crp->u.u4.level3[level2][addr])
  392.                         {
  393.                         long page = page_alloc();
  394.                         if (page) crp->u.u4.level3[level2][addr] = 0x39 + page;
  395.                         else return -1;
  396.                         }
  397.                     size -= page_size;
  398.                     if (size <= 0) return 0;
  399.                     }
  400.                 }
  401.             return -1;            
  402.             }
  403.         }
  404.     }
  405.  
  406. int    lower_space(struct mmu *crp, long size)
  407.     {
  408.     long addr,level2;
  409.     switch(mmutype)
  410.         {
  411.         case  gestalt68030MMU:
  412.             {
  413.             for (level2 = 0; level2 < 8; level2++)
  414.                 {
  415.                 for (addr = 0; addr < (1<<22)/page_size; addr++)
  416.                     {
  417.                     if (!crp->u.u4.level3[level2][addr])
  418.                         {
  419.                         long page = page_alloc();
  420.                         if (page) crp->u.u3.level3[level2][addr] = 0x1 + page;
  421.                         else return -1;
  422.                         }
  423.                     size -= page_size;
  424.                     if (size <= 0) return 0;
  425.                     }
  426.                 }
  427.             return -1;
  428.             }
  429.         case  gestalt68040MMU:
  430.             {
  431.             for (level2 = 0; level2 < 128; level2++)
  432.                 {
  433.                 for (addr = 0; addr < (1<<18)/page_size; addr++)
  434.                     {
  435.                     if (!crp->u.u4.level3[level2][addr])
  436.                         {
  437.                         long page = page_alloc();
  438.                         if (page) crp->u.u4.level3[level2][addr] = 0x39 + page;
  439.                         else return -1;
  440.                         }
  441.                     size -= page_size;
  442.                     if (size <= 0) return 0;
  443.                     }
  444.                 }
  445.             return -1;
  446.             }
  447.         default:
  448.             return -1;
  449.         }
  450.     }
  451.  
  452. int    supervisor_space(struct mmu *crp, long lower, long upper)
  453.     {
  454.     long addr,level2;
  455.     for (level2 = 0; level2 < 128; level2++)
  456.         {
  457.         for (addr = 0; addr < (1<<18)/page_size; addr++)
  458.             {
  459.             long addr2 = (level2<<18) + addr*page_size;
  460.             if ((addr2 >= lower-page_size) && (addr2 <= upper))
  461.                 {
  462.                 crp->u.u4.level3[level2][addr] = 0x39 + addr2;
  463.                 }
  464.             if (addr2 > upper) return 0;
  465.             }
  466.         }
  467.     return -1;
  468.     }
  469.  
  470. void free_space(struct mmu *crp)
  471.     {
  472.     long addr,level2;
  473.     flush_caches();
  474.     switch(mmutype)
  475.         {
  476.         case  gestalt68030MMU:
  477.             {
  478.             for (level2 = 0; level2 < 8; level2++)
  479.                 {
  480.                 for (addr = 0; addr < (1<<22)/page_size; addr++)
  481.                     {
  482.                     page_free(crp->u.u3.level3[level2][addr]&~255);
  483.                     }
  484.                 }
  485.             }
  486.         break;
  487.         case  gestalt68040MMU:
  488.             {
  489.             for (level2 = 0; level2 < 128; level2++)
  490.                 {
  491.                 for (addr = 0; addr < (1<<18)/page_size; addr++)
  492.                     {
  493.                     page_free(crp->u.u4.level3[level2][addr]&~255);
  494.                     }
  495.                 }
  496.             }
  497.         break;
  498.         }
  499.     if (!crp->sbreak)    /* must be relocatable */
  500.         {
  501.         struct mem_chain *storage = crp->storage;
  502.         while (storage)
  503.             {
  504.             struct mem_chain *nxt = storage->nxt;
  505.             DisposPtr((Ptr)storage);
  506.             storage = nxt;
  507.             }
  508.         }
  509.     }
  510.  
  511. void wipeout(struct mmu *crp)
  512.     {
  513.     long addr;
  514.     switch(mmutype)
  515.         {
  516.         case  gestalt68030MMU:
  517.             {
  518.             for (addr = 0; addr < 8; addr++)
  519.                 {
  520.                 crp->u.u3.level2[addr] = 0xA + (long)&(crp->u.u3.level3[addr][0]);
  521.                 }
  522.             }
  523.         break;
  524.         case  gestalt68040MMU:
  525.             {
  526.             for (addr = 0; addr < 128; addr++)
  527.                 {
  528.                 crp->u.u4.level1[addr] = 0x18;
  529.                 crp->u.u4.level2[addr] = 0xA + (long)&(crp->u.u4.level3[addr][0]);
  530.                 }
  531.             crp->u.u4.level1[0] = 0xA + (long)(crp->u.u4.level2);
  532.             }
  533.         break;
  534.         }
  535.     }
  536.  
  537. #endif