sysALib.s
上传用户:ske666
上传日期:2022-03-30
资源大小:371k
文件大小:8k
源码类别:

VxWorks

开发平台:

Objective-C

  1. /* sysALib.s - HITSAT omu system-dependent routines */
  2. /*
  3. DESCRIPTION
  4. This module contains:
  5. system-dependent routines written in assembly language;
  6. It contains the entry code:
  7. sysInit()
  8. for VxWorks images that start running from RAM, such as 'vxWorks'.
  9. These images are loaded into memory by some external program (e.g., a boot ROM) and then started.
  10. The routine sysInit() must come first in the text segment.
  11. Its job is to perform the minimal setup needed to call the generic C routine usrInit().
  12. sysInit()
  13. masks interrupts in:
  14. the processor
  15. the interrupt controller
  16. sets the initial stack pointer.
  17. Other hardware and device initialisation is performed later in the sysHwInit routine in sysLib.c.
  18. */
  19. #define _ASMLANGUAGE
  20. #include "vxWorks.h"
  21. #include "asm.h"
  22. #include "regs.h"
  23. #include "sysLib.h"
  24. #include "config.h"
  25. #include "arch/arm/mmuArmLib.h"
  26.         .data
  27.         .globl   VAR(copyright_wind_river)
  28.         .long    VAR(copyright_wind_river)
  29. /* internals */
  30. .globl FUNC(sysInit) /* start of system code */
  31. .globl FUNC(sysIntStackSplit) /* routine to split interrupt stack */
  32. /* externals */
  33. .extern FUNC(usrInit) /* system initialization routine */
  34. .extern FUNC(vxSvcIntStackBase) /* base of SVC-mode interrupt stack */
  35. .extern FUNC(vxSvcIntStackEnd) /* end of SVC-mode interrupt stack */
  36. .extern FUNC(vxIrqIntStackBase) /* base of IRQ-mode interrupt stack */
  37. .extern FUNC(vxIrqIntStackEnd) /* end of IRQ-mode interrupt stack */
  38. .text
  39. .balign 4
  40. /*******************************************************************************
  41. *
  42. * sysInit - start after boot
  43. *
  44. * This routine is the system start-up entry point for VxWorks in RAM, the
  45. * first code executed after booting.  It disables interrupts, sets up
  46. * the stack, and jumps to the C routine usrInit() in usrConfig.c.
  47. *
  48. * The initial stack is set to grow down from the address of sysInit().  This
  49. * stack is used only by usrInit() and is never used again.  Memory for the
  50. * stack must be accounted for when determining the system load address.
  51. *
  52. * NOTE: This routine should not be called by the user.
  53. *
  54. * RETURNS: N/A
  55. * sysInit ()              /@ THIS IS NOT A CALLABLE ROUTINE @/
  56. */
  57. _ARM_FUNCTION(sysInit)
  58. /* Turn off the watchdog. */
  59. ldr r0, =rWTCON_ADR /* r0->WTCON */
  60. ldr r1, =rWTCON_INIT_VALUE /* r1 = WTCON's initValue */
  61. str r1, [r0] /* Turn off the watch-dog */
  62. /* Setup MMU Control Register */
  63. mov r1, #MMU_INIT_VALUE /* Defined in mmuArmLib.h */
  64. #if defined(INTEGRATOR_EARLY_I_CACHE_ENABLE)
  65. orr r1, r1, #MMUCR_I_ENABLE /* conditionally enable Icache*/
  66. #endif
  67. mcr p15, 0, r1, c1, c0, 0 /* Write to MMU CR */
  68. /* drain write-buffer */
  69. mov r1, #0 /* data SBZ */
  70. mcr p15, 0, r1, c7, c10, 4
  71. /* Flush (invalidate) both I and D caches */
  72. mcr p15, 0, r1, c7, c7, 0 /* R1 = 0 from above, data SBZ*/
  73.         /*
  74.         Set Process ID Register to zero, 
  75.         this effectively disables the process ID remapping feature.
  76.         */
  77. mov r1, #0
  78. mcr p15, 0, r1, c13, c0, 0
  79. /* Disable interrupts in processor and switch to SVC32 mode */
  80. mrs r1, cpsr
  81. bic r1, r1, #MASK_MODE
  82. orr r1, r1, #MODE_SVC32 | I_BIT | F_BIT
  83. msr cpsr, r1
  84. /* Disable individual interrupts in the interrupt controller */
  85. ldr r1, =0xffffffff
  86. ldr r2, =rINTMSK_ADR /* R2->interrupt mask registor of controller */
  87. str r1, [r2] /* disable all sources */
  88. ldr r2, =rINTSUBMSK_ADR /* R2->sub-interrupt mask registor of controller */
  89. str r1, [r2] /* disable all sub-sources */
  90. /* Set asynchronous mode via MMU. */
  91. mrc p15, 0, r2, c1, c0, 0
  92. orr r2, r2, #MMUCR_ASYNC
  93. mcr p15, 0, r2, c1, c0, 0
  94. /* Set PLL lock time. */
  95. ldr r2, =rLOCKTIME_ADR
  96. ldr r1, =rLOCKTIME_INIT_VALUE
  97. str r1, [r2]
  98. /* Set FCLK:HCLK:PCLK = 1:2:4 */
  99. ldr r2, =rCLKDIVN_ADR
  100. ldr r1, =rCLKDIVN_INIT_VALUE
  101. str r1, [r2]
  102. /* Set FCLK = 200MHz by Fosc = 12MHz */
  103. ldr r2, =rMPLLCON_ADR
  104. /* ldr r1, =rMPLLCON_INIT_VALUE*/
  105.   ldr r1, =0xa1031
  106. str r1, [r2]
  107. /* Set clock control register */
  108. ldr r2, =rCLKCON_ADR
  109. ldr r1, =rCLKCON_INIT_VALUE
  110. str r1, [r2]
  111. /* Set clock slow register */
  112. ldr r2, =rCLKSLOW_ADR
  113. ldr r1, =rCLKSLOW_INIT_VALUE
  114. str r1, [r2]
  115.   
  116. /* Set bus width for each bank, 0x22111112 */
  117. ldr r2, =rBWSCON_ADR
  118. ldr r1, =0x2211d120 /*((0x2<<4)+(0x1<<8)+((0x1+(0x1<<2)+(0x1<<3))<<12)+(0x1<<16)+(0x1<<20)+(0x2<<24)+(0x2<<28))*/
  119. str r1, [r2]
  120. /* Set bank0 and bank5 for flash and cs8900, 0x00000700 */
  121. ldr r2, =rBANKCON0_ADR
  122. ldr r1, =rBANKCON0_INIT_VALUE
  123. str r1, [r2]
  124. ldr r2, =rBANKCON3_ADR
  125. ldr r1, =0x1F4C
  126. str r1, [r2]
  127. /*Add by wangbinbin
  128. ldr r2, =rBANKCON5_ADR
  129. ldr r1, =rBANKCON5_INIT_VALUE
  130. str r1, [r2]
  131. */
  132. /*Add by wangbinbin*/
  133.  /*Set bank6 for SDRAM, 0x00018000 */
  134. ldr r2, =rBANKCON6_ADR
  135. ldr r1, =rBANKCON6_INIT_VALUE
  136. str r1, [r2]
  137.   
  138.   
  139. /* Set refresh for SDRAM, 0x00860459 */
  140. ldr r2, =rREFRESH_ADR
  141. ldr r1, =rREFRESH_INIT_VALUE
  142. str r1, [r2]
  143. /* Set bank size for SDRAM, 0x000000b7 */
  144. ldr r2, =rBANKSIZE_ADR
  145. ldr r1, =rBANKSIZE_INIT_VALUE
  146. str r1, [r2]
  147. /* Set bank mode, 0x00000030 */
  148. ldr r2, =rMRSRB6_ADR
  149. ldr r1, =rMRSRB6_INIT_VALUE
  150. str r1, [r2]
  151.   
  152. /* initialise stack pointer */
  153. adr sp, FUNC(sysInit)
  154. /* now call usrInit */
  155. mov fp, #0 /* initialise frame pointer */
  156. mov r0, #BOOT_WARM_AUTOBOOT /* pass startType */
  157. #if (ARM_THUMB)
  158. ldr r12, L$_usrInit
  159. bx r12
  160. #else
  161. b FUNC(usrInit)
  162. #endif /* (ARM_THUMB) */
  163. /*******************************************************************************
  164. *
  165. * sysIntStackSplit - split interrupt stack and set interrupt stack pointers
  166. *
  167. * This routine is called, via a function pointer, during kernel
  168. * initialisation.  It splits the allocated interrupt stack into IRQ and
  169. * SVC-mode stacks and sets the processor's IRQ stack pointer. Note that
  170. * the pointer passed points to the bottom of the stack allocated i.e.
  171. * highest address+1.
  172. *
  173. * IRQ stack needs 6 words per nested interrupt;
  174. * SVC-mode will need a good deal more for the C interrupt handlers.
  175. * For now, use ratio 1:7 with any excess allocated to the SVC-mode stack
  176. * at the lowest address.
  177. *
  178. * Note that FIQ is not handled by VxWorks so no stack is allocated for it.
  179. *
  180. * The stacks and the variables that describe them look like this.
  181. * .CS
  182. *
  183. *         - HIGH MEMORY -
  184. *     ------------------------ <--- vxIrqIntStackBase (r0 on entry)
  185. *     |                      |
  186. *     |       IRQ-mode       |
  187. *     |    interrupt stack   |
  188. *     |                      |
  189. *     ------------------------ <--{ vxIrqIntStackEnd
  190. *     |                      |    { vxSvcIntStackBase
  191. *     |       SVC-mode       |
  192. *     |    interrupt stack   |
  193. *     |                      |
  194. *     ------------------------ <--- vxSvcIntStackEnd
  195. *         - LOW  MEMORY -
  196. * .CE
  197. *
  198. * NOTE: This routine should not be called by the user.
  199. * void sysIntStackSplit
  200. *     (
  201. *     char *pBotStack   /@ pointer to bottom of interrupt stack @/
  202. *     long size /@ size of stack @/
  203. *     )
  204. */
  205. _ARM_FUNCTION_CALLED_FROM_C(sysIntStackSplit)
  206. /*
  207.  * r0 = base of space allocated for stacks (i.e. highest address)
  208.  * r1 = size of space
  209.  */
  210. sub r2, r0, r1 /* r2->lowest usable address */
  211. ldr r3, L$_vxSvcIntStackEnd
  212. str r2, [r3] /*  == end of SVC-mode stack */
  213. sub r2, r0, r1, ASR #3 /* leave 1/8 for IRQ */
  214. ldr r3, L$_vxSvcIntStackBase
  215. str r2, [r3]
  216. /* now allocate IRQ stack, setting irq_sp */
  217. ldr r3, L$_vxIrqIntStackEnd
  218. str r2, [r3]
  219. ldr r3, L$_vxIrqIntStackBase
  220. str r0, [r3]
  221. mrs r2, cpsr
  222. bic r3, r2, #MASK_MODE
  223. orr r3, r3, #MODE_IRQ32 | I_BIT /* set irq_sp */
  224. msr cpsr, r3
  225. mov sp, r0
  226. /* switch back to original mode and return */
  227. msr cpsr, r2
  228. #if (ARM_THUMB)
  229. bx lr
  230. #else
  231. mov pc, lr
  232. #endif /* (ARM_THUMB) */
  233. /******************************************************************************/
  234. /*
  235.  * PC-relative-addressable pointers - LDR Rn,=sym is broken
  236.  * note "_" after "$" to stop preprocessor preforming substitution
  237.  */
  238. .balign 4
  239. L$_vxSvcIntStackBase:
  240. .long VAR(vxSvcIntStackBase)
  241. L$_vxSvcIntStackEnd:
  242. .long VAR(vxSvcIntStackEnd)
  243. L$_vxIrqIntStackBase:
  244. .long VAR(vxIrqIntStackBase)
  245. L$_vxIrqIntStackEnd:
  246. .long VAR(vxIrqIntStackEnd)
  247. #if (ARM_THUMB)
  248. L$_usrInit:
  249. .long FUNC(usrInit)
  250. #endif /* (ARM_THUMB) */