head.s

Linux内核源代码 为压缩文件 是<<Linux内核>>一书中的源代码

/*
 *  arch/s390/kernel/head.S
 *
 *  S390 version
 *    Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
 *    Author(s): Hartmut Penner ([e-mail]),
 *               Martin Schwidefsky ([e-mail]),
 *
 * There are 4 different IPL methods
 *  1) load the image directly into ram at address 0 and do an PSW restart
 *  2) linload will load the image from address 0x10000 to memory 0x10000
 *     and start the code thru LPSW 0x0008000080010000 (VM only, deprecated)
 *  3) generate the tape ipl header, store the generated image on a tape
 *     and ipl from it
 *  4) generate the vm reader ipl header, move the generated image to the
 *     VM reader (use option NOH!) and do a ipl from reader (VM only)
 *  We use the cpuid to distinguish between VM and native ipl
 *  params for kernel are pushed to 0x10400 (see setup.h)
 */

#include <linux/config.h>
#include <asm/setup.h>
#include <asm/lowcore.h>

#ifndef CONFIG_IPL
        .org   0
        .long  0x00080000,0x80000000+iplstart  # Just a restart PSW

iplstart:
        l     %r12,.Lparm                      # pointer to parameter area
#
# find out memory size
#
        mvc   104(8,0),.Lpcmem0          # setup program check handler
        slr   %r2,%r2
        lhi   %r3,1
        sll   %r3,20
.Lloop0:
        l     %r0,0(%r2)                 # test page
        ar    %r2,%r3                    # add 1M
        jnm   .Lloop0                    # r1 < 0x80000000 -> loop
.Lchkmem0:
        n     %r2,.L4malign0             # align to multiples of 4M
        st    %r2,MEMORY_SIZE-PARMAREA(%r12)  # store memory size
        slr   %r2,%r2
        st    %r2,INITRD_SIZE-PARMAREA(%r12)  # null ramdisk
        st    %r2,INITRD_START-PARMAREA(%r12)
        j     start

.Lparm: .long  PARMAREA
.L4malign0:.long 0xffc00000
        .align 8
.Lpcmem0:.long  0x00080000,0x80000000 + .Lchkmem0

#else
#ifdef CONFIG_IPL_TAPE
#define IPL_BS 1024
        .org   0
        .long  0x00080000,0x80000000+iplstart  # The first 24 bytes are loaded
        .long  0x07000000,0x60000001           # by ipl to addresses 0-23.
        .long  0x02000000,0x20000000+IPL_BS    # (a PSW and two CCWs).
        .long  0x00000000,0x00000000           # external old psw
        .long  0x00000000,0x00000000           # svc old psw
        .long  0x00000000,0x00000000           # program check old psw
        .long  0x00000000,0x00000000           # machine check old psw
        .long  0x00000000,0x00000000           # io old psw
        .long  0x00000000,0x00000000
        .long  0x00000000,0x00000000
        .long  0x00000000,0x00000000
        .long  0x000a0000,0x00000058           # external new psw
        .long  0x000a0000,0x00000060           # svc new psw
        .long  0x000a0000,0x00000068           # program check new psw
        .long  0x000a0000,0x00000070           # machine check new psw
        .long  0x00080000,0x80000000+.Lioint   # io new psw

        .org   0x100
iplstart:
	l     %r1,0xb8                         # load ipl subchannel number
        lhi   %r2,IPL_BS                       # load start address
        bras  %r14,.Lloader                    # load rest of ipl image
        st    %r1,__LC_IPLDEV                  # store ipl device number
        l     %r12,.Lparm                      # pointer to parameter area

#
# find out memory size
#
        mvc   104(8,0),.Lpcmem0          # setup program check handler
        slr   %r2,%r2
        lhi   %r3,1
        sll   %r3,20
.Lloop0:
        l     %r0,0(%r2)                 # test page
        ar    %r2,%r3                    # add 1M
        jnm   .Lloop0                    # r1 < 0x80000000 -> loop
.Lchkmem0:
        n     %r2,.L4malign0             # align to multiples of 4M
        st    %r2,MEMORY_SIZE-PARMAREA(%r12)  # store memory size
        c     %r2,.Lbigmem               # more than 64 MB of memory ?
        jl    .Lmemok                    # if yes load ramdisk to 32 MB
        mvc   INITRD_START-PARMAREA(4,%r12),.Lrdstart
.Lmemok:

