home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 28 / amigaformatcd28.iso / -seriously_amiga- / misc / quickrom / quickrom.asm < prev    next >
Encoding:
Assembly Source File  |  1998-05-09  |  8.8 KB  |  258 lines
  1. * QuickROM - uses 68060 or 68040 MMU to remap Kickstart in FAST RAM
  2. * First written by Simon N Goodwin October 10th 1996, PUBLIC DOMAIN
  3. * Updated January 1997: automatically senses the Kickstart ROM size
  4. * and can be re-assembled for page sizes other than the default 4K.
  5. * First upload to Aminet, version 36.07, May 1998.
  6. *
  7. * This program works like KSREMAP and ROM2FAST, but it's compatible
  8. * with more systems, smaller than the former, and more capable than
  9. * the latter. Written and tested on a Mark 2 Cyberstorm 68060, more
  10. * than doubling the speed of access to Kickstart code. Also tested
  11. * on GVP G-FORCE 68060, Commodore's 3640 (helps a bit, but hampered
  12. * by its very slow 'fast' RAM interface) Warp Engine 68040/33 and a
  13. * Mark 1 Cyberstorm, which was even faster than the Mark 2 - though
  14. * it's a shame that Phase Five's Mark 1 SCSI add-on never worked as
  15. * it should have done. Nic Wilson's KickSpeed tester (from Set040)
  16. * reads ROM 2.4 times faster on my Mark 1 Cyberstorm hardware after
  17. * running QuickROM. 
  18. *
  19. * The advantages of QuickROM over the proprietary versions are:
  20. *
  21. * Allocates RAM from the top of memory to minimise fragmentation.
  22. *
  23. * Allows de-allocation as well as allocation, freeing 516K memory.
  24. *
  25. * More diagnostics for cases when it won't work (Exec result codes).
  26. *
  27. * Freely distributable including the Devpac Source code (this is it)
  28. * with copious comments explaining its strengths and weaknesses.
  29. *
  30. * Does not use undocumented 68060.library hooks, so it should work
  31. * fine on any other 68060 or 68040 system with an MMU, unlike some.
  32. *
  33. * Works with 1 Mb ROMs as well as Commodore 512K ones, and uses the
  34. * documented method to find the ROM size, so it should suit other
  35. * sizes too, as long as they're in the first 32 Mb of address space
  36. * (likely as the MAGIC_ROM_SIZE needs to be at address 16 Mb - 20).
  37. *
  38. * Limitations are:
  39. *
  40. * No messages. Check the return code to find out EXACTLY what happened.
  41. *
  42. * Requires an MMU, and won't work with old 68030, 68451 or 68851 ones.
  43. * There are already plenty of Kickstart re-mappers for those systems.
  44. *
  45. * May get confused in the MMU table setup or ROM location is radically
  46. * changed in some future Amiga. This program is inevitably architecture-
  47. * and processor-specific, although I've tried to make it fairly flexible.
  48. *
  49. * History and Predictions:
  50. *
  51. * Code was originally designed to shadow the 512K ROM at $00F80000; this
  52. * suited all Commodore Amiga ROMs from Kickstart 1.4 to 3.1, but new 1Mb
  53. * versions are expected one day, so the updated code includes changes to
  54. * look for them, from address $00F00000 up. It still expects ROM sizes to
  55. * be a multiple of 256K, where that's the size of a pointer-level table
  56. * entry, as it works in units of one complete 256K mapping table.
  57. *
  58. *   The Third Edition of the Amiga Hardware Reference Manual documents
  59. *   on page 224 a technique for finding the size and hence the start
  60. *   address of the ROM, making reference to these 'magic' constants:
  61. *
  62. MAGIC_ROMEND equ    $01000000        End of C= Kickstarts
  63. MAGIC_SIZEOFFSET equ    -20        Offset to ROM size.L
  64. *
  65. * When testing modifications, check the MMU start pointer offset and
  66. * number of pointer-level entries modified in TableFix, as well as the
  67. * ROM address and size. If it's past $01FFFFFF you'll need to use a
  68. * later root pointer to find the required first pointer level entry.
  69. *
  70. * The re-mapping area includes one extra MMU page of RAM to ensure page
  71. * alignment. It uses eight bytes after the ROM image (guaranteed to be
  72. * available by heap alignment rules) to point back to the start of the
  73. * allocation and watermark the area "MMU!". All current systems use 4K
  74. * pages but some effort has been made to make the code adjust to other
  75. * page sizes, if re-assembled with the following constant adjusted:
  76. *
  77. PAGE_SIZE    equ    4096
  78. *
  79. * PLEASE NOTE: the code has not been tested with 8K pages, as they're not
  80. * used in any known Amiga; similarly it assumes 256K areas for each pointer
  81. * level table entry, as these are standard on current 68040 and 68060s. It
  82. * will probably require radical change for new or non-68040/68060 MMUs
  83. *
  84. ******************************************************************************
  85. *
  86. * This is the program itself. It uses 68020+ opcodes as well as the MMU,
  87. * so it starts by checking ExecBase to ensure that the processor is suitable.
  88. * 
  89. QuickROM    move.l      4.w,a6                    Find EXEC
  90.     btst      #3,$129(a6)         Test for a 68060 or 68040
  91.             beq.s    Too_Old
  92.  
  93.             lea.l    FindMMU,a5            
  94.            jsr        -30(a6)            EXEC Supervisor function
  95.             tst.w    d0        Is MMU enabled in TC? If so,
  96.             bpl.s    MMU_off        bit 15=1 (on 68040/060 only)
  97.  
  98.     if    PAGE_SIZE=4096
  99.     
  100.             add.w    d0,d0        Check we're using 4K pages: if
  101.             bpl.s    Pages_OK        so, TC bit 14 should be zero
  102.  
  103. Pages_8K    moveq    #24,d0        FAIL! MMU using 8K pages
  104.     rts
  105.  
  106.     endc
  107.     
  108. Pages_OK    move.l    a0,d0        Copy and test Root Pointer
  109.             bne.s    got_MMU        Zero is definitely not enough
  110.             
  111. no_MMU    moveq    #28,d0        FAIL! MMU not initialised
  112.     rts
  113.     
  114. MMU_off    moveq    #26,d0        FAIL! MMU not enabled
  115.     rts    
  116.     
  117. Too_Old    moveq    #30,d0        FAIL! 68060 or 68040 required
  118.     rts
  119.  
  120.     dc.b    '$VER: QuickROM v36.07 (3-May-1998) by Simon N Goodwin',0
  121.     even
  122.  
  123. Bad_Copy    moveq    #20,d0        FAIL! Remapped by someone else
  124.     rts        
  125.  
  126. * EXEC Supervisor routine to extract MMU configuration register details 
  127.  
  128. FindMMU    movec    urp,a0
  129.     movec    tc,d0
  130.     rte        
  131.  
  132. No_Room    moveq    #22,d0        FAIL! More FAST RAM needed
  133.      rts
  134.  
  135. ******************************************************************************
  136. *
  137. * If we get thus far we're basically onto a winner. We've got an 060 or 040,
  138. * 4K memory mapping is enabled. Code has been extended to allow undoing, and
  139. * the memory to be reclaimed, if it is re-invoked when already in use.
  140. *
  141. * Register usage:
  142. *
  143. * D0, D1, A0, A1 scratch and system
  144. * D4 Size of physical ROM
  145. * D7 MMU table address mask
  146. *
  147. * A4 Start of physical ROM
  148. * A5 End of physical ROM
  149. *
  150. got_MMU    move.l    (a0),d0        MMU pointer table for 1st 32 Mb
  151.     move.l    #$FFFFFE00,d7    Mask to clear lower 9 bits
  152.     and.l    d7,d0        Mask allows safe .W in offset
  153.     lea.l    MAGIC_ROMEND,a5    End of ROM
  154.     move.l    a5,a4        
  155.     move.l    MAGIC_SIZEOFFSET(a5),d4 Size of ROM
  156.     moveq    #16,d1        Shift to divide start*4 by 256K
  157.     sub.l    d4,a4        Start of ROM
  158.     move.l    a4,d5
  159.     
  160. * The pointers handle 256K each, so if the ROM is at $00F80000 as usual the
  161. * first associated long word pointer will be entry 62, counting from 0, in the
  162. * pointer-level table, since 62*256K = 15.5 Mb = $00F80000 (as any fule kno).
  163.  
  164.     lsr.l    d1,d5        Expect 62*4 for ROM at $F80000
  165.     add.w    d5,d0        Offset to first page pointer
  166.     move.l    d0,a2        Save first pointer table entry
  167.     move.l    (a2),d1        Find first page table entry
  168.     and.l    d7,d1        Mask out page usage flags
  169.     move.l    (d1.l),d1        Get page table entry
  170.     and.l    d7,d1        Physical address for this page
  171.     cmp.l    a4,d1        Is it pointing at ROM already?
  172.     beq.s    Create        If so, we can soon change that!
  173.  
  174. * It's already re-mapped, so try to un-map it
  175.  
  176.     add.l    d4,d1        Point past end of ROM
  177.     move.l    d1,a1
  178.     move.l    (a1)+,d6        Pick up past pointer
  179.     beq.s    Bad_Copy        Check it's non zero!
  180.     
  181.     moveq    #7,d1        Mask for lower three bits
  182.     and.l    d6,d1          which should all be zero
  183.     bne.s    Bad_Copy        Check alignment is plausible
  184.  
  185.     cmp.l    #'MMU!',(a1)    Check for our odd signature
  186.     bne.s    Bad_Copy
  187.  
  188.     move.l    a4,d2    
  189.     bsr.s    TableFix        Point MMU tables back to ROM
  190.  
  191.     move.l    d6,a1        Where to deallocate
  192.     move.l    #PAGE_SIZE,d0
  193.     add.l    d4,d0        ROM size and a bit
  194.  
  195.     jsr    -210(a6)        FreeMem
  196.  
  197.     moveq    #0,d0        No error
  198.     rts
  199.     
  200. * Allocate memory
  201.  
  202. Create    move.l    #$00040004,d1    MEMF_REVERSE and MEMF_FAST
  203.     move.l    d4,d0        Deduced ROM size
  204.     add.l    #PAGE_SIZE,d0    ...and a bit for overlap
  205.  
  206.     jsr    -198(a6)        AllocMem
  207.  
  208.     move.l    a4,a0        Computed ROM address
  209.     move.l    d0,d2        Copy returned address
  210.     beq.s    No_Room
  211.  
  212.     move.l    d0,a3        Save base of allocated RAM
  213.     
  214. * Ensure correct alignment on a page boundary
  215.  
  216.     move.l    d4,d0        ROM size
  217.     add.l    #PAGE_SIZE-1,d2
  218.     and.l    #$FFFFFFFF-PAGE_SIZE+1,d2
  219.     move.l    d2,a1        Where to copy TO
  220.     move.l    a3,(a1,d0.l)    Store real base at end of copy
  221.     move.l    #'MMU!',4(a1,d0.l)    Put watermark in last 4 bytes
  222.     
  223. * Copy ROM there
  224.  
  225.     jsr    -624(a6)        CopyMemQuick, A0 to A1 for D0
  226.  
  227. * This subroutine updates the MMU page table, whether mapping or unmapping
  228.         
  229. TableFix    jsr        -120(a6)            Disable, implies Forbid
  230.  
  231. * Fix the MMU tables by pointing them at the new copy
  232. * D2 points at the 'new' ROM image to be used, and D4 is its size.
  233. * A2 points to the MMU pointer table entry for the first 256K of ROM space
  234.  
  235.     move.l    d4,d1        Work out size in pointer pages
  236.     moveq    #18,d0        Shift factor to divide by 256K
  237.     lsr.l    d0,d1        Number of pointers to be tweaked
  238.     addq.l    #1,d2        Set Resident flag for pages
  239.     subq.l    #1,d1        Adjust for DBRA
  240.  
  241. Pointers    move.l    d7,d0
  242.     and.l    (a2)+,d0        Pointer to MMU block to remap
  243.     move.l    d0,a0        Masked to 512 boundary
  244.     moveq    #63,d0        Count 4K blocks
  245.  
  246. Pages    move.l    d2,(a0)+        Masked page pointer
  247.     add.l    #PAGE_SIZE,d2
  248.     dbra    d0,Pages
  249.  
  250.     dbra    d1,Pointers
  251.  
  252.     jsr        -126(a6)            Enable, implies Permit
  253.     
  254.     moveq    #0,d0        Admit nothing
  255.     rts
  256.     
  257.     end
  258.