b075083f35
FCP dump feature detection works only if the sclp command in head.S
was succesful. Since the sclp command is skipped if diag260 works,
we don't have any dump feature detection anymore.
Bug was introduced with d57de5a367
.
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
389 lines
9.6 KiB
ArmAsm
389 lines
9.6 KiB
ArmAsm
/*
|
|
* arch/s390/kernel/head64.S
|
|
*
|
|
* Copyright (C) IBM Corp. 1999,2006
|
|
*
|
|
* Author(s): Hartmut Penner <hp@de.ibm.com>
|
|
* Martin Schwidefsky <schwidefsky@de.ibm.com>
|
|
* Rob van der Heij <rvdhei@iae.nl>
|
|
* Heiko Carstens <heiko.carstens@de.ibm.com>
|
|
*
|
|
*/
|
|
|
|
#
|
|
# startup-code at 0x10000, running in absolute addressing mode
|
|
# this is called either by the ipl loader or directly by PSW restart
|
|
# or linload or SALIPL
|
|
#
|
|
.org 0x10000
|
|
startup:basr %r13,0 # get base
|
|
.LPG0: l %r13,0f-.LPG0(%r13)
|
|
b 0(%r13)
|
|
0: .long startup_continue
|
|
|
|
#
|
|
# params at 10400 (setup.h)
|
|
#
|
|
.org PARMAREA
|
|
.quad 0 # IPL_DEVICE
|
|
.quad 0 # INITRD_START
|
|
.quad 0 # INITRD_SIZE
|
|
|
|
.org COMMAND_LINE
|
|
.byte "root=/dev/ram0 ro"
|
|
.byte 0
|
|
|
|
.org 0x11000
|
|
|
|
startup_continue:
|
|
basr %r13,0 # get base
|
|
.LPG1: sll %r13,1 # remove high order bit
|
|
srl %r13,1
|
|
lhi %r1,1 # mode 1 = esame
|
|
mvi __LC_AR_MODE_ID,1 # set esame flag
|
|
slr %r0,%r0 # set cpuid to zero
|
|
sigp %r1,%r0,0x12 # switch to esame mode
|
|
sam64 # switch to 64 bit mode
|
|
lctlg %c0,%c15,.Lctl-.LPG1(%r13) # load control registers
|
|
lg %r12,.Lparmaddr-.LPG1(%r13) # pointer to parameter area
|
|
# move IPL device to lowcore
|
|
mvc __LC_IPLDEV(4),IPL_DEVICE+4-PARMAREA(%r12)
|
|
#
|
|
# Setup stack
|
|
#
|
|
larl %r15,init_thread_union
|
|
lg %r14,__TI_task(%r15) # cache current in lowcore
|
|
stg %r14,__LC_CURRENT
|
|
aghi %r15,1<<(PAGE_SHIFT+THREAD_ORDER) # init_task_union + THREAD_SIZE
|
|
stg %r15,__LC_KERNEL_STACK # set end of kernel stack
|
|
aghi %r15,-160
|
|
xc __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15) # clear backchain
|
|
|
|
brasl %r14,ipl_save_parameters
|
|
#
|
|
# clear bss memory
|
|
#
|
|
larl %r2,__bss_start # start of bss segment
|
|
larl %r3,_end # end of bss segment
|
|
sgr %r3,%r2 # length of bss
|
|
sgr %r4,%r4 #
|
|
sgr %r5,%r5 # set src,length and pad to zero
|
|
mvcle %r2,%r4,0 # clear mem
|
|
jo .-4 # branch back, if not finish
|
|
# set program check new psw mask
|
|
mvc __LC_PGM_NEW_PSW(8),.Lpcmsk-.LPG1(%r13)
|
|
larl %r1,.Lslowmemdetect # set program check address
|
|
stg %r1,__LC_PGM_NEW_PSW+8
|
|
lghi %r1,0xc
|
|
diag %r0,%r1,0x260 # get memory size of virtual machine
|
|
cgr %r0,%r1 # different? -> old detection routine
|
|
jne .Lslowmemdetect
|
|
aghi %r1,1 # size is one more than end
|
|
larl %r2,memory_chunk
|
|
stg %r1,8(%r2) # store size of chunk
|
|
|
|
.Lslowmemdetect:
|
|
l %r2,.Lrcp-.LPG1(%r13) # Read SCP forced command word
|
|
.Lservicecall:
|
|
stosm .Lpmask-.LPG1(%r13),0x01 # authorize ext interrupts
|
|
|
|
stctg %r0,%r0,.Lcr-.LPG1(%r13) # get cr0
|
|
la %r1,0x200 # set bit 22
|
|
og %r1,.Lcr-.LPG1(%r13) # or old cr0 with r1
|
|
stg %r1,.Lcr-.LPG1(%r13)
|
|
lctlg %r0,%r0,.Lcr-.LPG1(%r13) # load modified cr0
|
|
|
|
mvc __LC_EXT_NEW_PSW(8),.Lpcmsk-.LPG1(%r13) # set postcall psw
|
|
larl %r1,.Lsclph
|
|
stg %r1,__LC_EXT_NEW_PSW+8 # set handler
|
|
|
|
larl %r4,.Lsccb # %r4 is our index for sccb stuff
|
|
lgr %r1,%r4 # our sccb
|
|
.insn rre,0xb2200000,%r2,%r1 # service call
|
|
ipm %r1
|
|
srl %r1,28 # get cc code
|
|
xr %r3,%r3
|
|
chi %r1,3
|
|
be .Lfchunk-.LPG1(%r13) # leave
|
|
chi %r1,2
|
|
be .Lservicecall-.LPG1(%r13)
|
|
lpswe .Lwaitsclp-.LPG1(%r13)
|
|
.Lsclph:
|
|
lh %r1,.Lsccbr-.Lsccb(%r4)
|
|
chi %r1,0x10 # 0x0010 is the sucess code
|
|
je .Lprocsccb # let's process the sccb
|
|
chi %r1,0x1f0
|
|
bne .Lfchunk-.LPG1(%r13) # unhandled error code
|
|
c %r2,.Lrcp-.LPG1(%r13) # Did we try Read SCP forced
|
|
bne .Lfchunk-.LPG1(%r13) # if no, give up
|
|
l %r2,.Lrcp2-.LPG1(%r13) # try with Read SCP
|
|
b .Lservicecall-.LPG1(%r13)
|
|
.Lprocsccb:
|
|
lghi %r1,0
|
|
icm %r1,3,.Lscpincr1-.Lsccb(%r4) # use this one if != 0
|
|
jnz .Lscnd
|
|
lg %r1,.Lscpincr2-.Lsccb(%r4) # otherwise use this one
|
|
.Lscnd:
|
|
xr %r3,%r3 # same logic
|
|
ic %r3,.Lscpa1-.Lsccb(%r4)
|
|
chi %r3,0x00
|
|
jne .Lcompmem
|
|
l %r3,.Lscpa2-.Lsccb(%r4)
|
|
.Lcompmem:
|
|
mlgr %r2,%r1 # mem in MB on 128-bit
|
|
l %r1,.Lonemb-.LPG1(%r13)
|
|
mlgr %r2,%r1 # mem size in bytes in %r3
|
|
b .Lfchunk-.LPG1(%r13)
|
|
|
|
.align 4
|
|
.Lpmask:
|
|
.byte 0
|
|
.align 8
|
|
.Lcr:
|
|
.quad 0x00 # place holder for cr0
|
|
.Lwaitsclp:
|
|
.quad 0x0102000180000000,.Lsclph
|
|
.Lrcp:
|
|
.int 0x00120001 # Read SCP forced code
|
|
.Lrcp2:
|
|
.int 0x00020001 # Read SCP code
|
|
.Lonemb:
|
|
.int 0x100000
|
|
|
|
.Lfchunk:
|
|
|
|
#
|
|
# find memory chunks.
|
|
#
|
|
larl %r9,memory_chunk # skip tprot loop if diag260
|
|
lg %r9,8(%r9) # memory detection was successful
|
|
ltgr %r9,%r9
|
|
jne .Ldonemem
|
|
|
|
lgr %r9,%r3 # end of mem
|
|
larl %r1,.Lchkmem # set program check address
|
|
stg %r1,__LC_PGM_NEW_PSW+8
|
|
la %r1,1 # test in increments of 128KB
|
|
sllg %r1,%r1,17
|
|
larl %r3,memory_chunk
|
|
slgr %r4,%r4 # set start of chunk to zero
|
|
slgr %r5,%r5 # set end of chunk to zero
|
|
slr %r6,%r6 # set access code to zero
|
|
la %r10,MEMORY_CHUNKS # number of chunks
|
|
.Lloop:
|
|
tprot 0(%r5),0 # test protection of first byte
|
|
ipm %r7
|
|
srl %r7,28
|
|
clr %r6,%r7 # compare cc with last access code
|
|
je .Lsame
|
|
lghi %r8,0 # no program checks
|
|
j .Lsavchk
|
|
.Lsame:
|
|
algr %r5,%r1 # add 128KB to end of chunk
|
|
# no need to check here,
|
|
brc 12,.Lloop # this is the same chunk
|
|
.Lchkmem: # > 16EB or tprot got a program check
|
|
lghi %r8,1 # set program check flag
|
|
.Lsavchk:
|
|
clgr %r4,%r5 # chunk size > 0?
|
|
je .Lchkloop
|
|
stg %r4,0(%r3) # store start address of chunk
|
|
lgr %r0,%r5
|
|
slgr %r0,%r4
|
|
stg %r0,8(%r3) # store size of chunk
|
|
st %r6,20(%r3) # store type of chunk
|
|
la %r3,24(%r3)
|
|
ahi %r10,-1 # update chunk number
|
|
.Lchkloop:
|
|
lr %r6,%r7 # set access code to last cc
|
|
# we got an exception or we're starting a new
|
|
# chunk , we must check if we should
|
|
# still try to find valid memory (if we detected
|
|
# the amount of available storage), and if we
|
|
# have chunks left
|
|
lghi %r4,1
|
|
sllg %r4,%r4,31
|
|
clgr %r5,%r4
|
|
je .Lhsaskip
|
|
xr %r0, %r0
|
|
clgr %r0, %r9 # did we detect memory?
|
|
je .Ldonemem # if not, leave
|
|
chi %r10, 0 # do we have chunks left?
|
|
je .Ldonemem
|
|
.Lhsaskip:
|
|
chi %r8,1 # program check ?
|
|
je .Lpgmchk
|
|
lgr %r4,%r5 # potential new chunk
|
|
algr %r5,%r1 # add 128KB to end of chunk
|
|
j .Llpcnt
|
|
.Lpgmchk:
|
|
algr %r5,%r1 # add 128KB to end of chunk
|
|
lgr %r4,%r5 # potential new chunk
|
|
.Llpcnt:
|
|
clgr %r5,%r9 # should we go on?
|
|
jl .Lloop
|
|
.Ldonemem:
|
|
|
|
larl %r12,machine_flags
|
|
#
|
|
# find out if we are running under VM
|
|
#
|
|
stidp __LC_CPUID # store cpuid
|
|
tm __LC_CPUID,0xff # running under VM ?
|
|
bno 0f-.LPG1(%r13)
|
|
oi 7(%r12),1 # set VM flag
|
|
0: lh %r0,__LC_CPUID+4 # get cpu version
|
|
chi %r0,0x7490 # running on a P/390 ?
|
|
bne 1f-.LPG1(%r13)
|
|
oi 7(%r12),4 # set P/390 flag
|
|
1:
|
|
|
|
#
|
|
# find out if we have the MVPG instruction
|
|
#
|
|
la %r1,0f-.LPG1(%r13) # set program check address
|
|
stg %r1,__LC_PGM_NEW_PSW+8
|
|
sgr %r0,%r0
|
|
lghi %r1,0
|
|
lghi %r2,0
|
|
mvpg %r1,%r2 # test MVPG instruction
|
|
oi 7(%r12),16 # set MVPG flag
|
|
0:
|
|
|
|
#
|
|
# find out if the diag 0x44 works in 64 bit mode
|
|
#
|
|
la %r1,0f-.LPG1(%r13) # set program check address
|
|
stg %r1,__LC_PGM_NEW_PSW+8
|
|
diag 0,0,0x44 # test diag 0x44
|
|
oi 7(%r12),32 # set diag44 flag
|
|
0:
|
|
|
|
#
|
|
# find out if we have the IDTE instruction
|
|
#
|
|
la %r1,0f-.LPG1(%r13) # set program check address
|
|
stg %r1,__LC_PGM_NEW_PSW+8
|
|
.long 0xb2b10000 # store facility list
|
|
tm 0xc8,0x08 # check bit for clearing-by-ASCE
|
|
bno 0f-.LPG1(%r13)
|
|
lhi %r1,2094
|
|
lhi %r2,0
|
|
.long 0xb98e2001
|
|
oi 7(%r12),0x80 # set IDTE flag
|
|
0:
|
|
|
|
#
|
|
# find out if the diag 0x9c is available
|
|
#
|
|
la %r1,0f-.LPG1(%r13) # set program check address
|
|
stg %r1,__LC_PGM_NEW_PSW+8
|
|
stap __LC_CPUID+4 # store cpu address
|
|
lh %r1,__LC_CPUID+4
|
|
diag %r1,0,0x9c # test diag 0x9c
|
|
oi 6(%r12),1 # set diag9c flag
|
|
0:
|
|
|
|
#
|
|
# find out if we have the MVCOS instruction
|
|
#
|
|
la %r1,0f-.LPG1(%r13) # set program check address
|
|
stg %r1,__LC_PGM_NEW_PSW+8
|
|
.short 0xc800 # mvcos 0(%r0),0(%r0),%r0
|
|
.short 0x0000
|
|
.short 0x0000
|
|
0: tm 0x8f,0x13 # special-operation exception?
|
|
bno 1f-.LPG1(%r13) # if yes, MVCOS is present
|
|
oi 6(%r12),2 # set MVCOS flag
|
|
1:
|
|
|
|
lpswe .Lentry-.LPG1(13) # jump to _stext in primary-space,
|
|
# virtual and never return ...
|
|
.align 16
|
|
.Lentry:.quad 0x0000000180000000,_stext
|
|
.Lctl: .quad 0x04b50002 # cr0: various things
|
|
.quad 0 # cr1: primary space segment table
|
|
.quad .Lduct # cr2: dispatchable unit control table
|
|
.quad 0 # cr3: instruction authorization
|
|
.quad 0 # cr4: instruction authorization
|
|
.quad 0xffffffffffffffff # cr5: primary-aste origin
|
|
.quad 0 # cr6: I/O interrupts
|
|
.quad 0 # cr7: secondary space segment table
|
|
.quad 0 # cr8: access registers translation
|
|
.quad 0 # cr9: tracing off
|
|
.quad 0 # cr10: tracing off
|
|
.quad 0 # cr11: tracing off
|
|
.quad 0 # cr12: tracing off
|
|
.quad 0 # cr13: home space segment table
|
|
.quad 0xc0000000 # cr14: machine check handling off
|
|
.quad 0 # cr15: linkage stack operations
|
|
.Lduct: .long 0,0,0,0,0,0,0,0
|
|
.long 0,0,0,0,0,0,0,0
|
|
.Lpcmsk:.quad 0x0000000180000000
|
|
.L4malign:.quad 0xffffffffffc00000
|
|
.Lscan2g:.quad 0x80000000 + 0x20000 - 8 # 2GB + 128K - 8
|
|
.Lnop: .long 0x07000700
|
|
.Lparmaddr:
|
|
.quad PARMAREA
|
|
|
|
.globl ipl_schib
|
|
ipl_schib:
|
|
.rept 13
|
|
.long 0
|
|
.endr
|
|
|
|
.globl ipl_flags
|
|
ipl_flags:
|
|
.long 0
|
|
.globl ipl_devno
|
|
ipl_devno:
|
|
.word 0
|
|
|
|
.org 0x12000
|
|
.globl s390_readinfo_sccb
|
|
s390_readinfo_sccb:
|
|
.Lsccb:
|
|
.hword 0x1000 # length, one page
|
|
.byte 0x00,0x00,0x00
|
|
.byte 0x80 # variable response bit set
|
|
.Lsccbr:
|
|
.hword 0x00 # response code
|
|
.Lscpincr1:
|
|
.hword 0x00
|
|
.Lscpa1:
|
|
.byte 0x00
|
|
.fill 89,1,0
|
|
.Lscpa2:
|
|
.int 0x00
|
|
.Lscpincr2:
|
|
.quad 0x00
|
|
.fill 3984,1,0
|
|
.org 0x13000
|
|
|
|
#ifdef CONFIG_SHARED_KERNEL
|
|
.org 0x100000
|
|
#endif
|
|
|
|
#
|
|
# startup-code, running in absolute addressing mode
|
|
#
|
|
.globl _stext
|
|
_stext: basr %r13,0 # get base
|
|
.LPG3:
|
|
# check control registers
|
|
stctg %c0,%c15,0(%r15)
|
|
oi 6(%r15),0x40 # enable sigp emergency signal
|
|
oi 4(%r15),0x10 # switch on low address proctection
|
|
lctlg %c0,%c15,0(%r15)
|
|
|
|
lam 0,15,.Laregs-.LPG3(%r13) # load acrs needed by uaccess
|
|
brasl %r14,start_kernel # go to C code
|
|
#
|
|
# We returned from start_kernel ?!? PANIK
|
|
#
|
|
basr %r13,0
|
|
lpswe .Ldw-.(%r13) # load disabled wait psw
|
|
|
|
.align 8
|
|
.Ldw: .quad 0x0002000180000000,0x0000000000000000
|
|
.Laregs:.long 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
|