#
# load parameter file from tape
#
 	l     %r2,INITRD_START-PARMAREA(%r12)  # use ramdisk location as temp
        bras  %r14,.Lloader                    # load parameter file
        ltr   %r2,%r2                          # got anything ?
        jz    .Lnopf
	chi   %r2,895
	jnh   .Lnotrunc
	lhi   %r2,895
.Lnotrunc:
        l     %r4,INITRD_START-PARMAREA(%r12)
        la    %r5,0(%r4,%r2)
        lr    %r3,%r2
.Lidebc:
        tm    0(%r5),0x80                      # high order bit set ?
        jo    .Ldocv                           #  yes -> convert from EBCDIC
        ahi   %r5,-1
        brct  %r3,.Lidebc
        j     .Lnocv
.Ldocv:
        l     %r3,.Lcvtab
        tr    0(256,%r4),0(%r3)                # convert parameters to ascii
        tr    256(256,%r4),0(%r3)
        tr    512(256,%r4),0(%r3)
        tr    768(122,%r4),0(%r3)
.Lnocv: la    %r3,COMMAND_LINE-PARMAREA(%r12)  # load adr. of command line
	mvc   0(256,%r3),0(%r4)
	mvc   256(256,%r3),256(%r4)
	mvc   512(256,%r3),512(%r4)
	mvc   768(122,%r3),768(%r4)
        slr   %r0,%r0
        j     .Lcntlp
.Ldelspc:
        ic    %r0,0(%r2,%r3)
        chi   %r0,0x20                         # is it a space ?
        je    .Lcntlp
        ahi   %r2,1
        j     .Leolp
.Lcntlp:
        brct  %r2,.Ldelspc
.Leolp:
        slr   %r0,%r0
        stc   %r0,0(%r2,%r3)                   # terminate buffer
.Lnopf:

#
# load ramdisk from tape
#	
 	l     %r2,INITRD_START-PARMAREA(%r12)  # load adr. of ramdisk
        bras  %r14,.Lloader                    # load ramdisk
 	st    %r2,INITRD_SIZE-PARMAREA(%r12)   # store size of ramdisk
        ltr   %r2,%r2
        jnz   .Lrdcont
        st    %r2,INITRD_START-PARMAREA(%r12)  # no ramdisk found, null it
.Lrdcont:
#
# everything loaded, go for it
#
        j     start
#
# subroutine for loading from tape
# Paramters:	
#  R1 = device number
#  R2 = load address
.Lloader:	
        st    %r14,.Lldret
        la    %r3,.Lorbread                    # r3 = address of orb 
	la    %r5,.Lirb                        # r5 = address of irb
        st    %r2,.Lccwread+4                  # initialize CCW data addresses
        lctl  %c6,%c6,.Lcr6               
        slr   %r2,%r2
.Lldlp:
        lhi   %r6,3                            # 3 retries
.Lssch:
        ssch  0(%r3)                           # load chunk of IPL_BS bytes
        jnz   .Llderr
.Lw4end:
        bras  %r14,.Lwait4io
        tm    8(%r5),0x82                      # do we have a problem ?
        jnz   .Lrecov
        slr   %r7,%r7
        icm   %r7,3,10(%r5)                    # get residual count
        lcr   %r7,%r7
        ahi   %r7,IPL_BS                       # IPL_BS-residual=#bytes read
        ar    %r2,%r7                          # add to total size
        tm    8(%r5),0x01                      # found a tape mark ?
        jnz   .Ldone
        l     %r0,.Lccwread+4                  # update CCW data addresses
        ar    %r0,%r7
        st    %r0,.Lccwread+4                
        j     .Lldlp
.Ldone:
        l     %r14,.Lldret
        br    %r14                             # r2 contains the total size
.Lrecov:
        bras  %r14,.Lsense                     # do the sensing
        brct  %r6,.Lssch                       # dec. retry count & branch
        j     .Llderr
#
# Sense subroutine
#
.Lsense:
        st    %r14,.Lsnsret
        la    %r7,.Lorbsense              
        ssch  0(%r7)                           # start sense command
        jnz   .Llderr
        bras  %r14,.Lwait4io
        l     %r14,.Lsnsret
        tm    8(%r5),0x82                      # do we have a problem ?
        jnz   .Llderr
        br    %r14
#
# Wait for interrupt subroutine
#
.Lwait4io:
        lpsw  .Lwaitpsw                 
.Lioint:
        c     %r1,0xb8                         # compare subchannel number
        jne   .Lwait4io
        tsch  0(%r5)
        slr   %r0,%r0
        tm    8(%r5),0x82                      # do we have a problem ?
        jnz   .Lwtexit
        tm    8(%r5),0x04                      # got device end ?
        jz    .Lwait4io
