arch/s390/kernel/head64.S

   1 /*
   2  *  arch/s390/kernel/head.S
   3  *
   4  *  S390 version
   5  *    Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
   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  *
  10  * There are 5 different IPL methods
  11  *  1) load the image directly into ram at address 0 and do an PSW restart
  12  *  2) linload will load the image from address 0x10000 to memory 0x10000
  13  *     and start the code thru LPSW 0x0008000080010000 (VM only, deprecated)
  14  *  3) generate the tape ipl header, store the generated image on a tape
  15  *     and ipl from it
  16  *     In case of SL tape you need to IPL 5 times to get past VOL1 etc
  17  *  4) generate the vm reader ipl header, move the generated image to the
  18  *     VM reader (use option NOH!) and do a ipl from reader (VM only)
  19  *  5) direct call of start by the SALIPL loader
  20  *  We use the cpuid to distinguish between VM and native ipl
  21  *  params for kernel are pushed to 0x10400 (see setup.h)
  22
  23     Changes:
  24     Okt 25 2000 <rvdheij@iae.nl>
  25         added code to skip HDR and EOF to allow SL tape IPL (5 retries)
  26         changed first CCW from rewind to backspace block
  27
  28  */
  29
  30 #include <linux/config.h>
  31 #include <asm/setup.h>
  32 #include <asm/lowcore.h>
  33 #include <asm/offsets.h>
  34
  35 #ifndef CONFIG_IPL
  36         .org   0
  37         .long  0x00080000,0x80000000+startup   # Just a restart PSW
  38 #else
  39 #ifdef CONFIG_IPL_TAPE
  40 #define IPL_BS 1024
  41         .org   0
  42         .long  0x00080000,0x80000000+iplstart  # The first 24 bytes are loaded
  43         .long  0x27000000,0x60000001           # by ipl to addresses 0-23.
  44         .long  0x02000000,0x20000000+IPL_BS    # (a PSW and two CCWs).
  45         .long  0x00000000,0x00000000           # external old psw
  46         .long  0x00000000,0x00000000           # svc old psw
  47         .long  0x00000000,0x00000000           # program check old psw
  48         .long  0x00000000,0x00000000           # machine check old psw
  49         .long  0x00000000,0x00000000           # io old psw
  50         .long  0x00000000,0x00000000
  51         .long  0x00000000,0x00000000
  52         .long  0x00000000,0x00000000
  53         .long  0x000a0000,0x00000058           # external new psw
  54         .long  0x000a0000,0x00000060           # svc new psw
  55         .long  0x000a0000,0x00000068           # program check new psw
  56         .long  0x000a0000,0x00000070           # machine check new psw
  57         .long  0x00080000,0x80000000+.Lioint   # io new psw
  58
  59         .org   0x100
  60 #
  61 # subroutine for loading from tape
  62 # Paramters:
  63 #  R1 = device number
  64 #  R2 = load address
  65 .Lloader:
  66         st    %r14,.Lldret
  67         la    %r3,.Lorbread                    # r3 = address of orb
  68         la    %r5,.Lirb                        # r5 = address of irb
  69         st    %r2,.Lccwread+4                  # initialize CCW data addresses
  70         lctl  %c6,%c6,.Lcr6
  71         slr   %r2,%r2
  72 .Lldlp:
  73         la    %r6,3                            # 3 retries
  74 .Lssch:
  75         ssch  0(%r3)                           # load chunk of IPL_BS bytes
  76         bnz   .Llderr
  77 .Lw4end:
  78         bas   %r14,.Lwait4io
  79         tm    8(%r5),0x82                      # do we have a problem ?
  80         bnz   .Lrecov
  81         slr   %r7,%r7
  82         icm   %r7,3,10(%r5)                    # get residual count
  83         lcr   %r7,%r7
  84         la    %r7,IPL_BS(%r7)                  # IPL_BS-residual=#bytes read
  85         ar    %r2,%r7                          # add to total size
  86         tm    8(%r5),0x01                      # found a tape mark ?
  87         bnz   .Ldone
  88         l     %r0,.Lccwread+4                  # update CCW data addresses
  89         ar    %r0,%r7
  90         st    %r0,.Lccwread+4
  91         b     .Lldlp
  92 .Ldone:
  93         l     %r14,.Lldret
  94         br    %r14                             # r2 contains the total size
  95 .Lrecov:
  96         bas   %r14,.Lsense                     # do the sensing
  97         bct   %r6,.Lssch                       # dec. retry count & branch
  98         b     .Llderr
  99 #
 100 # Sense subroutine
 101 #
 102 .Lsense:
 103         st    %r14,.Lsnsret
 104         la    %r7,.Lorbsense
 105         ssch  0(%r7)                           # start sense command
 106         bnz   .Llderr
 107         bas   %r14,.Lwait4io
 108         l     %r14,.Lsnsret
 109         tm    8(%r5),0x82                      # do we have a problem ?
 110         bnz   .Llderr
 111         br    %r14
 112 #
 113 # Wait for interrupt subroutine
 114 #
 115 .Lwait4io:
 116         lpsw  .Lwaitpsw
 117 .Lioint:
 118         c     %r1,0xb8                         # compare subchannel number
 119         bne   .Lwait4io
 120         tsch  0(%r5)
 121         slr   %r0,%r0
 122         tm    8(%r5),0x82                      # do we have a problem ?
 123         bnz   .Lwtexit
 124         tm    8(%r5),0x04                      # got device end ?
 125         bz    .Lwait4io
 126 .Lwtexit:
 127         br    %r14
 128 .Llderr:
 129         lpsw  .Lcrash
 130
 131         .align 8
 132 .Lorbread:
 133         .long  0x00000000,0x0080ff00,.Lccwread
 134         .align 8
 135 .Lorbsense:
 136         .long  0x00000000,0x0080ff00,.Lccwsense
 137         .align 8
 138 .Lccwread:
 139         .long  0x02200000+IPL_BS,0x00000000
 140 .Lccwsense:
 141         .long  0x04200001,0x00000000
 142 .Lwaitpsw:
 143         .long  0x020a0000,0x80000000+.Lioint
 144
 145 .Lirb:  .long  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
 146 .Lcr6:  .long  0xff000000
 147         .align 8
 148 .Lcrash:.long  0x000a0000,0x00000000
 149 .Lldret:.long  0
 150 .Lsnsret: .long 0
 151 #endif  /* CONFIG_IPL_TAPE */
 152
 153 #ifdef CONFIG_IPL_VM
 154 #define IPL_BS 0x730
 155         .org   0
 156         .long  0x00080000,0x80000000+iplstart  # The first 24 bytes are loaded
 157         .long  0x02000018,0x60000050           # by ipl to addresses 0-23.
 158         .long  0x02000068,0x60000050           # (a PSW and two CCWs).
 159         .fill  80-24,1,0x40                    # bytes 24-79 are discarded !!
 160         .long  0x020000f0,0x60000050           # The next 160 byte are loaded
 161         .long  0x02000140,0x60000050           # to addresses 0x18-0xb7
 162         .long  0x02000190,0x60000050           # They form the continuation
 163         .long  0x020001e0,0x60000050           # of the CCW program started
 164         .long  0x02000230,0x60000050           # by ipl and load the range
 165         .long  0x02000280,0x60000050           # 0x0f0-0x730 from the image
 166         .long  0x020002d0,0x60000050           # to the range 0x0f0-0x730
 167         .long  0x02000320,0x60000050           # in memory. At the end of
 168         .long  0x02000370,0x60000050           # the channel program the PSW
 169         .long  0x020003c0,0x60000050           # at location 0 is loaded.
 170         .long  0x02000410,0x60000050           # Initial processing starts
 171         .long  0x02000460,0x60000050           # at 0xf0 = iplstart.
 172         .long  0x020004b0,0x60000050
 173         .long  0x02000500,0x60000050
 174         .long  0x02000550,0x60000050
 175         .long  0x020005a0,0x60000050
 176         .long  0x020005f0,0x60000050
 177         .long  0x02000640,0x60000050
 178         .long  0x02000690,0x60000050
 179         .long  0x020006e0,0x20000050
 180
 181         .org   0xf0
 182 #
 183 # subroutine for loading cards from the reader
 184 #
 185 .Lloader:
 186         la    %r3,.Lorb                        # r2 = address of orb into r2
 187         la    %r5,.Lirb                        # r4 = address of irb
 188         la    %r6,.Lccws
 189         la    %r7,20
 190 .Linit:
 191         st    %r2,4(%r6)                       # initialize CCW data addresses
 192         la    %r2,0x50(%r2)
 193         la    %r6,8(%r6)
 194         bct   7,.Linit
 195
 196         lctl  %c6,%c6,.Lcr6                    # set IO subclass mask
 197         slr   %r2,%r2
 198 .Lldlp:
 199         ssch  0(%r3)                           # load chunk of 1600 bytes
 200         bnz   .Llderr
 201 .Lwait4irq:
 202         mvc   0x78(8),.Lnewpsw                 # set up IO interrupt psw
 203         lpsw  .Lwaitpsw
 204 .Lioint:
 205         c     %r1,0xb8                         # compare subchannel number
 206         bne   .Lwait4irq
 207         tsch  0(%r5)
 208
 209         slr   %r0,%r0
 210         ic    %r0,8(%r5)                       # get device status
 211         chi   %r0,8                            # channel end ?
 212         be    .Lcont
 213         chi   %r0,12                           # channel end + device end ?
 214         be    .Lcont
 215
 216         l     %r0,4(%r5)
 217         s     %r0,8(%r3)                       # r0/8 = number of ccws executed
 218         mhi   %r0,10                           # *10 = number of bytes in ccws
 219         lh    %r3,10(%r5)                      # get residual count
 220         sr    %r0,%r3                          # #ccws*80-residual=#bytes read
 221         ar    %r2,%r0
 222
 223         br    %r14                             # r2 contains the total size
 224
 225 .Lcont:
 226         ahi   %r2,0x640                        # add 0x640 to total size
 227         la    %r6,.Lccws
 228         la    %r7,20
 229 .Lincr:
 230         l     %r0,4(%r6)                       # update CCW data addresses
 231         ahi   %r0,0x640
 232         st    %r0,4(%r6)
 233         ahi   %r6,8
 234         bct   7,.Lincr
 235
 236         b     .Lldlp
 237 .Llderr:
 238         lpsw  .Lcrash
 239
 240         .align 8
 241 .Lorb:  .long  0x00000000,0x0080ff00,.Lccws
 242 .Lirb:  .long  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
 243 .Lcr6:  .long  0xff000000
 244 .Lloadp:.long  0,0
 245         .align 8
 246 .Lcrash:.long  0x000a0000,0x00000000
 247 .Lnewpsw:
 248         .long  0x00080000,0x80000000+.Lioint
 249 .Lwaitpsw:
 250         .long  0x020a0000,0x80000000+.Lioint
 251
 252         .align 8
 253 .Lccws: .rept  19
 254         .long  0x02600050,0x00000000
 255         .endr
 256         .long  0x02200050,0x00000000
 257 #endif  /* CONFIG_IPL_VM */
 258
 259 iplstart:
 260         lh    %r1,0xb8                         # test if subchannel number
 261         bct   %r1,.Lnoload                     #  is valid
 262         l     %r1,0xb8                         # load ipl subchannel number
 263         la    %r2,IPL_BS                       # load start address
 264         bas   %r14,.Lloader                    # load rest of ipl image
 265         larl  %r12,_pstart                     # pointer to parameter area
 266         st    %r1,IPL_DEVICE+4-PARMAREA(%r12)  # store ipl device number
 267
 268 #
 269 # load parameter file from ipl device
 270 #
 271 .Lagain1:
 272         l     %r2,INITRD_START+4-PARMAREA(%r12)# use ramdisk location as temp
 273         bas   %r14,.Lloader                    # load parameter file
 274         ltr   %r2,%r2                          # got anything ?
 275         bz    .Lnopf
 276         chi   %r2,895
 277         bnh   .Lnotrunc
 278         la    %r2,895
 279 .Lnotrunc:
 280         l     %r4,INITRD_START+4-PARMAREA(%r12)
 281         clc   0(3,%r4),.L_hdr                  # if it is HDRx
 282         bz    .Lagain1                         # skip dataset header
 283         clc   0(3,%r4),.L_eof                  # if it is EOFx
 284         bz    .Lagain1                         # skip dateset trailer
 285         la    %r5,0(%r4,%r2)
 286         lr    %r3,%r2
 287 .Lidebc:
 288         tm    0(%r5),0x80                      # high order bit set ?
 289         bo    .Ldocv                           #  yes -> convert from EBCDIC
 290         ahi   %r5,-1
 291         bct   %r3,.Lidebc
 292         b     .Lnocv
 293 .Ldocv:
 294         l     %r3,.Lcvtab
 295         tr    0(256,%r4),0(%r3)                # convert parameters to ascii
 296         tr    256(256,%r4),0(%r3)
 297         tr    512(256,%r4),0(%r3)
 298         tr    768(122,%r4),0(%r3)
 299 .Lnocv: la    %r3,COMMAND_LINE-PARMAREA(%r12)  # load adr. of command line
 300         mvc   0(256,%r3),0(%r4)
 301         mvc   256(256,%r3),256(%r4)
 302         mvc   512(256,%r3),512(%r4)
 303         mvc   768(122,%r3),768(%r4)
 304         slr   %r0,%r0
 305         b     .Lcntlp
 306 .Ldelspc:
 307         ic    %r0,0(%r2,%r3)
 308         chi   %r0,0x20                         # is it a space ?
 309         be    .Lcntlp
 310         ahi   %r2,1
 311         b     .Leolp
 312 .Lcntlp:
 313         brct  %r2,.Ldelspc
 314 .Leolp:
 315         slr   %r0,%r0
 316         stc   %r0,0(%r2,%r3)                   # terminate buffer
 317 .Lnopf:
 318
 319 #
 320 # load ramdisk from ipl device
 321 #
 322 .Lagain2:
 323         l     %r2,INITRD_START+4-PARMAREA(%r12)# load adr. of ramdisk
 324         bas   %r14,.Lloader                    # load ramdisk
 325         st    %r2,INITRD_SIZE+4-PARMAREA(%r12) # store size of ramdisk
 326         ltr   %r2,%r2
 327         bnz   .Lrdcont
 328         st    %r2,INITRD_START+4-PARMAREA(%r12)# no ramdisk found, null it
 329 .Lrdcont:
 330         l     %r2,INITRD_START+4-PARMAREA(%r12)
 331         clc   0(3,%r2),.L_hdr                  # skip HDRx and EOFx
 332         bz    .Lagain2
 333         clc   0(3,%r2),.L_eof
 334         bz    .Lagain2
 335
 336 #ifdef CONFIG_IPL_VM
 337 #
 338 # reset files in VM reader
 339 #
 340         stidp __LC_CPUID                       # store cpuid
 341         tm    __LC_CPUID,0xff                  # running VM ?
 342         bno   .Lnoreset
 343         la    %r2,.Lreset
 344         lhi   %r3,26
 345         .long 0x83230008
 346 .Lnoreset:
 347 #endif
 348
 349 #
 350 # everything loaded, go for it
 351 #
 352 .Lnoload:
 353         l     %r1,.Lstartup
 354         br    %r1
 355
 356 .Lstartup: .long startup
 357 .Lcvtab:.long  _ebcasc                         # ebcdic to ascii table
 358 .Lreset:.byte  0xc3,0xc8,0xc1,0xd5,0xc7,0xc5,0x40,0xd9,0xc4,0xd9,0x40
 359         .byte  0xc1,0xd3,0xd3,0x40,0xd2,0xc5,0xc5,0xd7,0x40,0xd5,0xd6
 360         .byte  0xc8,0xd6,0xd3,0xc4             # "change rdr all keep nohold"
 361 .L_eof: .long  0xc5d6c600       /* C'EOF' */
 362 .L_hdr: .long  0xc8c4d900       /* C'HDR' */
 363 #endif  /* CONFIG_IPL */
 364
 365 #
 366 # SALIPL loader support. Based on a patch by Rob van der Heij.
 367 # This entry point is called directly from the SALIPL loader and
 368 # doesn't need a builtin ipl record.
 369 #
 370         .org  0x800
 371         .globl start
 372 start:
 373         stm   %r0,%r15,0x07b0           # store registers
 374         basr  %r12,%r0
 375 .base:
 376         l     %r11,.parm
 377         l     %r8,.cmd                  # pointer to command buffer
 378
 379         ltr   %r9,%r9                   # do we have SALIPL parameters?
 380         bp    .sk8x8
 381
 382         mvc   0(64,%r8),0x00b0          # copy saved registers
 383         xc    64(240-64,%r8),0(%r8)     # remainder of buffer
 384         tr    0(64,%r8),.lowcase
 385         b     .gotr
 386 .sk8x8:
 387         mvc   0(240,%r8),0(%r9)         # copy iplparms into buffer
 388 .gotr:
 389         l     %r10,.tbl                 # EBCDIC to ASCII table
 390         tr    0(240,%r8),0(%r10)
 391         stidp __LC_CPUID                # Are we running on VM maybe
 392         cli   __LC_CPUID,0xff
 393         bnz   .test
 394         .long 0x83300060                # diag 3,0,x'0060' - storage size
 395         b     .done
 396 .test:
 397         mvc   0x68(8),.pgmnw            # set up pgm check handler
 398         l     %r2,.fourmeg
 399         lr    %r3,%r2
 400         bctr  %r3,%r0                   # 4M-1
 401 .loop:  iske  %r0,%r3
 402         ar    %r3,%r2
 403 .pgmx:
 404         sr    %r3,%r2
 405         la    %r3,1(%r3)
 406 .done:
 407         l     %r1,.memsize
 408         st    %r3,4(%r1)
 409         slr   %r0,%r0
 410         st    %r0,INITRD_SIZE+4-PARMAREA(%r11)
 411         st    %r0,INITRD_START+4-PARMAREA(%r11)
 412         j     startup                   # continue with startup
 413 .tbl:   .long _ebcasc                   # translate table
 414 .cmd:   .long COMMAND_LINE              # address of command line buffer
 415 .parm:  .long PARMAREA
 416 .fourmeg: .long 0x00400000              # 4M
 417 .pgmnw: .long 0x00080000,.pgmx
 418 .memsize: .long memory_size
 419 .lowcase:
 420         .byte 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07
 421         .byte 0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f
 422         .byte 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17
 423         .byte 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f
 424         .byte 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27
 425         .byte 0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f
 426         .byte 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37
 427         .byte 0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f
 428         .byte 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47
 429         .byte 0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f
 430         .byte 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57
 431         .byte 0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f
 432         .byte 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67
 433         .byte 0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f
 434         .byte 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77
 435         .byte 0x78,0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f
 436
 437         .byte 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87
 438         .byte 0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f
 439         .byte 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97
 440         .byte 0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f
 441         .byte 0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7
 442         .byte 0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf
 443         .byte 0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7
 444         .byte 0xb8,0xb9,0xba,0xbb,0xbc,0xbd,0xbe,0xbf
 445         .byte 0xc0,0x81,0x82,0x83,0x84,0x85,0x86,0x87   # .abcdefg
 446         .byte 0x88,0x89,0xca,0xcb,0xcc,0xcd,0xce,0xcf   # hi
 447         .byte 0xd0,0x91,0x92,0x93,0x94,0x95,0x96,0x97   # .jklmnop
 448         .byte 0x98,0x99,0xda,0xdb,0xdc,0xdd,0xde,0xdf   # qr
 449         .byte 0xe0,0xe1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7   # ..stuvwx
 450         .byte 0xa8,0xa9,0xea,0xeb,0xec,0xed,0xee,0xef   # yz
 451         .byte 0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7
 452         .byte 0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xff
 453
 454 #
 455 # startup-code at 0x10000, running in real mode
 456 # this is called either by the ipl loader or directly by PSW restart
 457 # or linload or SALIPL
 458 #
 459         .org  0x10000
 460 startup:basr  %r13,0                     # get base
 461 .LPG1:  sll   %r13,1                     # remove high order bit
 462         srl   %r13,1
 463         lhi   %r1,1                      # mode 1 = esame
 464         slr   %r0,%r0                    # set cpuid to zero
 465         sigp  %r1,%r0,0x12               # switch to esame mode
 466         sam64                            # switch to 64 bit mode
 467         lctlg %c0,%c15,.Lctl-.LPG1(%r13) # load control registers
 468         larl  %r12,_pstart               # pointer to parameter area
 469                                          # move IPL device to lowcore
 470         mvc   __LC_IPLDEV(4),IPL_DEVICE+4-PARMAREA(%r12)
 471
 472 #
 473 # clear bss memory
 474 #
 475         larl  %r2,__bss_start           # start of bss segment
 476         larl  %r3,_end                  # end of bss segment
 477         sgr   %r3,%r2                   # length of bss
 478         sgr   %r4,%r4                   #
 479         sgr   %r5,%r5                   # set src,length and pad to zero
 480         mvcle %r2,%r4,0                 # clear mem
 481         jo    .-4                       # branch back, if not finish
 482
 483         l     %r2,.Lrcp-.LPG1(%r13)     # Read SCP forced command word
 484 .Lservicecall:
 485         stosm .Lpmask-.LPG1(%r13),0x01  # authorize ext interrupts
 486
 487         stctg %r0,%r0,.Lcr-.LPG1(%r13)  # get cr0
 488         la    %r1,0x200                 # set bit 22
 489         og    %r1,.Lcr-.LPG1(%r13)      # or old cr0 with r1
 490         stg   %r1,.Lcr-.LPG1(%r13)
 491         lctlg %r0,%r0,.Lcr-.LPG1(%r13)  # load modified cr0
 492
 493         mvc   __LC_EXT_NEW_PSW(8),.Lpcmsk-.LPG1(%r13) # set postcall psw
 494         larl  %r1,.Lsclph
 495         stg   %r1,__LC_EXT_NEW_PSW+8    # set handler
 496
 497         larl  %r4,_pstart               # %r4 is our index for sccb stuff
 498         la    %r1,.Lsccb-PARMAREA(%r4)  # our sccb
 499         .insn rre,0xb2200000,%r2,%r1    # service call
 500         ipm   %r1
 501         srl   %r1,28                    # get cc code
 502         xr    %r3,%r3
 503         chi   %r1,3
 504         be    .Lfchunk-.LPG1(%r13)      # leave
 505         chi   %r1,2
 506         be    .Lservicecall-.LPG1(%r13)
 507         lpsw  .Lwaitsclp-.LPG1(%r13)
 508 .Lsclph:
 509         lh    %r1,.Lsccbr-PARMAREA(%r4)
 510         chi   %r1,0x10                  # 0x0010 is the sucess code
 511         je    .Lprocsccb                # let's process the sccb
 512         chi   %r1,0x1f0
 513         bne   .Lfchunk-.LPG1(%r13)      # unhandled error code
 514         c     %r2,.Lrcp-.LPG1(%r13)     # Did we try Read SCP forced
 515         bne   .Lfchunk-.LPG1(%r13)      # if no, give up
 516         l     %r2,.Lrcp2-.LPG1(%r13)    # try with Read SCP
 517         b     .Lservicecall-.LPG1(%r13)
 518 .Lprocsccb:
 519         lh    %r1,.Lscpincr1-PARMAREA(%r4) # use this one if != 0
 520         chi   %r1,0x00
 521         jne   .Lscnd
 522         lg    %r1,.Lscpincr2-PARMAREA(%r4) # otherwise use this one
 523 .Lscnd:
 524         xr    %r3,%r3                   # same logic
 525         ic    %r3,.Lscpa1-PARMAREA(%r4)
 526         chi   %r3,0x00
 527         jne   .Lcompmem
 528         l     %r3,.Lscpa2-PARMAREA(%r13)
 529 .Lcompmem:
 530         mlgr  %r2,%r1                   # mem in MB on 128-bit
 531         l     %r1,.Lonemb-.LPG1(%r13)
 532         mlgr  %r2,%r1                   # mem size in bytes in %r3
 533         b     .Lfchunk-.LPG1(%r13)
 534
 535 .Lpmask:
 536         .byte 0
 537         .align 8
 538 .Lcr:
 539         .quad 0x00  # place holder for cr0
 540 .Lwaitsclp:
 541         .long 0x020A0000
 542         .quad .Lsclph
 543 .Lrcp:
 544         .int 0x00120001 # Read SCP forced code
 545 .Lrcp2:
 546         .int 0x00020001 # Read SCP code
 547 .Lonemb:
 548         .int 0x100000
 549
 550 .Lfchunk:
 551                                          # set program check new psw mask
 552         mvc   __LC_PGM_NEW_PSW(8),.Lpcmsk-.LPG1(%r13)
 553
 554 #
 555 # find memory chunks.
 556 #
 557         lgr   %r9,%r3                    # end of mem
 558         larl  %r1,.Lchkmem               # set program check address
 559         stg   %r1,__LC_PGM_NEW_PSW+8
 560         la    %r1,1                      # test in increments of 128KB
 561         sllg  %r1,%r1,17
 562         larl  %r3,memory_chunk
 563         slgr  %r4,%r4                    # set start of chunk to zero
 564         slgr  %r5,%r5                    # set end of chunk to zero
 565         slr  %r6,%r6                     # set access code to zero
 566         la    %r10,MEMORY_CHUNKS         # number of chunks
 567 .Lloop:
 568         tprot 0(%r5),0                   # test protection of first byte
 569         ipm   %r7
 570         srl   %r7,28
 571         clr   %r6,%r7                    # compare cc with last access code
 572         je    .Lsame
 573         j     .Lchkmem
 574 .Lsame:
 575         algr  %r5,%r1                    # add 128KB to end of chunk
 576                                          # no need to check here,
 577         brc   12,.Lloop                  # this is the same chunk
 578 .Lchkmem:                                # > 16EB or tprot got a program check
 579         clgr  %r4,%r5                    # chunk size > 0?
 580         je    .Lchkloop
 581         stg   %r4,0(%r3)                 # store start address of chunk
 582         lgr   %r0,%r5
 583         slgr  %r0,%r4
 584         stg   %r0,8(%r3)                 # store size of chunk
 585         st    %r6,20(%r3)                # store type of chunk
 586         la    %r3,24(%r3)
 587         larl  %r8,memory_size
 588         stg   %r5,0(%r8)                 # store memory size
 589         ahi   %r10,-1                    # update chunk number
 590 .Lchkloop:
 591         lr    %r6,%r7                    # set access code to last cc
 592         # we got an exception or we're starting a new
 593         # chunk , we must check if we should
 594         # still try to find valid memory (if we detected
 595         # the amount of available storage), and if we
 596         # have chunks left
 597         lghi  %r4,1
 598         sllg  %r4,%r4,31
 599         clgr  %r5,%r4
 600         je    .Lhsaskip
 601         xr    %r0, %r0
 602         clgr  %r0, %r9                   # did we detect memory?
 603         je    .Ldonemem                  # if not, leave
 604         chi   %r10, 0                    # do we have chunks left?
 605         je    .Ldonemem
 606 .Lhsaskip:
 607         algr  %r5,%r1                    # add 128KB to end of chunk
 608         lgr   %r4,%r5                    # potential new chunk
 609         clgr  %r5,%r9                    # should we go on?
 610         jl    .Lloop
 611 .Ldonemem:
 612
 613         larl  %r12,machine_flags
 614 #
 615 # find out if we are running under VM
 616 #
 617         stidp  __LC_CPUID               # store cpuid
 618         tm     __LC_CPUID,0xff          # running under VM ?
 619         bno    0f-.LPG1(%r13)
 620         oi     7(%r12),1                # set VM flag
 621 0:      lh     %r0,__LC_CPUID+4         # get cpu version
 622         chi    %r0,0x7490               # running on a P/390 ?
 623         bne    1f-.LPG1(%r13)
 624         oi     7(%r12),4                # set P/390 flag
 625 1:
 626         chi    %r0,0x2084               # new stidp format?
 627         bne    2f-.LPG1(%r13)
 628         oi     7(%r12),64               # set new stidp flag
 629 2:
 630
 631 #
 632 # find out if we have the MVPG instruction
 633 #
 634         la     %r1,0f-.LPG1(%r13)       # set program check address
 635         stg    %r1,__LC_PGM_NEW_PSW+8
 636         sgr    %r0,%r0
 637         lghi   %r1,0
 638         lghi   %r2,0
 639         mvpg   %r1,%r2                  # test MVPG instruction
 640         oi     7(%r12),16               # set MVPG flag
 641 0:
 642
 643 #
 644 # find out if the diag 0x44 works in 64 bit mode
 645 #
 646         la     %r1,0f-.LPG1(%r13)       # set program check address
 647         stg    %r1,__LC_PGM_NEW_PSW+8
 648         mvc    __LC_DIAG44_OPCODE(8),.Lnop-.LPG1(%r13)
 649         diag   0,0,0x44                 # test diag 0x44
 650         oi     7(%r12),32               # set diag44 flag
 651         mvc    __LC_DIAG44_OPCODE(8),.Ldiag44-.LPG1(%r13)
 652 0:
 653
 654 #
 655 # find out if we have the IDTE instruction
 656 #
 657         la     %r1,0f-.LPG1(%r13)       # set program check address
 658         stg    %r1,__LC_PGM_NEW_PSW+8
 659         .long   0xb2b10000              # store facility list
 660         tm      0xc8,0x08               # check bit for clearing-by-ASCE
 661         bno     0f-.LPG1(%r13)
 662         lhi     %r1,2094
 663         lhi     %r2,0
 664         .long   0xb98e2001
 665         oi      7(%r12),0x80            # set IDTE flag
 666 0:
 667
 668         lpswe .Lentry-.LPG1(13)         # jump to _stext in primary-space,
 669                                         # virtual and never return ...
 670         .align 16
 671 .Lentry:.quad  0x0000000180000000,_stext
 672 .Lctl:  .quad  0x04b50002               # cr0: various things
 673         .quad  0                        # cr1: primary space segment table
 674         .quad  .Lduct                   # cr2: dispatchable unit control table
 675         .quad  0                        # cr3: instruction authorization
 676         .quad  0                        # cr4: instruction authorization
 677         .quad  0xffffffffffffffff       # cr5: primary-aste origin
 678         .quad  0                        # cr6:  I/O interrupts
 679         .quad  0                        # cr7:  secondary space segment table
 680         .quad  0                        # cr8:  access registers translation
 681         .quad  0                        # cr9:  tracing off
 682         .quad  0                        # cr10: tracing off
 683         .quad  0                        # cr11: tracing off
 684         .quad  0                        # cr12: tracing off
 685         .quad  0                        # cr13: home space segment table
 686         .quad  0xc0000000               # cr14: machine check handling off
 687         .quad  0                        # cr15: linkage stack operations
 688 .Lpcmsk:.quad  0x0000000180000000
 689 .L4malign:.quad 0xffffffffffc00000
 690 .Lscan2g:.quad 0x80000000 + 0x20000 - 8 # 2GB + 128K - 8
 691 .Lnop:  .long  0x07000700
 692 .Ldiag44:.long 0x83000044
 693
 694         .org PARMAREA-64
 695 .Lduct: .long 0,0,0,0,0,0,0,0
 696         .long 0,0,0,0,0,0,0,0
 697
 698 #
 699 # params at 10400 (setup.h)
 700 #
 701         .org   PARMAREA
 702         .global _pstart
 703 _pstart:
 704         .quad  0                        # IPL_DEVICE
 705         .quad  RAMDISK_ORIGIN           # INITRD_START
 706         .quad  RAMDISK_SIZE             # INITRD_SIZE
 707
 708         .org   COMMAND_LINE
 709         .byte  "root=/dev/ram0 ro"
 710         .byte  0
 711         .org   0x11000
 712 .Lsccb:
 713         .hword 0x1000                   # length, one page
 714         .byte 0x00,0x00,0x00
 715         .byte 0x80                      # variable response bit set
 716 .Lsccbr:
 717         .hword 0x00                     # response code
 718 .Lscpincr1:
 719         .hword 0x00
 720 .Lscpa1:
 721         .byte 0x00
 722         .fill 89,1,0
 723 .Lscpa2:
 724         .int 0x00
 725 .Lscpincr2:
 726         .quad 0x00
 727         .fill 3984,1,0
 728         .org 0x12000
 729         .global _pend
 730 _pend:
 731
 732 #ifdef CONFIG_SHARED_KERNEL
 733         .org   0x100000
 734 #endif
 735
 736 #
 737 # startup-code, running in virtual mode
 738 #
 739         .globl _stext
 740 _stext: basr  %r13,0                    # get base
 741 .LPG2:
 742 #
 743 # Setup stack
 744 #
 745         larl  %r15,init_thread_union
 746         lg    %r14,__TI_task(%r15)      # cache current in lowcore
 747         stg   %r14,__LC_CURRENT
 748         aghi  %r15,16384                # init_task_union + 16384
 749         stg   %r15,__LC_KERNEL_STACK    # set end of kernel stack
 750         aghi  %r15,-160
 751         xc    0(8,%r15),0(%r15)         # set backchain to zero
 752
 753 # check control registers
 754         stctg  %c0,%c15,0(%r15)
 755         oi     6(%r15),0x20             # enable sigp external interrupts
 756         oi     4(%r15),0x10             # switch on low address proctection
 757         lctlg  %c0,%c15,0(%r15)
 758
 759 #
 760         lam    0,15,.Laregs-.LPG2(%r13) # load access regs needed by uaccess
 761         brasl  %r14,start_kernel        # go to C code
 762 #
 763 # We returned from start_kernel ?!? PANIK
 764 #
 765         basr  %r13,0
 766         lpswe .Ldw-.(%r13)           # load disabled wait psw
 767 #
 768             .align 8
 769 .Ldw:       .quad  0x0002000180000000,0x0000000000000000
 770 .Laregs:    .long  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
 771