arch/s390/kernel/head64.S

   1 /*
   2  * arch/s390/kernel/head64.S
   3  *
   4  * Copyright (C) IBM Corp. 1999,2006
   5  *
   6  *   Author(s): Hartmut Penner <hp@de.ibm.com>
   7  *              Martin Schwidefsky <schwidefsky@de.ibm.com>
   8  *              Rob van der Heij <rvdhei@iae.nl>
   9  *              Heiko Carstens <heiko.carstens@de.ibm.com>
  10  *
  11  */
  12
  13 #
  14 # startup-code at 0x10000, running in absolute addressing mode
  15 # this is called either by the ipl loader or directly by PSW restart
  16 # or linload or SALIPL
  17 #
  18         .org  0x10000
  19 startup:basr  %r13,0                     # get base
  20 .LPG0:  l     %r13,0f-.LPG0(%r13)
  21         b     0(%r13)
  22 0:      .long startup_continue
  23
  24 #
  25 # params at 10400 (setup.h)
  26 #
  27         .org   PARMAREA
  28         .quad  0                        # IPL_DEVICE
  29         .quad  0                        # INITRD_START
  30         .quad  0                        # INITRD_SIZE
  31
  32         .org   COMMAND_LINE
  33         .byte  "root=/dev/ram0 ro"
  34         .byte  0
  35
  36         .org   0x11000
  37
  38 startup_continue:
  39         basr  %r13,0                     # get base
  40 .LPG1:  sll   %r13,1                     # remove high order bit
  41         srl   %r13,1
  42         GET_IPL_DEVICE
  43         lhi   %r1,1                      # mode 1 = esame
  44         mvi   __LC_AR_MODE_ID,1          # set esame flag
  45         slr   %r0,%r0                    # set cpuid to zero
  46         sigp  %r1,%r0,0x12               # switch to esame mode
  47         sam64                            # switch to 64 bit mode
  48         lctlg %c0,%c15,.Lctl-.LPG1(%r13) # load control registers
  49         lg    %r12,.Lparmaddr-.LPG1(%r13)# pointer to parameter area
  50                                          # move IPL device to lowcore
  51         mvc   __LC_IPLDEV(4),IPL_DEVICE+4-PARMAREA(%r12)
  52
  53 #
  54 # clear bss memory
  55 #
  56         larl  %r2,__bss_start           # start of bss segment
  57         larl  %r3,_end                  # end of bss segment
  58         sgr   %r3,%r2                   # length of bss
  59         sgr   %r4,%r4                   #
  60         sgr   %r5,%r5                   # set src,length and pad to zero
  61         mvcle %r2,%r4,0                 # clear mem
  62         jo    .-4                       # branch back, if not finish
  63
  64         l     %r2,.Lrcp-.LPG1(%r13)     # Read SCP forced command word
  65 .Lservicecall:
  66         stosm .Lpmask-.LPG1(%r13),0x01  # authorize ext interrupts
  67
  68         stctg %r0,%r0,.Lcr-.LPG1(%r13)  # get cr0
  69         la    %r1,0x200                 # set bit 22
  70         og    %r1,.Lcr-.LPG1(%r13)      # or old cr0 with r1
  71         stg   %r1,.Lcr-.LPG1(%r13)
  72         lctlg %r0,%r0,.Lcr-.LPG1(%r13)  # load modified cr0
  73
  74         mvc   __LC_EXT_NEW_PSW(8),.Lpcmsk-.LPG1(%r13) # set postcall psw
  75         larl  %r1,.Lsclph
  76         stg   %r1,__LC_EXT_NEW_PSW+8    # set handler
  77
  78         larl  %r4,.Lsccb                # %r4 is our index for sccb stuff
  79         lgr   %r1,%r4                   # our sccb
  80         .insn rre,0xb2200000,%r2,%r1    # service call
  81         ipm   %r1
  82         srl   %r1,28                    # get cc code
  83         xr    %r3,%r3
  84         chi   %r1,3
  85         be    .Lfchunk-.LPG1(%r13)      # leave
  86         chi   %r1,2
  87         be    .Lservicecall-.LPG1(%r13)
  88         lpswe .Lwaitsclp-.LPG1(%r13)
  89 .Lsclph:
  90         lh    %r1,.Lsccbr-.Lsccb(%r4)
  91         chi   %r1,0x10                  # 0x0010 is the sucess code
  92         je    .Lprocsccb                # let's process the sccb
  93         chi   %r1,0x1f0
  94         bne   .Lfchunk-.LPG1(%r13)      # unhandled error code
  95         c     %r2,.Lrcp-.LPG1(%r13)     # Did we try Read SCP forced
  96         bne   .Lfchunk-.LPG1(%r13)      # if no, give up
  97         l     %r2,.Lrcp2-.LPG1(%r13)    # try with Read SCP
  98         b     .Lservicecall-.LPG1(%r13)
  99 .Lprocsccb:
 100         lghi  %r1,0
 101         icm   %r1,3,.Lscpincr1-.Lsccb(%r4) # use this one if != 0
 102         jnz   .Lscnd
 103         lg    %r1,.Lscpincr2-.Lsccb(%r4) # otherwise use this one
 104 .Lscnd:
 105         xr    %r3,%r3                   # same logic
 106         ic    %r3,.Lscpa1-.Lsccb(%r4)
 107         chi   %r3,0x00
 108         jne   .Lcompmem
 109         l     %r3,.Lscpa2-.Lsccb(%r4)
 110 .Lcompmem:
 111         mlgr  %r2,%r1                   # mem in MB on 128-bit
 112         l     %r1,.Lonemb-.LPG1(%r13)
 113         mlgr  %r2,%r1                   # mem size in bytes in %r3
 114         b     .Lfchunk-.LPG1(%r13)
 115
 116         .align 4
 117 .Lpmask:
 118         .byte 0
 119         .align 8
 120 .Lcr:
 121         .quad 0x00  # place holder for cr0
 122 .Lwaitsclp:
 123         .quad  0x0102000180000000,.Lsclph
 124 .Lrcp:
 125         .int 0x00120001 # Read SCP forced code
 126 .Lrcp2:
 127         .int 0x00020001 # Read SCP code
 128 .Lonemb:
 129         .int 0x100000
 130
 131 .Lfchunk:
 132                                          # set program check new psw mask
 133         mvc   __LC_PGM_NEW_PSW(8),.Lpcmsk-.LPG1(%r13)
 134
 135 #
 136 # find memory chunks.
 137 #
 138         lgr   %r9,%r3                    # end of mem
 139         larl  %r1,.Lchkmem               # set program check address
 140         stg   %r1,__LC_PGM_NEW_PSW+8
 141         la    %r1,1                      # test in increments of 128KB
 142         sllg  %r1,%r1,17
 143         larl  %r3,memory_chunk
 144         slgr  %r4,%r4                    # set start of chunk to zero
 145         slgr  %r5,%r5                    # set end of chunk to zero
 146         slr  %r6,%r6                     # set access code to zero
 147         la    %r10,MEMORY_CHUNKS         # number of chunks
 148 .Lloop:
 149         tprot 0(%r5),0                   # test protection of first byte
 150         ipm   %r7
 151         srl   %r7,28
 152         clr   %r6,%r7                    # compare cc with last access code
 153         je    .Lsame
 154         j     .Lchkmem
 155 .Lsame:
 156         algr  %r5,%r1                    # add 128KB to end of chunk
 157                                          # no need to check here,
 158         brc   12,.Lloop                  # this is the same chunk
 159 .Lchkmem:                                # > 16EB or tprot got a program check
 160         clgr  %r4,%r5                    # chunk size > 0?
 161         je    .Lchkloop
 162         stg   %r4,0(%r3)                 # store start address of chunk
 163         lgr   %r0,%r5
 164         slgr  %r0,%r4
 165         stg   %r0,8(%r3)                 # store size of chunk
 166         st    %r6,20(%r3)                # store type of chunk
 167         la    %r3,24(%r3)
 168         larl  %r8,memory_size
 169         stg   %r5,0(%r8)                 # store memory size
 170         ahi   %r10,-1                    # update chunk number
 171 .Lchkloop:
 172         lr    %r6,%r7                    # set access code to last cc
 173         # we got an exception or we're starting a new
 174         # chunk , we must check if we should
 175         # still try to find valid memory (if we detected
 176         # the amount of available storage), and if we
 177         # have chunks left
 178         lghi  %r4,1
 179         sllg  %r4,%r4,31
 180         clgr  %r5,%r4
 181         je    .Lhsaskip
 182         xr    %r0, %r0
 183         clgr  %r0, %r9                   # did we detect memory?
 184         je    .Ldonemem                  # if not, leave
 185         chi   %r10, 0                    # do we have chunks left?
 186         je    .Ldonemem
 187 .Lhsaskip:
 188         algr  %r5,%r1                    # add 128KB to end of chunk
 189         lgr   %r4,%r5                    # potential new chunk
 190         clgr  %r5,%r9                    # should we go on?
 191         jl    .Lloop
 192 .Ldonemem:
 193
 194         larl  %r12,machine_flags
 195 #
 196 # find out if we are running under VM
 197 #
 198         stidp  __LC_CPUID               # store cpuid
 199         tm     __LC_CPUID,0xff          # running under VM ?
 200         bno    0f-.LPG1(%r13)
 201         oi     7(%r12),1                # set VM flag
 202 0:      lh     %r0,__LC_CPUID+4         # get cpu version
 203         chi    %r0,0x7490               # running on a P/390 ?
 204         bne    1f-.LPG1(%r13)
 205         oi     7(%r12),4                # set P/390 flag
 206 1:
 207
 208 #
 209 # find out if we have the MVPG instruction
 210 #
 211         la     %r1,0f-.LPG1(%r13)       # set program check address
 212         stg    %r1,__LC_PGM_NEW_PSW+8
 213         sgr    %r0,%r0
 214         lghi   %r1,0
 215         lghi   %r2,0
 216         mvpg   %r1,%r2                  # test MVPG instruction
 217         oi     7(%r12),16               # set MVPG flag
 218 0:
 219
 220 #
 221 # find out if the diag 0x44 works in 64 bit mode
 222 #
 223         la     %r1,0f-.LPG1(%r13)       # set program check address
 224         stg    %r1,__LC_PGM_NEW_PSW+8
 225         diag   0,0,0x44                 # test diag 0x44
 226         oi     7(%r12),32               # set diag44 flag
 227 0:
 228
 229 #
 230 # find out if we have the IDTE instruction
 231 #
 232         la     %r1,0f-.LPG1(%r13)       # set program check address
 233         stg    %r1,__LC_PGM_NEW_PSW+8
 234         .long   0xb2b10000              # store facility list
 235         tm      0xc8,0x08               # check bit for clearing-by-ASCE
 236         bno     0f-.LPG1(%r13)
 237         lhi     %r1,2094
 238         lhi     %r2,0
 239         .long   0xb98e2001
 240         oi      7(%r12),0x80            # set IDTE flag
 241 0:
 242
 243         lpswe .Lentry-.LPG1(13)         # jump to _stext in primary-space,
 244                                         # virtual and never return ...
 245         .align 16
 246 .Lentry:.quad  0x0000000180000000,_stext
 247 .Lctl:  .quad  0x04b50002               # cr0: various things
 248         .quad  0                        # cr1: primary space segment table
 249         .quad  .Lduct                   # cr2: dispatchable unit control table
 250         .quad  0                        # cr3: instruction authorization
 251         .quad  0                        # cr4: instruction authorization
 252         .quad  0xffffffffffffffff       # cr5: primary-aste origin
 253         .quad  0                        # cr6:  I/O interrupts
 254         .quad  0                        # cr7:  secondary space segment table
 255         .quad  0                        # cr8:  access registers translation
 256         .quad  0                        # cr9:  tracing off
 257         .quad  0                        # cr10: tracing off
 258         .quad  0                        # cr11: tracing off
 259         .quad  0                        # cr12: tracing off
 260         .quad  0                        # cr13: home space segment table
 261         .quad  0xc0000000               # cr14: machine check handling off
 262         .quad  0                        # cr15: linkage stack operations
 263 .Lduct: .long 0,0,0,0,0,0,0,0
 264         .long 0,0,0,0,0,0,0,0
 265 .Lpcmsk:.quad  0x0000000180000000
 266 .L4malign:.quad 0xffffffffffc00000
 267 .Lscan2g:.quad 0x80000000 + 0x20000 - 8 # 2GB + 128K - 8
 268 .Lnop:  .long  0x07000700
 269 .Lparmaddr:
 270         .quad   PARMAREA
 271
 272         .org    0x12000
 273 .globl s390_readinfo_sccb
 274 s390_readinfo_sccb:
 275 .Lsccb:
 276         .hword 0x1000                   # length, one page
 277         .byte 0x00,0x00,0x00
 278         .byte 0x80                      # variable response bit set
 279 .Lsccbr:
 280         .hword 0x00                     # response code
 281 .Lscpincr1:
 282         .hword 0x00
 283 .Lscpa1:
 284         .byte 0x00
 285         .fill 89,1,0
 286 .Lscpa2:
 287         .int 0x00
 288 .Lscpincr2:
 289         .quad 0x00
 290         .fill 3984,1,0
 291         .org    0x13000
 292
 293 #ifdef CONFIG_SHARED_KERNEL
 294         .org   0x100000
 295 #endif
 296
 297 #
 298 # startup-code, running in absolute addressing mode
 299 #
 300         .globl _stext
 301 _stext: basr  %r13,0                    # get base
 302 .LPG3:
 303 #
 304 # Setup stack
 305 #
 306         larl  %r15,init_thread_union
 307         lg    %r14,__TI_task(%r15)      # cache current in lowcore
 308         stg   %r14,__LC_CURRENT
 309         aghi  %r15,1<<(PAGE_SHIFT+THREAD_ORDER) # init_task_union + THREAD_SIZE
 310         stg   %r15,__LC_KERNEL_STACK    # set end of kernel stack
 311         aghi  %r15,-160
 312         xc    __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15) # clear backchain
 313
 314 # check control registers
 315         stctg  %c0,%c15,0(%r15)
 316         oi     6(%r15),0x40             # enable sigp emergency signal
 317         oi     4(%r15),0x10             # switch on low address proctection
 318         lctlg  %c0,%c15,0(%r15)
 319
 320 #
 321         lam    0,15,.Laregs-.LPG3(%r13) # load access regs needed by uaccess
 322         brasl  %r14,start_kernel        # go to C code
 323 #
 324 # We returned from start_kernel ?!? PANIK
 325 #
 326         basr  %r13,0
 327         lpswe .Ldw-.(%r13)           # load disabled wait psw
 328 #
 329             .align 8
 330 .Ldw:       .quad  0x0002000180000000,0x0000000000000000
 331 .Laregs:    .long  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0