mmugen 1.0 -凯发app

purpose of mmugen
-----------------


mmugen is a utility that allows users to generate mmu page table entries for arm cached cores.  the utility processes a text file (known as a rule file) which depicts the memory layout of a particular system and creates one or two binary files containing the necessary entries for the level 1 and level 2 page tables.  this utility can be used to generate v4,v5,v6, or v7 page table formats.  for more information about page table formats or mmu settings for your core, you can refer to your core's trm. 


conditions of use
-----------------


mmugen has been adapted by arm from an original design developed by peter maloy of codesprite, www.codesprite.com


no support will be provided by arm relating to the use of this product.




files included
--------------


this package includes an eclipse project which contains the following source files:
   
main.c            - parses rule file and sets entry bits
level1.c          - generates level 1 page table entries
level2.c          - generates level 2 page table entries
missing_region.c  - fills in missing entries from level 1 or level 2 tables
checking.c        - prints each page table entry for verification purposes
mmugen.h          - contains global structures and function prototypes


it also includes three example rule files:


simple.rule       - a simple rule file which generates v4/v5 format level 1 and level 2 tables  
v6.rule           - a more complex rule file which generates v6 format level 1 and level 2 tables
ct1176_eb.rule    - a flat-mapped rule file which depicts the memory map of an arm emulation baseboard fitted with an arm1176 core tile


using mmugen
------------ 


1) build mmugen.axf using the batch file (build.bat) or the eclipse project provided


2) start rvd, connect to the arm7tdmi rviss model, and load mmugen.axf


3) input the following information when prompted by the semihosting console:


 - the name of the rule file you want to process
 - the name of the level 1 page table binary file  
 - the name of the file which will contain a copy of the generated page table entries
 - whether you have a level 2 table (yes or no)
 - the name of the level 2 page table binary file
 - the base address of the level 2 page table(s)


please note that if the rule file is not in the same directory as mmugen.axf, you will need to use double backslashes ( \\ ) when specifying the rule file in the semihosting console (for example:  ..\\v6.rule).


4) include the generated binary file(s) into your application using incbin. for details about incbin, you can refer to the rvct assembler guide. 
 


general rule file text
----------------------


text                            definition
****                            **********


base_address                    address of the start of the page table entries
level                           which page table entries you are writing
vsix                            using v6 formatted page tables
vseven                          using v7 formatted page tables
default                         defines the default page table entry for missing memory regions in the level 1 and level 2 tables
virtual                         defines the virtual addresses
to                              used to specify the range of virtual addresses 
physical                        defines the physical address
postprocess                     defines postprocessing information              




valid rule file text for v6/v7 page tables
------------------------------------------


memory type             level   supported attributes for type           definition
***********             *****   *****************************           **********
fault                   1                                               creates a fault region for specified addresses          
                
pages                   1                                               specified addresses are divided into pages of 4kb or 64kb   
                                eec                                     memory supports error checking
                                domain_number                           sets domain number associated with memory region    
                                not_secure                              the memory region is accessed with non-secure rights (arm1176 & cortex-a8/a9 only)


section                 1                                               specified addresses are divided into 1mb sections
                                not_secure                              the memory region is accessed with non-secure rights (arm1176 & cortex-a8/a9 only)
                                not_global                              the translation is marked as processor-specific in the tlb
                                shared                                  memory shared with other components (processors/peripherals)
                                readwrite                               readwrite memory
                                readonly                                readonly memory
                                outer                                   setting outer cache attributes to non-cacheable/non-bufferable
                                outer_b                                 setting outer cache attributes to non-cacheable/bufferable
                                outer_c                                 setting outer cache attributes to cacheable/non-bufferable              
                                outer_cb                                setting outer cache attributes to cacheable/bufferable
                                normal
                                device
                                strongly_ordered
                                no_access               
                                svc_readwrite
                                no_usr_write
                                full_access
                                eec                                     memory supports error checking  
                                domain_number                           sets domain number associated with memory region
                                execute_never                           memory region is not-executable
                                cacheable                               cacheable memory
                                bufferable                              bufferable memory   
                
supersection            1                                               specified addresses are divided into 16mb sections
                                not_secure                              the memory region is accessed with non-secure rights (arm1176 & cortex-a8/a9 only)
                                not_global                              the translation is marked as processor-specific in the tlb
                                shared                                  memory shared with other components (processors/peripherals)
                                readwrite                               readwrite memory
                                readonly                                readonly memory
                                outer                                   setting outer cache attributes to non-cacheable/non-bufferable
                                outer_b                                 setting outer cache attributes to non-cacheable/bufferable
                                outer_c                                 setting outer cache attributes to cacheable/non-bufferable              
                                outer_cb                                setting outer cache attributes to cacheable/bufferable
                                normal
                                device
                                strongly_ordered
                                no_access
                                svc_readwrite
                                no_usr_write
                                full_access
                                eec                                     memory supports error checking
                                execute_never                           memory region is not-executable
                                cacheable                               cacheable memory
                                bufferable                              bufferable memory
            
