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