.Lwtexit:
        br    %r14
.Llderr:
        lpsw  .Lcrash              

        .align 8
.Lorbread:
	.long  0x00000000,0x0080ff00,.Lccwread
        .align 8
.Lorbsense:
        .long  0x00000000,0x0080ff00,.Lccwsense
        .align 8
.Lccwread:
        .long  0x02200000+IPL_BS,0x00000000
.Lccwsense:
        .long  0x04200001,0x00000000
.Lwaitpsw:
	.long  0x020a0000,0x80000000+.Lioint

.Lirb:	.long  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
.Lcr6:  .long  0xff000000
        .align 8
.Lcrash:.long  0x000a0000,0x00000000
.Lpcmem0:.long  0x00080000,0x80000000 + .Lchkmem0
.Lparm: .long  PARMAREA
.L4malign0:.long 0xffc00000
.Lbigmem:.long 0x04000000
.Lrdstart:.long 0x02000000
.Lldret:.long  0
.Lsnsret: .long 0
.Lcvtab:.long  _ebcasc                         # ebcdic to ascii table

#endif  /* CONFIG_IPL_TAPE */

#ifdef CONFIG_IPL_VM
        .org   0
        .long  0x00080000,0x80000000+iplstart  # The first 24 bytes are loaded
        .long  0x02000018,0x60000050           # by ipl to addresses 0-23.
        .long  0x02000068,0x60000050           # (a PSW and two CCWs).
        .fill  80-24,1,0x40                    # bytes 24-79 are discarded !!
        .long  0x020000f0,0x60000050           # The next 160 byte are loaded
        .long  0x02000140,0x60000050           # to addresses 0x18-0xb7
        .long  0x02000190,0x60000050           # They form the continuation
        .long  0x020001e0,0x60000050           # of the CCW program started
        .long  0x02000230,0x60000050           # by ipl and load the range
        .long  0x02000280,0x60000050           # 0x0f0-0x730 from the image
        .long  0x020002d0,0x60000050           # to the range 0x0f0-0x730
        .long  0x02000320,0x60000050           # in memory. At the end of
        .long  0x02000370,0x60000050           # the channel program the PSW
        .long  0x020003c0,0x60000050           # at location 0 is loaded.
        .long  0x02000410,0x60000050           # Initial processing starts
        .long  0x02000460,0x60000050           # at 0xf0 = iplstart.
        .long  0x020004b0,0x60000050
        .long  0x02000500,0x60000050
        .long  0x02000550,0x60000050
        .long  0x020005a0,0x60000050
        .long  0x020005f0,0x60000050
        .long  0x02000640,0x60000050
        .long  0x02000690,0x60000050
        .long  0x020006e0,0x20000050


        .org   0xf0
iplstart:
	l     %r1,0xb8                         # load ipl subchannel number
        lhi   %r2,0x730                        # load start address
        bras  %r14,.Lloader                    # load rest of ipl image
        st    %r1,__LC_IPLDEV                  # store ipl device number
	l     %r12,.Lparm                      # pointer to parameter area

#
# find out memory size
#
        mvc   104(8,0),.Lpcmem0           # setup program check handler
        slr   %r2,%r2
        lhi   %r3,1
        sll   %r3,20
.Lloop0:
        l     %r0,0(%r2)                 # test page
        ar    %r2,%r3                    # add 1M
        jnm   .Lloop0                    # r1 < 0x80000000 -> loop
.Lchkmem0:
        n     %r2,.L4malign0             # align to multiples of 4M
        st    %r2,MEMORY_SIZE-PARMAREA(%r12)  # store memory size
        c     %r2,.Lbigmem               # more than 64 MB of memory ?
        jl    .Lmemok                    # if yes load ramdisk to 32 MB
        mvc   INITRD_START-PARMAREA(4,%r12),.Lrdstart
.Lmemok:

#
# load parameter file from reader
#
        l     %r2,INITRD_START-PARMAREA(%r12)  # use ramdisk location as temp
        bras  %r14,.Lloader                    # load parameter file
        ltr   %r2,%r2                          # got anything ?
        jz    .Lnopf
        chi   %r2,895
        jnh   .Lnotrunc
        lhi   %r2,895
.Lnotrunc:
        l     %r4,INITRD_START-PARMAREA(%r12)
        la    %r5,0(%r4,%r2)
        lr    %r3,%r2
.Lidebc:
        tm    0(%r5),0x80                      # high order bit set ?
        jo    .Ldocv                           #  yes -> convert from EBCDIC
        ahi   %r5,-1