largepages              2                                               specified addresses are divided into 16kb sections  
                                execute_never                           memory region is not-executable
                                outer                                   setting outer cache attributes to non-cacheable/non-bufferable
                                outer_b                                 setting outer cache attributes to non-cacheable/bufferable
                                outer_c                                 setting outer cache attributes to cacheable/non-bufferable              
                                outer_cb                                setting outer cache attributes to cacheable/bufferable
                                normal
                                device  
                                strongly_ordered
                                not_global                              the translation is marked as processor-specific in the tlb
                                shared                                  memory shared with other components (processors/peripherals)
                                readwrite                               readwrite memory
                                readonly                                readonly memory
                                no_access
                                svc_readwrite
                                no_usr_write
                                full_access
                                cacheable                               cacheable memory
                                bufferable                              bufferable memory
                
extended_smallpages     2                                               specified addresses are divided into 4kb sections
                                not_global                              the translation is marked as processor-specific in the tlb
                                shared                                  memory shared with other components (processors/peripherals)
                                readwrite                               readwrite memory
                                readonly                                readonly memory
                                outer                                   setting outer cache attributes to non-cacheable/non-bufferable
                                outer_b                                 setting outer cache attributes to non-cacheable/bufferable
                                outer_c                                 setting outer cache attributes to cacheable/non-bufferable              
                                outer_cb                                setting outer cache attributes to cacheable/bufferable
                                normal
                                device
                                strongly_ordered
                                no_access
                                svc_readwrite
                                no_usr_write
                                full_access
                                cacheable                               cacheable memory
                                bufferable                              bufferable memory
                                execute_never                           memory region is not-executable




valid rule file text for v4/v5 page tables
------------------------------------------
                


type                    level   supported attributes for type           definition
****                    *****   *****************************           **********
fault                   1                                               creates a fault region for specified addresses          
                
pages                   1                                               specified addresses divided into pages  
                                eec                                     memory supports error checking      
                                domain_number                           sets domain number associated with memory region    
                
section                 1                                               specified addresses are divided into 1mb sections
                                outer                                   setting outer cache attributes to non-cacheable/non-bufferable
                                outer_b                                 setting outer cache attributes to non-cacheable/bufferable
                                outer_c                                 setting outer cache attributes to cacheable/non-bufferable              
                                outer_cb                                setting outer cache attributes to cacheable/bufferable
                                normal
                                device
                                strongly_ordered
                                no_access
                                svc_readwrite
                                no_usr_write
                                full_access
                                eec                                     memory supports error checking  
                                domain_number                           sets domain number associated with memory region
                                cacheable                               cacheable memory
                                bufferable                              bufferable memory
                
supersection            1                                               specified addresses are divided into 16mb sections
                                outer                                   setting outer cache attributes to non-cacheable/non-bufferable
                                outer_b                                 setting outer cache attributes to non-cacheable/bufferable
                                outer_c                                 setting outer cache attributes to cacheable/non-bufferable              
                                outer_cb                                setting outer cache attributes to cacheable/bufferable
                                normal
                                device
                                strongly_ordered
                                no_access
                                svc_readwrite
                                no_usr_write
                                full_access
                                eec                                     memory supports error checking
                                cacheable                               cacheable memory
                                bufferable                              bufferable memory
            
largepages              2                                               specified addresses are divided into 64kb sections
                                outer                                   setting outer cache attributes to non-cacheable/non-bufferable
                                outer_b                                 setting outer cache attributes to non-cacheable/bufferable
                                outer_c                                 setting outer cache attributes to cacheable/non-bufferable              
                                outer_cb                                setting outer cache attributes to cacheable/bufferable  
                                normal
                                device  
                                strongly_ordered
                                no_access
                                svc_readwrite
                                no_usr_write
                                full_access
                                cacheable                               cacheable memory
                                bufferable                              bufferable memory


smallpages              2                                               specified addresses are divided into 4kb pages      
                                no_access
                                svc_readwrite
                                no_usr_write
                                full_access
                                cacheable                               cacheable memory
                                bufferable                              bufferable memory


                
