开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
mmuArmLib.h
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：22k
源码类别：

VxWorks

开发平台：

C/C++

mmuArmLib.h：源码内容
  1. /* mmuArmLib.h - ARM MMU library header file */
  3. /* Copyright 1996-2001 Wind River Systems, Inc. */
  5. /*
  6. modification history
  7. --------------------
  8. 01p,15jan02,m_h  920,940 thumb incorrectly defined as CPU_940_T not CPU_940T_T
  9. 01o,05oct01,rec  added I-SRAM and D-SRAM CP15, R1 bit defs.
  10. 01n,03oct01,jpd  added WRITETHROUGH definitions for 946E.
  11. 01m,26jul01,scm  add extended small page table support for XScale...
  12. 01l,25jul01,scm  add support for extended page attributres on XScale...
  13. 01k,23jul01,scm  change XScale name to conform to coding standards...
  14. 01j,11dec00,scm  replace references to ARMSA2 with XScale
  15. 01i,01sep00,scm  add sa2 support...
  16. 01h,07sep99,jpd  added ARM740T, ARM920T support.
  17. 01g,20jan99,cdp  removed support for old ARM libraries;
  18.  add prefix to MMU_IDs.
  19. 01f,24nov98,jpd  added ARM940T support, added other CPU ids; removed
  20.  mmuIntLock/Unlock as intIFLock/Unlock to be used instead;
  21.             cdp  restructured for multiple cache/MMU libraries; big-endian.
  22. 01e,09mar98,jpd  added MMUCTR_ definitions for ARM810 and extra cache states.
  23. 01d,20jan98,jpd  added _func_armPhysToVirt() etc. function pointers.
  24. 01c,17sep97,jpd  added MMU_INIT_VALUE and mmuIntLock/Unlock definitions.
  25. 01b,24jan97,jpd  modified mmuAEnable definition.
  26. 01a,09may96,cdp  created.
  27. */
  29. #ifndef __INCmmuArmLibh
  30. #define __INCmmuArmLibh
  32. /*
  33.  * N.B. although this library contains code written for the ARM810 CPU,
  34.  * at the time of writing, this code has not been fully tested on
  35.  * that CPU. YOU HAVE BEEN WARNED.
  36.  */
  38. #ifdef __cplusplus
  39. extern "C" {
  40. #endif
  43. #ifndef _ASMLANGUAGE
  45. #include "memLib.h"
  47. #endif /* _ASMLANGUAGE */
  49. /*
  50.  * MMUs are not fitted to all processors, and so the definitions below
  51.  * should not need to be included for processors without MMUs.
  52.  */
  54. #if (ARMMMU != ARMMMU_NONE)
  56. /*
  57.  * MMU identifiers as read from ID register (not all tested, some from
  58.  * datasheets).
  59.  */
  61. #if (CPU==XSCALE)
  62. #define MMU_ID_CPU_MASK 0xFFFFF000 /* Mask for CPU types */
  64. #define MMU_ID_XSCALE           0x69052000 /* XScale needs validation */
  65. #else
  66. #define MMU_ID_CPU_MASK 0xFFFFF0 /* Mask for CPU types */
  68. #define MMU_ID_ARM710A 0x047100
  69. #define MMU_ID_ARM710T 0x807100
  70. #define MMU_ID_ARM720T 0x807200
  71. #define MMU_ID_ARM810 0x018100
  72. #define MMU_ID_SA110 0x01A100
  73. #define MMU_ID_SA1100 0x01A110
  74. #define MMU_ID_SA1500 0x01A150
  75. #define MMU_ID_ARM920T 0x029200
  76. #define MMU_ID_ARM940T 0x029400
  77. #define MMU_ID_ARM740T_8 0x807400 /* 8 kB cache variant */
  78. #define MMU_ID_ARM740T_4 0x817400 /* 4 kB cache variant */
  79. #define MMU_ID_ARM946E 0x049460
  80. #endif /* if CPU=XSCALE */
  83. /*
  84.  * The page size we will use. Ignore the sub-page, Large Page and Tiny
  85.  * Page features. Page size is still defined for MPUs, (it is the
  86.  * minimum size for a region).
  87.  */
  89. #define PAGE_SIZE 4096
  92. #if (!ARM_HAS_MPU) /* definitions for page-table type MMUs */
  93. /*
  94.  * The amount described by a Level 1 Descriptor, which equals the smallest
  95.  * amount of VM allocatable in VxWorks.
  96.  */
  98. #define PAGE_BLOCK_SIZE 0x100000 /* 1 MB */
  101. #define PTE_INDEX_MASK 0x000FF000 /* extract PTE index from Virt Addr */
  102. #define PTE_INDEX_SHIFT 12 /* shift to make that into PTE index */
  104. #define L1D_TO_BASE_SHIFT 10 /* to turn L1D to PT base addr */
  106. #define ADDR_PI_MASK 0x00000FFF /* extract page index from Virt Addr */
  108. #define ADDR_TO_PAGE 12 /* shift phys address to PTE page base address */
  111. /* Level 1 Descriptor types */
  113. #define DESC_TYPE_PAGE 1
  115. #define DEF_L1_PAGE 0x00000011 /* domain zero, Page descriptor */
  117. /*
  118.  * Section descriptors, such as might be used to set up an intermediate
  119.  * set of page tables on processors such as SA-1100/SA-1500 where this
  120.  * needs to be done from BSP initialisation, before vm(Base)Lib sets up
  121.  a proper set of page tables.
  122.  */
  124. #define RAM_SECT_DESC    0xC1E   /* R/W cacheable bufferable domain 0 */
  125. #define MINICACHE_SECT_DESC 0xC1A   /* R/W C+ B- domain 0 */
  126. #define OTHER_SECT_DESC 0xC12   /* R/W C- B- domain 0 */
  129. /* Level 2 Descriptor or Page Table Entry (PTE) types */
  131. #define PTE_TYPE_FAULT  0 /* any access will cause a fault */
  132. #define PTE_TYPE_SM_PAGE 2 /* Small page descriptor */
  133. #define PTE_TYPE_EX_PAGE 3 /* Extended page descriptor */
  136. /*
  137.  * The Translation Table Base register (TTBR) points to a table of Level 1
  138.  * Descriptors. these are either Invalid Section descriptors, Section
  139.  * Descriptors, or Page Table Descriptors. If Page Table Descriptors, they
  140.  * each point to a table of Level 2 Page Descriptors, or Page Table Entries
  141.  * (PTEs).
  142.  * The 32-bit (virtual) address space allows for 4096 M. Each Level 1
  143.  * Descriptor describes a 1 M area of memory. There are therefore 4096 Level
  144.  * 1 Descriptors, and each table of 256 Level 2 Page Descriptors (PTEs)
  145.  * describes 256 4 kbyte pages.
  146.  */
  148. #define NUM_L1_DESCS 4096
  149. #define NUM_L2_DESCS 256
  150. #define L1_TABLE_SIZE (NUM_L1_DESCS * sizeof(LEVEL_1_DESC))
  153. /* No. of pages a Level 1 Descriptor table takes up */
  155. #define L1_DESC_PAGES (L1_TABLE_SIZE / PAGE_SIZE)
  158. /* Size of a Page Table */
  160. #define PAGE_TABLE_SIZE (NUM_L2_DESCS * sizeof(PTE))
  163. /*
  164.  * Architecture-dependent MMU states. These are states settable for pages and
  165.  * here they correspond to settings in the Page Table Entries (PTEs).
  166.  *
  167.  * We set Valid/Invalid by setting a Fault second-level descriptor rather
  168.  * than by using the Access Permissions within a small page second-level
  169.  * descriptor. This is because we will want to use the Access Permissions to
  170.  * allow read/write from supervisor mode and we cannot then use the AP bits
  171.  * to disallow access as the SR bits in the MMU Control register must be set
  172.  * to 01 in order to control read/write access from Supervisor mode.
  173.  */
  175. #define MMU_STATE_MASK_VALID 0x03 /* 2nd level desc type*/
  177. #if (CPU==XSCALE)
  178. #define MMU_STATE_MASK_WRITABLE 0x00000030 /* AP bits */
  179. #else
  180. #define MMU_STATE_MASK_WRITABLE 0x00000FF0 /* All APn bits */
  181. #endif /* if CPU=XSCALE */
  183. #define MMU_STATE_MASK_CACHEABLE 0x0000000C /* CB bits */
  184. #if (CPU==XSCALE)
  185. #define MMU_STATE_MASK_EX_CACHEABLE 0x0000004C /* X bit, and CB bits */
  186. #endif
  188. #if (CPU==XSCALE)
  189. #define MMU_STATE_VALID PTE_TYPE_EX_PAGE /* set to page type */
  190. #else
  191. #define MMU_STATE_VALID PTE_TYPE_SM_PAGE /* set to page type */
  192. #endif /* if CPU=XSCALE */
  194. #define MMU_STATE_VALID_NOT PTE_TYPE_FAULT /* set to type fault */
  196. #if (CPU==XSCALE)
  197. #define MMU_STATE_WRITABLE 0x00000030 /* AP bits to 11 */
  198. #else
  199. #define MMU_STATE_WRITABLE 0x00000FF0 /* APn bits to 11 */
  200. #endif /* if CPU=XSCALE */
  201. #define MMU_STATE_WRITABLE_NOT 0x0 /* APn bits to 00 */
  203. #if ((ARMMMU == ARMMMU_710A) || (ARMMMU == ARMMMU_720T) || 
  204.      (ARMMMU == ARMMMU_XSCALE))
  205. /* Write-through mode is only available on some CPUs */
  207. #define MMU_STATE_CACHEABLE_WRITETHROUGH 0x8
  208. #endif /* (ARMMMU == ARMMMU_710A/720T/XSCALE) */
  210. #if ((ARMMMU == ARMMMU_SA1100) || (ARMMMU == ARMMMU_SA1500) || 
  211.      (ARMMMU == ARMMMU_XSCALE))
  212. /* Minicacheable state only available on some CPUs. */
  214. #if (CPU==XSCALE)
  215. #define MMU_STATE_CACHEABLE_MINICACHE 0x48 /* allocate in minicache, X=1, CB=10  */
  216. #else
  217. #define MMU_STATE_CACHEABLE_MINICACHE 0x8  /* allocate in minicache */
  218. #endif /* if CPU=XSCALE */
  220. #endif
  222. #define MMU_STATE_CACHEABLE_COPYBACK 0xC  /* write back */
  223. #if (CPU==XSCALE)
  224. #define MMU_STATE_CACHEABLE_EX_COPYBACK 0x4C /* allow read/write allocate, X=1, CB=11  */
  225. #endif /* if CPU=XSCALE */
  228. /*
  229.  * Set the default state to be copyback. CACHEABLE_WRITETHROUGH can also be
  230.  * selected on 710A.
  231.  */
  233. #define MMU_STATE_CACHEABLE MMU_STATE_CACHEABLE_COPYBACK
  234. #if (CPU==XSCALE)
  235. #define MMU_STATE_EX_CACHEABLE MMU_STATE_CACHEABLE_EX_COPYBACK
  236. #endif /* if CPU=XSCALE */
  238. #define MMU_STATE_CACHEABLE_NOT 0x0
  239. #if (CPU==XSCALE)
  240. #define MMU_STATE_EX_CACHEABLE_NOT 0x0
  241. #endif /* if CPU=XSCALE */
  243. #define MMU_STATE_BUFFERABLE 0x4 /* bufferable, not cacheable */
  244. #define MMU_STATE_BUFFERABLE_NOT 0x0 /* will also set not cacheable */
  245. #if (CPU==XSCALE)
  246. #define MMU_STATE_EX_BUFFERABLE 0x44 /* bufferable, not cacheable, no coalesce */
  247. #define MMU_STATE_EX_BUFFERABLE_NOT 0x0 /* will also set not cacheable, no coalesce */
  248. #endif /* if CPU=XSCALE */
  250. #else /* (!ARM_HAS_MPU) */
  252. #define MPU_REGION_BASE_MASK 0xFFFFF000
  253. #define MPU_REGION_SIZE_MASK 0x0000003E
  254. #define MPU_REGION_SIZE_MAX 0x0000003E
  257. #define MMU_STATE_MASK_VALID 0x03 /* 2 AP bits */
  258. #define MMU_STATE_MASK_CACHEABLE 0xC0 /* CB bits */
  260. #define MMU_STATE_VALID 0x03 /* Full access */
  261. #define MMU_STATE_VALID_NOT 0x00 /* No access */
  263. /* cacheable and bufferable states are not real physical bit definitions */
  265. #if ((ARMMMU == ARMMMU_740T) || (ARMMMU == ARMMMU_946E))
  266. /* Write-through mode is not available on all CPUs */
  268. #define MMU_STATE_CACHEABLE_WRITETHROUGH 0x80
  269. #endif /* (ARMMMU == ARMMMU_740T,946E) */
  271. #define MMU_STATE_CACHE_BIT 0x80
  273. #define MMU_STATE_CACHEABLE_COPYBACK 0xC0
  275. /*
  276.  * Set the default state to be copyback. CACHEABLE_WRITETHROUGH can also be
  277.  * selected on 740T/946E.
  278.  */
  280. #define MMU_STATE_CACHEABLE MMU_STATE_CACHEABLE_COPYBACK
  282. #define MMU_STATE_CACHEABLE_NOT 0x0
  284. #define MMU_STATE_BUFFERABLE 0x40 /* bufferable, not cacheable */
  285. #define MMU_STATE_BUFFERABLE_NOT 0x0 /* will also set not cacheable*/
  287. /*
  288.  * For MPUs, we need a size for a region that means the entire address
  289.  * space.  It is perfectly reasonable to wish to define such a region
  290.  * and it is of course, not expressible within a UINT. So, define a
  291.  * special size.
  292.  */
  294. #define MMU_ENTIRE_SPACE 0
  296. #endif /* (!ARM_HAS_MPU) */
  299. /* MMU Control Register bit allocations */
  301. #define MMUCR_M_ENABLE  (1<<0)  /* MMU enable */
  302. #define MMUCR_A_ENABLE  (1<<1)  /* Address alignment fault enable */
  303. #define MMUCR_C_ENABLE  (1<<2)  /* (data) cache enable */
  304. #define MMUCR_W_ENABLE  (1<<3)  /* write buffer enable */
  305. #define MMUCR_PROG32  (1<<4)  /* PROG32 */
  306. #define MMUCR_DATA32  (1<<5)  /* DATA32 */
  307. #define MMUCR_L_ENABLE  (1<<6)  /* Late abort on earlier CPUs */
  308. #define MMUCR_BIGEND  (1<<7)  /* Big-endian (=1), little-endian (=0) */
  309. #define MMUCR_SYSTEM  (1<<8)  /* System bit, modifies MMU protections */
  310. #define MMUCR_ROM  (1<<9)  /* ROM bit, modifies MMU protections */
  311. #define MMUCR_F  (1<<10) /* Should Be Zero */
  312. #define MMUCR_Z_ENABLE  (1<<11) /* Branch prediction enable on 810 */
  313. #define MMUCR_I_ENABLE  (1<<12) /* Instruction cache enable */
  315. #if ((defined CPU_946ES) || (defined CPU_946ES_T))
  316. #define MMUCR_ALTVECT      (1<<13) /* alternate vector select */
  317. #define MMUCR_ROUND_ROBIN    (1<<14) /* round-robin placement */
  318. #define MMUCR_DISABLE_TBIT   (1<<15) /* disable TBIT */
  319. #define MMUCR_DSRAM_EN       (1<<16) /* D-SRAM enable  */
  320. #define MMUCR_DSRAM_LOADMODE (1<<17) /* D-SRAM load mode select  */
  321. #define MMUCR_ISRAM_EN       (1<<18) /* I-SRAM enable  */
  322. #define MMUCR_ISRAM_LOADMODE (1<<19) /* I-SRAM load mode select  */
  323. #endif /* CPU_946ES */
  325. #if ((defined CPU_966ES) || (defined CPU_966ES_T))
  326. #define MMUCR_ALTVECT      (1<<13) /* alternate vector select */
  327. #define MMUCR_DISABLE_TBIT   (1<<15) /* disable TBIT */
  328. #endif /* CPU_966ES */
  330. #if ((defined CPU_920T) || (defined CPU_920T_T) || 
  331.      (defined CPU_940T) || (defined CPU_940T_T))
  332. #define MMUCR_FB_DISABLE (1<<30) /* nFastBus bit */
  333. #define MMUCR_ASYNC_BIT  (1<<31) /* Async bit*/
  334. #define MMUCR_SYNC  (1<<30) /* Synchronous mode */
  335. #define MMUCR_ASYNC  (3<<30) /* Asynchronous mode */
  336. #endif /* CPU_920T or CPU_940T */
  339. /*
  340.  * Values to be used when mmuEnable() is called. This will be after the MMU has
  341.  * been initialised by sysInit()/romInit() and after cacheLib has set whatever
  342.  * cache enable settings have been chosen.
  343.  *
  344.  * M 1 Enable MMU
  345.  * A 0 Enable address alignment fault
  346.  * C X ((D-)Cache Enable) Controlled by cacheLib
  347.  * W X (Write Buffer) Controlled by cacheLib
  348.  * P X (PROG32) should be set before this
  349.  * D X (DATA32) should be set before this
  350.  * L X (Late abort on earlier CPUs) ignore
  351.  * B X (Big/Little-endian) should be set before this
  352.  * S 0 (System)
  353.  * R 1 (ROM)
  354.  * F 0 Should be Zero
  355.  * Z X (Branch prediction enable on 810) Controlled by cacheLib
  356.  * I X (I-cache enable) Controlled by cacheLib
  357.  *
  358.  * For time being, do not enable the address alignment fault, as GCC
  359.  * currently generates unaligned accesses in its code, and switching this
  360.  * on will cause immediate faults. So, do not put it into the enable
  361.  * mask.
  362.  *
  363.  * We used to clear all the Reserved/Should Be Zero bits when the
  364.  * MMU/MPU was enabled, by including one bits for them in the definition
  365.  * of MMU_ENABLE_MASK. We no longer do this, as CPU designers may extend
  366.  * the definitions of the bits within the MMU Control Register. The MMU
  367.  * Control register is initialised within romInit()/sysInit(), as the BSP
  368.  * is the only place where the particular details of the CPU/MMU are
  369.  * actually known. In general, it will be appropriate for the BSP to
  370.  * initialise the MMUCR Reserved/Should Be Zero bits to zero. When the
  371.  * MMU is enabled, we will only change the bits we are particularly
  372.  * concerned about, by using a Read-Modify-Write strategy.
  373.  */
  375. #if (ARMMMU == ARMMMU_810)
  376. #define MMU_ENABLE_MASK  (MMUCR_M_ENABLE | MMUCR_SYSTEM | MMUCR_ROM | 
  377.   MMUCR_Z_ENABLE)
  378. #else
  379. #define MMU_ENABLE_MASK  (MMUCR_M_ENABLE | MMUCR_SYSTEM | MMUCR_ROM)
  380. #endif /* (ARMMMU == ARMMMU_810) */
  382. #if 0
  383. #if ((ARMMMU == ARMMMU_940T) || (ARMMMU == ARMMMU_920T))
  384. /*
  385.  * When enabling the 940T/920T, we should not alter the clocking mode that
  386.  * has been selected earlier (by the BSP).
  387.  */
  389. #define MMU_ENABLE_MASK  (0x3FFFE000 | 
  390. MMUCR_M_ENABLE | 
  391. MMUCR_SYSTEM | MMUCR_ROM | MMUCR_F | MMUCR_Z_ENABLE)
  392. #else
  393. #define MMU_ENABLE_MASK  (0xFFFFE000 | 
  394. MMUCR_M_ENABLE | 
  395. MMUCR_SYSTEM | MMUCR_ROM | MMUCR_F | MMUCR_Z_ENABLE)
  396. #endif /* (ARMMMU == ARMMMU_940T/920T) */
  397. #endif /* <<< 0 */
  399. #if ((ARMMMU == ARMMMU_710A) || (ARMMMU == ARMMMU_720T) || 
  400.      (ARMMMU == ARMMMU_920T))
  401. #define MMU_ENABLE_VALUE (MMUCR_M_ENABLE | MMUCR_ROM)
  402. #endif
  404. #if (ARMMMU == ARMMMU_810)
  405. #define MMU_ENABLE_VALUE (MMUCR_M_ENABLE | MMUCR_ROM )
  406. #endif
  408. #if ((ARMMMU == ARMMMU_SA110) || (ARMMMU == ARMMMU_SA1100) || 
  409.      (ARMMMU == ARMMMU_SA1500) || (ARMMMU == ARMMMU_XSCALE))
  410. #define MMU_ENABLE_VALUE (MMUCR_M_ENABLE | MMUCR_ROM)
  411. #endif
  413. #if ((ARMMMU == ARMMMU_940T) || (ARMMMU == ARMMMU_740T) || 
  414.      (ARMMMU == ARMMMU_946E))
  415. #define MMU_ENABLE_VALUE (MMUCR_M_ENABLE)
  416. #endif
  419. /*
  420.  * Values to be used when the MMU Control Register is initialised from
  421.  * within romInit.s or sysALib.s (before the MMU is enabled). Note that
  422.  * on 710A, this is also used to initialise the soft-copy of the MMU CR
  423.  * that we need to keep (in order to emulate Read-Modify-Write
  424.  * operations). So, 710A BSPs *MUST* initialise the MMU CR with the value
  425.  * contained here, or else trouble will ensue. This restriction does
  426.  * not apply to non-710A BSPs, but caution must be exercised in choosing a
  427.  * value different to that defined here.
  428.  */
  430. #if (_BYTE_ORDER == _LITTLE_ENDIAN)
  432. /* little-endian */
  434. #if ((ARMMMU == ARMMMU_710A) || (ARMMMU == ARMMMU_720T))
  435. #define MMU_INIT_VALUE (MMUCR_PROG32 | MMUCR_DATA32 | MMUCR_L_ENABLE | 
  436. MMUCR_ROM)
  437. #endif
  439. #if (ARMMMU == ARMMMU_810)
  440. #define MMU_INIT_VALUE (MMUCR_PROG32 | MMUCR_DATA32 | MMUCR_L_ENABLE | 
  441. MMUCR_ROM)
  442. #endif
  444. #if ((ARMMMU == ARMMMU_SA110) || (ARMMMU == ARMMMU_SA1100) || 
  445.      (ARMMMU == ARMMMU_SA1500) || (ARMMMU == ARMMMU_XSCALE))
  446. #define MMU_INIT_VALUE (MMUCR_PROG32 | MMUCR_DATA32 | MMUCR_L_ENABLE | 
  447. MMUCR_ROM)
  448. #endif
  450. #if ((ARMMMU == ARMMMU_940T) || (ARMMMU == ARMMMU_946E))
  451. /* W bit is Should Be One */
  453. #define MMU_INIT_VALUE (MMUCR_PROG32 | MMUCR_DATA32 | MMUCR_L_ENABLE | 
  454. MMUCR_W_ENABLE)
  455. #endif
  457. #if (ARMMMU == ARMMMU_740T)
  458. #define MMU_INIT_VALUE 0
  459. #endif
  461. #if (ARMMMU == ARMMMU_920T)
  462. /* W bit is Should Be One */
  464. #define MMU_INIT_VALUE (MMUCR_PROG32 | MMUCR_DATA32 | MMUCR_L_ENABLE | 
  465. MMUCR_ROM | MMUCR_W_ENABLE)
  466. #endif
  468. #else /* (_BYTE_ORDER == _LITTLE_ENDIAN) */
  470. /* big-endian */
  472. #if ((ARMMMU == ARMMMU_710A) || (ARMMMU == ARMMMU_720T))
  473. #define MMU_INIT_VALUE (MMUCR_PROG32 | MMUCR_DATA32 | MMUCR_L_ENABLE | 
  474. MMUCR_BIGEND | MMUCR_ROM)
  475. #endif
  477. #if (ARMMMU == ARMMMU_810)
  478. #define MMU_INIT_VALUE (MMUCR_PROG32 | MMUCR_DATA32 | MMUCR_L_ENABLE | 
  479. MMUCR_BIGEND | MMUCR_ROM)
  480. #endif
  482. #if ((ARMMMU == ARMMMU_SA110) || (ARMMMU == ARMMMU_SA1100) || 
  483.      (ARMMMU == ARMMMU_SA1500) || (ARMMMU == ARMMMU_XSCALE))
  484. #define MMU_INIT_VALUE (MMUCR_PROG32 | MMUCR_DATA32 | MMUCR_L_ENABLE | 
  485. MMUCR_BIGEND | MMUCR_ROM)
  486. #endif
  488. #if ((ARMMMU == ARMMMU_940T) || (ARMMMU == ARMMMU_946E))
  489. #define MMU_INIT_VALUE (MMUCR_PROG32 | MMUCR_DATA32 | MMUCR_L_ENABLE | 
  490. MMUCR_BIGEND | MMUCR_W_ENABLE)
  491. #endif
  493. #if (ARMMMU == ARMMMU_740T)
  494. #define MMU_INIT_VALUE MMUCR_BIGEND
  495. #endif
  497. #if (ARMMMU == ARMMMU_920T)
  498. #define MMU_INIT_VALUE (MMUCR_PROG32 | MMUCR_DATA32 | MMUCR_L_ENABLE | 
  499. MMUCR_W_ENABLE | MMUCR_BIGEND | MMUCR_ROM)
  500. #endif
  502. #endif /* _BYTE_ORDER == _LITTLE_ENDIAN */
  505. #if (ARMMMU == ARMMMU_810)
  507. /*
  508.  * Definitions for register 15 of the MMU coprocessor (clock and test
  509.  * configuration).
  510.  */
  512. #define MMUCTR_D  (1<<0) /* Enable Dynamic Clock switching */
  513. #define MMUCTR_S  (1<<1) /* Enable Synchronous clock switching */
  514. #define MMUCTR_F_BUS (0<<2) /* Fast clock source: ... bus clock */
  515. #define MMUCTR_F_REF (1<<2) /* ... REFCLK */
  516. #define MMUCTR_F_PLL (3<<2) /* ... PLL output clock */
  518. #endif /* (ARMMMU == ARMMMU_810) */
  520. #ifndef _ASMLANGUAGE
  522. #if (!ARM_HAS_MPU)
  524. #if (_BYTE_ORDER == _LITTLE_ENDIAN)
  526. /* little-endian */
  528. typedef struct
  529.     {
  530.     UINT type : 2; /* descriptor type, 1 => page */
  531.     UINT pad1 : 2; /* SBZ */
  532.     UINT pad2 : 1; /* SBO */
  533.     UINT domain : 4; /* domain number */
  534.     UINT pad3 : 1; /* SBZ */
  535.     UINT addr : 22; /* base address of page table */
  536.     } PAGE_DESC_FIELD;
  539. /* Layout of Page Table Entries (PTEs), actually small page descriptors */
  541. typedef struct
  542.     {
  543. #if (CPU==XSCALE)
  544.     UINT type : 2; /* page type, 3 => extended small page */
  545.     UINT cb : 2; /* cacheable/bufferable bits */
  546.     UINT ap : 2; /* access permission */
  547.     UINT tex  : 4; /* type extension field */
  548.     UINT sbz : 2; /* should be zero */
  549.     UINT addr : 20; /* page base address */
  550. #else
  551.     UINT type : 2; /* page type, 2 => small page */
  552.     UINT cb : 2; /* cacheable/bufferable bits */
  553.     UINT ap0 : 2; /* access permission, sub-page 0 */
  554.     UINT ap1 : 2; /* access permission, sub-page 1 */
  555.     UINT ap2 : 2; /* access permission, sub-page 2 */
  556.     UINT ap3 : 2; /* access permission, sub-page 3 */
  557.     UINT addr : 20; /* page base address */
  558. #endif /* if CPU=XSCALE */
  559.     } PTE_FIELD;
  561. #else /* (_BYTE_ORDER == _LITTLE_ENDIAN) */
  563. /* big-endian */
  565. typedef struct
  566.     {
  567.     UINT addr : 22; /* descriptor type, 1 => page */
  568.     UINT pad3 : 1; /* SBZ */
  569.     UINT domain : 4; /* domain number */
  570.     UINT pad2 : 1; /* SBO */
  571.     UINT pad1 : 2; /* SBZ */
  572.     UINT type : 2; /* base address of page table */
  573.     } PAGE_DESC_FIELD;
  575. /* Layout of Page Table Entries (PTEs), actually small page descriptors */
  577. typedef struct
  578.     {
  579. #if (CPU==XSCALE)
  580.     UINT addr : 20; /* page base address */
  581.     UINT sbz : 2; /* should be zero */
  582.     UINT tex  : 4; /* type extension field */
  583.     UINT ap : 2; /* access permission */
  584.     UINT cb : 2; /* cacheable/bufferable bits */
  585.     UINT type : 2; /* page type, 3 => extended small page */
  586. #else
  587.     UINT addr : 20; /* page base address */
  588.     UINT ap3 : 2; /* access permission, sub-page 3 */
  589.     UINT ap2 : 2; /* access permission, sub-page 2 */
  590.     UINT ap1 : 2; /* access permission, sub-page 1 */
  591.     UINT ap0 : 2; /* access permission, sub-page 0 */
  592.     UINT cb : 2; /* cacheable/bufferable bits */
  593.     UINT type : 2; /* page type, 2 => small page */
  594. #endif /* if CPU=XSCALE */
  595.     } PTE_FIELD;
  597. #endif /* (_BYTE_ORDER == _LITTLE_ENDIAN) */
  599. typedef union
  600.     {
  601.     PAGE_DESC_FIELD fields;
  602.     UINT32 bits;
  603.     } LEVEL_1_DESC;
  605. typedef union
  606.     {
  607.     PTE_FIELD fields;
  608.     UINT32 bits;
  609.     } PTE;
  611. typedef struct mmuTransTblStruct
  612.     {
  613.     LEVEL_1_DESC *pLevel1Table;
  614.     } MMU_TRANS_TBL;
  616. #else /* (!ARM_HAS_MPU) */
  618. #define MPU_NUM_REGIONS 8
  620. #if (_BYTE_ORDER == _LITTLE_ENDIAN)
  621. typedef struct
  622.     {
  623.     UINT enable : 1; /* 1 => region enabled */
  624.     UINT size : 5; /* size  */
  625.     UINT pad : 6; /* padding */
  626.     UINT base : 20; /* region base address */
  627.     } MPU_REGION_FIELDS;
  628. #else /* (_BYTE_ORDER == _LITTLE_ENDIAN) */
  629. /* Big-Endian */
  631. typedef struct
  632.     {
  633.     UINT base : 20; /* region base address */
  634.     UINT pad : 6; /* padding */
  635.     UINT size : 5; /* size  */
  636.     UINT enable : 1; /* 1 => region enabled */
  637.     } MPU_REGION_FIELDS;
  638. #endif /* (_BYTE_ORDER == _LITTLE_ENDIAN) */
  640. typedef union
  641.     {
  642.     MPU_REGION_FIELDS fields;
  643.     UINT32 bits;
  644.     } MPU_REGION_REG;
  646. typedef struct mmuTransTblStruct
  647.     {
  648.     MPU_REGION_REG regs[MPU_NUM_REGIONS];
  649.     } MMU_TRANS_TBL;
  651. #endif /* (!ARM_HAS_MPU) */
  654. /* Externally visible mmuLib, mmuMapLib and mmuALib2 routines */
  656. IMPORT UINT32 mmuReadId (void);
  657. IMPORT void * mmuVirtToPhys (void * addr);
  658. IMPORT void * mmuPhysToVirt (void * addr);
  660. IMPORT UINT32 (* mmuCrGet) (void);
  661. IMPORT void (* mmuModifyCr) (UINT32 value, UINT32 mask);
  662. IMPORT UINT32 mmuHardCrGet (void);
  663. IMPORT UINT32 mmuSoftCrGet (void);
  664. IMPORT void mmuModifyHardCr (UINT32 value, UINT32 mask);
  665. IMPORT void mmuModifySoftCr (UINT32 value, UINT32 mask);
  667. #if (ARMMMU == ARMMMU_710A)
  668. #include "mmuArm710aLib.h"
  669. #elif (ARMMMU == ARMMMU_720T)
  670. #include "mmuArm720tLib.h"
  671. #elif (ARMMMU == ARMMMU_740T)
  672. #include "mmuArm740tLib.h"
  673. #elif (ARMMMU == ARMMMU_810)
  674. #include "mmuArm810Lib.h"
  675. #elif (ARMMMU == ARMMMU_SA110)
  676. #include "mmuArmSA110Lib.h"
  677. #elif (ARMMMU == ARMMMU_SA1100)
  678. #include "mmuArmSA1100Lib.h"
  679. #elif (ARMMMU == ARMMMU_SA1500)
  680. #include "mmuArmSA1500Lib.h"
  681. #elif (ARMMMU == ARMMMU_920T)
  682. #include "mmuArm920tLib.h"
  683. #elif (ARMMMU == ARMMMU_940T)
  684. #include "mmuArm940tLib.h"
  685. #elif (ARMMMU == ARMMMU_946E)
  686. #include "mmuArm946eLib.h"
  687. #elif (ARMMMU == ARMMMU_XSCALE)
  688. #include "mmuArmXSCALELib.h"
  689. #endif /* ARMMMU == ARMMMU_710A */
  692. #if (!ARM_HAS_MPU)
  694. /*
  695.  * Pointer to a function that can be filled in by the BSP to point to a
  696.  * function that returns a memory partition id for an area of memory to store
  697.  * the Level 1 and Level 2 page tables. This area must be big enough for all
  698.  * use. No provision is made to use that memory and then continue using
  699.  * system memory once that has been filled.
  700.  * N.B. at the time of writing, this feature has NEVER been tested at all.
  701.  */
  703. IMPORT PART_ID (* _func_armPageSource) (void);
  705. #endif /* (!ARM_HAS_MPU) */
  707. #endif /* _ASMLANGUAGE */
  709. #endif /* (ARMMMU != ARMMMU_NONE) */
  711. #ifdef __cplusplus
  712. }
  713. #endif
  715. #endif /* __INCmmuArmLibh */