ArmPkg/Include/AsmMacroIoLib.h

   1 /** @file
   2   Macros to work around lack of Apple support for LDR register, =expr
   3
   4   Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
   5   Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
   6
   7   This program and the accompanying materials
   8   are licensed and made available under the terms and conditions of the BSD License
   9   which accompanies this distribution.  The full text of the license may be found at
  10   http://opensource.org/licenses/bsd-license.php
  11
  12   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17
  18 #ifndef __MACRO_IO_LIB_H__
  19 #define __MACRO_IO_LIB_H__
  20
  21 #if defined(__APPLE__)
  22
  23 //
  24 //  ldr reg, =expr does not work with current Apple tool chain. So do the work our selves
  25 //
  26
  27 // returns _Data in R0 and _Address in R1
  28 #define MmioWrite32(_Address, _Data) \
  29   ldr  r1, [pc, #8]     ;            \
  30   ldr  r0, [pc, #8]     ;            \
  31   str  r0, [r1]         ;            \
  32   b    1f               ;            \
  33   .long (_Address)      ;            \
  34   .long (_Data) ;                    \
  35 1:
  36
  37 // returns _Data in R0 and _Address in R1, and _OrData in r2
  38 #define MmioOr32(_Address, _OrData) \
  39   ldr  r1, [pc, #16]    ;           \
  40   ldr  r2, [pc, #16]    ;           \
  41   ldr  r0, [r1]         ;           \
  42   orr  r0, r0, r2       ;           \
  43   str  r0, [r1]         ;           \
  44   b    1f               ;           \
  45   .long (_Address)      ;           \
  46   .long (_OrData)       ;           \
  47 1:
  48
  49 // returns _Data in R0 and _Address in R1, and _OrData in r2
  50 #define MmioAnd32(_Address, _AndData) \
  51   ldr  r1, [pc, #16]    ;             \
  52   ldr  r2, [pc, #16]    ;             \
  53   ldr  r0, [r1]         ;             \
  54   and  r0, r0, r2       ;             \
  55   str  r0, [r1]         ;             \
  56   b    1f               ;             \
  57   .long (_Address)      ;             \
  58   .long (_AndData)       ;             \
  59 1:
  60
  61 // returns result in R0, _Address in R1, and _OrData in r2
  62 #define MmioAndThenOr32(_Address, _AndData, _OrData)  \
  63   ldr  r1, [pc, #24]    ;                             \
  64   ldr  r0, [r1]         ;                             \
  65   ldr  r2, [pc, #20]    ;                             \
  66   and  r0, r0, r2       ;                             \
  67   ldr  r2, [pc, #16]    ;                             \
  68   orr  r0, r0, r2       ;                             \
  69   str  r0, [r1]         ;                             \
  70   b    1f               ;                             \
  71   .long (_Address)      ;                             \
  72   .long (_AndData)      ;                             \
  73   .long (_OrData)       ;                             \
  74 1:
  75
  76 // returns _Data in _Reg and _Address in R1
  77 #define MmioWriteFromReg32(_Address, _Reg) \
  78   ldr  r1, [pc, #4]     ;                  \
  79   str  _Reg, [r1]       ;                  \
  80   b    1f               ;                  \
  81   .long (_Address)      ;                  \
  82 1:
  83
  84
  85 // returns _Data in R0 and _Address in R1
  86 #define MmioRead32(_Address)   \
  87   ldr  r1, [pc, #4]     ;      \
  88   ldr  r0, [r1]         ;      \
  89   b    1f               ;      \
  90   .long (_Address)      ;      \
  91 1:
  92
  93 // returns _Data in Reg and _Address in R1
  94 #define MmioReadToReg32(_Address, _Reg) \
  95   ldr  r1, [pc, #4]     ;               \
  96   ldr  _Reg, [r1]       ;               \
  97   b    1f               ;               \
  98   .long (_Address)      ;               \
  99 1:
 100
 101
 102 // load R0 with _Data
 103 #define LoadConstant(_Data)  \
 104   ldr  r0, [pc, #0]     ;    \
 105   b    1f               ;    \
 106   .long (_Data)         ;    \
 107 1:
 108
 109 // load _Reg with _Data
 110 #define LoadConstantToReg(_Data, _Reg)  \
 111   ldr  _Reg, [pc, #0]   ;               \
 112   b    1f               ;               \
 113   .long (_Data)         ;               \
 114 1:
 115
 116 // load _Reg with _Data if eq
 117 #define LoadConstantToRegIfEq(_Data, _Reg)  \
 118   ldreq  _Reg, [pc, #0]   ;                 \
 119   b    1f                 ;                 \
 120   .long (_Data)           ;                 \
 121 1:
 122
 123 // Convert the (ClusterId,CoreId) into a Core Position
 124 // We assume there are 4 cores per cluster
 125 #define GetCorePositionFromMpId(Pos, MpId, Tmp) \
 126   lsr   Pos, MpId, #6 ;                        \
 127   and   Tmp, MpId, #3 ;                        \
 128   add   Pos, Pos, Tmp
 129
 130 // Reserve a region at the top of the Primary Core stack
 131 // for Global variables for the XIP phase
 132 #define SetPrimaryStack(StackTop, GlobalSize, Tmp)  \
 133   and     Tmp, GlobalSize, #7         ;             \
 134   rsbne   Tmp, Tmp, #8                ;             \
 135   add     GlobalSize, GlobalSize, Tmp ;             \
 136   sub     sp, StackTop, GlobalSize    ;             \
 137                                       ;             \
 138   mov     Tmp, sp                     ;             \
 139   mov     GlobalSize, #0x0            ;             \
 140 _SetPrimaryStackInitGlobals:          ;             \
 141   cmp     Tmp, StackTop               ;             \
 142   beq     _SetPrimaryStackEnd         ;             \
 143   str     GlobalSize, [Tmp], #4       ;             \
 144   b       _SetPrimaryStackInitGlobals ;             \
 145 _SetPrimaryStackEnd:
 146
 147 // Initialize the Global Variable with '0'
 148 #define InitializePrimaryStack(GlobalSize, Tmp1)    \
 149   and     Tmp1, GlobalSize, #7        ;             \
 150   rsbne   Tmp1, Tmp1, #8              ;             \
 151   add     GlobalSize, GlobalSize, Tmp1 ;            \
 152                                       ;             \
 153   mov     Tmp1, sp                    ;             \
 154   sub     sp, GlobalSize              ;             \
 155   mov     GlobalSize, #0x0            ;             \
 156 _InitializePrimaryStackLoop:          ;             \
 157   cmp     Tmp1, sp                    ;             \
 158   bls     _InitializePrimaryStackEnd  ;             \
 159   str     GlobalSize, [Tmp1], #-4     ;             \
 160   b       _InitializePrimaryStackLoop ;             \
 161 _InitializePrimaryStackEnd:
 162
 163 #elif defined (__GNUC__)
 164
 165 #define MmioWrite32(Address, Data) \
 166   ldr  r1, =Address ;              \
 167   ldr  r0, =Data    ;              \
 168   str  r0, [r1]
 169
 170 #define MmioOr32(Address, OrData) \
 171   ldr  r1, =Address ;             \
 172   ldr  r2, =OrData  ;             \
 173   ldr  r0, [r1]     ;             \
 174   orr  r0, r0, r2   ;             \
 175   str  r0, [r1]
 176
 177 #define MmioAnd32(Address, AndData) \
 178   ldr  r1, =Address ;               \
 179   ldr  r2, =AndData ;               \
 180   ldr  r0, [r1]     ;               \
 181   and  r0, r0, r2   ;               \
 182   str  r0, [r1]
 183
 184 #define MmioAndThenOr32(Address, AndData, OrData) \
 185   ldr  r1, =Address ;                             \
 186   ldr  r0, [r1]     ;                             \
 187   ldr  r2, =AndData ;                             \
 188   and  r0, r0, r2   ;                             \
 189   ldr  r2, =OrData  ;                             \
 190   orr  r0, r0, r2   ;                             \
 191   str  r0, [r1]
 192
 193 #define MmioWriteFromReg32(Address, Reg) \
 194   ldr  r1, =Address ;                    \
 195   str  Reg, [r1]
 196
 197 #define MmioRead32(Address) \
 198   ldr  r1, =Address ;       \
 199   ldr  r0, [r1]
 200
 201 #define MmioReadToReg32(Address, Reg) \
 202   ldr  r1, =Address ;                 \
 203   ldr  Reg, [r1]
 204
 205 #define LoadConstant(Data) \
 206   ldr  r0, =Data
 207
 208 #define LoadConstantToReg(Data, Reg) \
 209   ldr  Reg, =Data
 210
 211 #define GetCorePositionFromMpId(Pos, MpId, Tmp) \
 212   lsr   Pos, MpId, #6 ;                        \
 213   and   Tmp, MpId, #3 ;                        \
 214   add   Pos, Pos, Tmp
 215
 216 #define SetPrimaryStack(StackTop, GlobalSize, Tmp)  \
 217   and     Tmp, GlobalSize, #7         ;             \
 218   rsbne   Tmp, Tmp, #8                ;             \
 219   add     GlobalSize, GlobalSize, Tmp ;             \
 220   sub     sp, StackTop, GlobalSize    ;             \
 221                                       ;             \
 222   mov     Tmp, sp                     ;             \
 223   mov     GlobalSize, #0x0            ;             \
 224 _SetPrimaryStackInitGlobals:          ;             \
 225   cmp     Tmp, StackTop               ;             \
 226   beq     _SetPrimaryStackEnd         ;             \
 227   str     GlobalSize, [Tmp], #4       ;             \
 228   b       _SetPrimaryStackInitGlobals ;             \
 229 _SetPrimaryStackEnd:
 230
 231 // Initialize the Global Variable with '0'
 232 #define InitializePrimaryStack(GlobalSize, Tmp1)    \
 233   and     Tmp1, GlobalSize, #7        ;             \
 234   rsbne   Tmp1, Tmp1, #8              ;             \
 235   add     GlobalSize, GlobalSize, Tmp1 ;            \
 236                                       ;             \
 237   mov     Tmp1, sp                    ;             \
 238   sub     sp, GlobalSize              ;             \
 239   mov     GlobalSize, #0x0            ;             \
 240 _InitializePrimaryStackLoop:          ;             \
 241   cmp     Tmp1, sp                    ;             \
 242   bls     _InitializePrimaryStackEnd  ;             \
 243   str     GlobalSize, [Tmp1], #-4     ;             \
 244   b       _InitializePrimaryStackLoop ;             \
 245 _InitializePrimaryStackEnd:
 246
 247 #else
 248
 249 //
 250 // Use ARM assembly macros, form armasam
 251 //
 252 //  Less magic in the macros if ldr reg, =expr works
 253 //
 254
 255 // returns _Data in R0 and _Address in R1
 256
 257
 258
 259 #define MmioWrite32(Address, Data) MmioWrite32Macro Address, Data
 260
 261
 262
 263
 264 // returns Data in R0 and Address in R1, and OrData in r2
 265 #define MmioOr32(Address, OrData) MmioOr32Macro Address, OrData
 266
 267
 268 // returns _Data in R0 and _Address in R1, and _OrData in r2
 269
 270
 271 #define MmioAnd32(Address, AndData)  MmioAnd32Macro Address, AndData
 272
 273 // returns result in R0, _Address in R1, and _OrData in r2
 274
 275
 276 #define MmioAndThenOr32(Address, AndData, OrData) MmioAndThenOr32Macro Address, AndData, OrData
 277
 278
 279 // returns _Data in _Reg and _Address in R1
 280
 281
 282 #define MmioWriteFromReg32(Address, Reg) MmioWriteFromReg32Macro Address, Reg
 283
 284 // returns _Data in R0 and _Address in R1
 285
 286
 287 #define MmioRead32(Address)  MmioRead32Macro Address
 288
 289 // returns _Data in Reg and _Address in R1
 290
 291
 292 #define MmioReadToReg32(Address, Reg) MmioReadToReg32Macro Address, Reg
 293
 294
 295 // load R0 with _Data
 296
 297
 298 #define LoadConstant(Data)  LoadConstantMacro Data
 299
 300 // load _Reg with _Data
 301
 302
 303 #define LoadConstantToReg(Data, Reg)  LoadConstantToRegMacro Data, Reg
 304
 305 // conditional load testing eq flag
 306 #define LoadConstantToRegIfEq(Data, Reg)  LoadConstantToRegIfEqMacro Data, Reg
 307
 308 #define GetCorePositionFromMpId(Pos, MpId, Tmp)  GetCorePositionFromMpId Pos, MpId, Tmp
 309
 310 #define SetPrimaryStack(StackTop,GlobalSize,Tmp) SetPrimaryStack StackTop, GlobalSize, Tmp
 311
 312 // Initialize the Global Variable with '0'
 313 #define InitializePrimaryStack(GlobalSize, Tmp1) InitializePrimaryStack GlobalSize, Tmp1
 314
 315 #endif
 316
 317 #endif