extended_smallpages     2                                               specified addresses are divided into 4kb pages
                                outer                                   setting outer cache attributes to non-cacheable/non-bufferable
                                outer_b                                 setting outer cache attributes to non-cacheable/bufferable
                                outer_c                                 setting outer cache attributes to cacheable/non-bufferable              
                                outer_cb                                setting outer cache attributes to cacheable/bufferable
                                normal
                                device
                                strongly_ordered
                                no_access
                                svc_readwrite
                                no_usr_write
                                full_access
                                cacheable                               cacheable memory
                                bufferable                              bufferable memory




important information
---------------------


* do not use / in your comments


* each rule entry must end with the type (e.g. fault, page, section, supersection, largepages, smallpages, extended_smallpages)


* if an unsupported attribute is used for a type, it will be ignored


* if an attribute is not listed, its value is set to zero in the page table entry


* tiny page generation is not supported


* all access control bits (ap bits) in v4/v5 level 2 page tables will be set to a single value


* cacheable and bufferable attributes must be set before the memory type is specify in the rule entry (memory type = normal, device, strongly_ordered)


* the readonly and readwrite attribute must be set before the access permission attribute (e.g. no_access, svc_readwrite, no_usr_write, full_access)


* the first virtual address in your level 1 table must be zero


* to specify the virtual address range, you must use the following format in your rule file:


       virtual beginning_addr to ending_addr


* the physical address of a memory region must follow physical in the rule entry 




outputted messages
------------------


mmu table generation complete


        a correct binary file has been generated.


filling missing page table entries with fault entry 


        no default page table entry is defined for the current level.  missing entries will be defined at fault.


filling missing page table entries with level 1 default entry


        missing table entries will be defined using the level 1 default entry.


filling missing page table entries with level 2 default entry


        missing table entries will be defined using the level 2 default entry.


warning 1: the level 1 page table is # entries, instead of 4096


        the generated level 1 page table is not 4096 entries long.


warning 2: ignoring normal memory type, tex bits have already been set.


        the tex have already been set by one of the outer_xx attributes, so the normal memory type is ignored.


warning 3: ignoring device memory type, tex bits have already been set.


        the tex have already been set by one of the outer_xx attributes, so the device memory type is ignored.


warning 4: ignoring strongly ordered memory type, tex bits have already been set.


        the tex have already been set by one of the outer_xx attributes, so the strongly_ordered memory type is ignored.


error 1: couldn't open rule file


        the rule file specified could not be opened


error 2: couldn't open output file


        the output binary file could not be opened


error 3: mmu table could not be generated   


        a correct binary file has not been generated.


error 4: readonly and no_access are not attributes for v7 page tables


        it is invalid to specify a memory region with readonly and no_access attributes in a v7 page table.


error 5: bufferable, not cacheable normal memory is not allowed.


        the input rule file defined a memory region as normal, bufferable, and not cacheable.


error 6: device memory cannot be cacheable.


        the input rule file defined a memory region as device and cacheable. 


error 7: strongly ordered memory cannot be cacheable or bufferable.


        the input rule file defined a memory region as cacheable and/or bufferable. 


error 8: unrecognized word


        the input rule file contains invalid text. 


error 9: mmu page table level not set


        the rule file does not contain a level value.


error 10: section not defined from v1 to v2
        
        the input rule file does not define a region from address v1 to address v2.


error 11: defined address range cannot be divided into 16mb sections.


        the address range is not divisible by 16mb.


error 12: defined address range cannot be divided into 1mb sections.


        the address range is not divisible by 1mb.


error 13: an invalid entry type was entered.


        the input rule file level 1 description contains an invalid entry type (not fault, page, section, supersection)


error 14: defined address range cannot be divided into 64kb sections.


        the address range is not divisible by 64kb.


error 15: defined address range cannot be divided into 4kb sections.


        the address range is not divisible by 4kb.


error 16: an invalid page type was entered.


        the input rule file level 1 description contains an invalid entry type (not largepages, smallpages, extended_smallpages)


error 17: missing address range cannot be divided into 16mb sections.


        the missing memory region cannot be divided into 16mb section(s).


error 18: missing address range is not divisible by 1mb.


        the missing memory region cannot be divided into 1mb section(s).


error 19: missing address range cannot be divided into 64kb sections.


        the missing memory region cannot be divided into 64kb section(s).


error 20: missing address range is not divisible by 4kb.


        the missing memory region cannot be divided into 4kb section(s).


error 21: level 2 table was not declared at runtime.


        there is a level 2 table in the rule file, but the user said there were no level 2 table when running mmugen.axf in rvd.