head     1.1;
branch   1.1.1;
access   ;
symbols  proj:1.1.1.1 start:1.1.1;
locks    ; strict;
comment  @# @;


1.1
date     2006.07.06.10.14.58;  author kaurikim;  state Exp;
branches 1.1.1.1;
next     ;

1.1.1.1
date     2006.07.06.10.14.58;  author kaurikim;  state Exp;
branches ;
next     ;


desc
@@



1.1
log
@Initial revision
@
text
@/*
 *	setup.S		Copyright (C) 1991, 1992 Linus Torvalds
 *
 * setup.s is responsible for getting the system data from the BIOS,
 * and putting them into the appropriate places in system memory.
 * both setup.s and system has been loaded by the bootblock.
 *
 * This code asks the bios for memory/disk/other parameters, and
 * puts them in a "safe" place: 0x90000-0x901FF, ie where the
 * boot-block used to be. It is then up to the protected mode
 * system to read them from there before the area is overwritten
 * for buffer-blocks.
 *
 * Move PS/2 aux init code to psaux.c
 * (troyer@@saifr00.cfsat.Honeywell.COM) 03Oct92
 *
 * some changes and additional features by Christoph Niemann,
 * March 1993/June 1994 (Christoph.Niemann@@linux.org)
 *
 * add APM BIOS checking by Stephen Rothwell, May 1994
 * (sfr@@canb.auug.org.au)
 *
 * High load stuff, initrd support and position independency
 * by Hans Lermen & Werner Almesberger, February 1996
 * <lermen@@elserv.ffm.fgan.de>, <almesber@@lrc.epfl.ch>
 *
 * Video handling moved to video.S by Martin Mares, March 1996
 * <mj@@k332.feld.cvut.cz>
 *
 * Extended memory detection scheme retwiddled by orc@@pell.chi.il.us (david
 * parsons) to avoid loadlin confusion, July 1997
 *
 * Transcribed from Intel (as86) -> AT&T (gas) by Chris Noe, May 1999.
 * <stiker@@northlink.com>
 *
 * Fix to work around buggy BIOSes which dont use carry bit correctly
 * and/or report extended memory in CX/DX for e801h memory size detection 
 * call.  As a result the kernel got wrong figures.  The int15/e801h docs
 * from Ralf Brown interrupt list seem to indicate AX/BX should be used
 * anyway.  So to avoid breaking many machines (presumably there was a reason
 * to orginally use CX/DX instead of AX/BX), we do a kludge to see
 * if CX/DX have been changed in the e801 call and if so use AX/BX .
 * Michael Miller, April 2001 <michaelm@@mjmm.org>
 *
 * New A20 code ported from SYSLINUX by H. Peter Anvin. AMD Elan bugfixes
 * by Robert Schwebel, December 2001 <robert@@schwebel.de>
 *
 */

#include <linux/config.h>
#include <asm/segment.h>
#include <linux/version.h>
#include <linux/compile.h>
#include <asm/boot.h>
#include <asm/e820.h>
#include <asm/page.h>
	
/* Signature words to ensure LILO loaded us right */
#define SIG1	0xAA55
#define SIG2	0x5A5A

INITSEG  = DEF_INITSEG		# 0x9000, we move boot here, out of the way
SYSSEG   = DEF_SYSSEG		# 0x1000, system loaded at 0x10000 (65536).
SETUPSEG = DEF_SETUPSEG		# 0x9020, this is the current segment
				# ... and the former contents of CS

DELTA_INITSEG = SETUPSEG - INITSEG	# 0x0020

.code16
.globl begtext, begdata, begbss, endtext, enddata, endbss

.text
begtext:
.data
begdata:
.bss
begbss:
.text

start:
	jmp	trampoline



################################################### setup.S head 시작
# This is the setup header, and it must start at %cs:2 (old 0x9020:2)

		.ascii	"HdrS"		# header signature
		.word	0x0203		# header version number (>= 0x0105)
					# or else old loadlin-1.5 will fail)
realmode_swtch:	.word	0, 0		# default_switch, SETUPSEG
start_sys_seg:	.word	SYSSEG
		.word	kernel_version	# pointing to kernel version string
					# above section of header is compatible
					# with loadlin-1.5 (header v1.5). Don't
					# change it.

type_of_loader:	.byte	0		# = 0, old one (LILO, Loadlin,
					#      Bootlin, SYSLX, bootsect...)
					# See Documentation/i386/boot.txt for
					# assigned ids
	
# flags, unused bits must be zero (RFU) bit within loadflags
loadflags:
LOADED_HIGH	= 1			# If set, the kernel is loaded high  
CAN_USE_HEAP	= 0x80			# If set, the loader also has set
					# heap_end_ptr to tell how much
					# space behind setup.S can be used for
					# heap purposes.
					# Only the loader knows what is free
#ifndef __BIG_KERNEL__
		.byte	0
#else
		.byte	LOADED_HIGH
#endif

setup_move_size: .word  0x8000		# size to move, when setup is not
					# loaded at 0x90000. We will move setup 
					# to 0x90000 then just before jumping
					# into the kernel. However, only the
					# loader knows how much data behind
					# us also needs to be loaded.

code32_start:				# here loaders can put a different
					# start address for 32-bit code.
#ifndef __BIG_KERNEL__
		.long	0x1000		#   0x1000 = default for zImage
#else
		.long	0x100000	# 0x100000 = default for big kernel
#endif

ramdisk_image:	.long	0		# address of loaded ramdisk image
					# Here the loader puts the 32-bit
					# address where it loaded the image.
					# This only will be read by the kernel.

ramdisk_size:	.long	0		# its size in bytes

bootsect_kludge:
		.word  bootsect_helper, SETUPSEG

heap_end_ptr:	.word	modelist+1024	# (Header version 0x0201 or later)
					# space from here (exclusive) down to
					# end of setup code can be used by setup
					# for local heap purposes.

pad1:		.word	0
cmd_line_ptr:	.long 0			# (Header version 0x0202 or later)
					# If nonzero, a 32-bit pointer
					# to the kernel command line.
					# The command line should be
					# located between the start of
					# setup and the end of low
					# memory (0xa0000), or it may
					# get overwritten before it
					# gets read.  If this field is
					# used, there is no longer
					# anything magical about the
					# 0x90000 segment; the setup
					# can be located anywhere in
					# low memory 0x10000 or higher.

ramdisk_max:	.long __MAXMEM-1	# (Header version 0x0203 or later)
					# The highest safe address for
					# the contents of an initrd

trampoline:	call	start_of_setup
		.space	1024
# End of setup header ############################################### setup.S head 끝





start_of_setup:
# Bootlin depends on this being done early
	movw	$0x01500, %ax	# ah = 0x15, al = 00
	movb	$0x81, %dl	# dl = 0x81
	int	$0x13		# 직접 접근장치를 읽는다. (dl = 0x81은 세컨드리를 의미)




# SAFE_RESET_DISK_CONTROLLER macro는 정의 되어 있지 않기 때문에 수행치 않음
#ifdef SAFE_RESET_DISK_CONTROLLER
# Reset the disk controller.
	movw	$0x0000, %ax	# ah = 0x00, al = 0x00, dl = 0x80 (프라이머리)
	movb	$0x80, %dl
	int	$0x13		# reset
#endif




# Set %ds = %cs, we know that SETUPSEG = %cs at this point
	movw	%cs, %ax		# aka SETUPSEG = 0x9020
	movw	%ax, %ds		# cs = ds = 0x9020
# Check signature at end of setup
	cmpw	$SIG1, setup_sig1	# SIG1 = AA55, setup_sig1 = SIG1  setup.S가 정상적으로 로딩되었는지 확인한다. 
					# (setup_sig1 변수의 값으로 확인)
	jne	bad_sig

	cmpw	$SIG2, setup_sig2	# SIG2 = 5A5A, setup_sig2 = SIG2 
	jne	bad_sig

	jmp	good_sig1

# Routine to print asciiz string at ds:si
prtstr:
	lodsb
	andb	%al, %al
	jz	fin

	call	prtchr
	jmp	prtstr

fin:	ret

# Space printing
prtsp2:	call	prtspc		# Print double space
prtspc:	movb	$0x20, %al	# Print single space (note: fall-thru)

# Part of above routine, this one just prints ascii al
prtchr:	pushw	%ax
	pushw	%cx
	xorb	%bh, %bh
	movw	$0x01, %cx
	movb	$0x0e, %ah
	int	$0x10
	popw	%cx
	popw	%ax
	ret

beep:	movb	$0x07, %al
	jmp	prtchr
	
no_sig_mess: .string	"No setup signature found ..."

good_sig1:
	jmp	good_sig

# We now have to find the rest of the setup code/data
bad_sig:
	movw	%cs, %ax			# SETUPSEG
	subw	$DELTA_INITSEG, %ax		# INITSEG
	movw	%ax, %ds
	xorb	%bh, %bh
	movb	(497), %bl			# get setup sect from bootsect
	subw	$4, %bx				# LILO loads 4 sectors of setup
	shlw	$8, %bx				# convert to words (1sect=2^8 words)
	movw	%bx, %cx
	shrw	$3, %bx				# convert to segment
	addw	$SYSSEG, %bx
	movw	%bx, %cs:start_sys_seg
# Move rest of setup code/data to here
	movw	$2048, %di			# four sectors loaded by LILO
	subw	%si, %si
	pushw	%cs
	popw	%es
	movw	$SYSSEG, %ax
	movw	%ax, %ds
	rep
	movsw
	movw	%cs, %ax			# aka SETUPSEG
	movw	%ax, %ds
	cmpw	$SIG1, setup_sig1
	jne	no_sig

	cmpw	$SIG2, setup_sig2
	jne	no_sig

	jmp	good_sig

no_sig:
	lea	no_sig_mess, %si
	call	prtstr

no_sig_loop:
	hlt
	jmp	no_sig_loop

good_sig:
	movw	%cs, %ax			# aka SETUPSEG
	subw	$DELTA_INITSEG, %ax 		# aka INITSEG DELTA_INITSEG = 0x20
	movw	%ax, %ds			# ds = 0x9000
# Check if an old loader tries to load a big-kernel
	testb	$LOADED_HIGH, %cs:loadflags	# LOADED_HIGH = 0x0001, %cs:loadflags = 0x0001 (big kernel 이기 때문에 1이 들어있다.)
	jz	loader_ok			# No, no danger for old loaders. ????????? <===== ?

	cmpb	$0, %cs:type_of_loader 		# Do we have a loader that	type_of_loader = 0
						# can deal with us?
	jnz	loader_ok			# Yes, continue.

	pushw	%cs				# No, we have an old loader,
	popw	%ds				# die. 
	lea	loader_panic_mess, %si
	call	prtstr

	jmp	no_sig_loop

loader_panic_mess: .string "Wrong loader, giving up..."







loader_ok:
# Get memory size (extended mem, kB)
# extended mem size를 잡아준다. 
	xorl	%eax, %eax		# %eax = 0
	movl	%eax, (0x1e0)		# (0x901e0) = 0x00000000
#ifndef STANDARD_MEMORY_BIOS_CALL
	movb	%al, (E820NR)		# (0x901e8) = 0x00
# Try three different memory detection schemes.  First, try
# e820h, which lets us assemble a memory map, then try e801h,
# which returns a 32-bit memory size, and finally 88h, which
# returns 0-64m

# method E820H:
# the memory map from hell.  e820h returns memory classified into
# a whole bunch of different types, and allows memory holes and
# everything.  We scan through this memory map and build a list
# of the first 32 memory areas, which we return at [E820MAP].
# This is documented at http://www.teleport.com/~acpi/acpihtml/topic245.htm


# 0x534d4150 == "SMAP"
#define SMAP  0x534d4150

meme820:
	xorl	%ebx, %ebx			# continuation counter		%ebx = 0x00000000
movw	$E820MAP, %di				# point into the whitelist	E820MAP = 0x2d0, %di = 0x02d0
						# so we can have the bios
						# directly write into it.


#
# struct e820map {
#	int nr_map;
#	struct e820entry {
#		unsigned long long addr;        /* start of memory segment */
#		unsigned long long size;        /* size of memory segment */
#		unsigned long type;             /* type of memory segment */
#	} map[E820MAX];
# };
#
jmpe820:
	movl	$0x0000e820, %eax		# e820, upper word zeroed   %eax =0x0000e820 
	movl	$SMAP, %edx			# ascii 'SMAP'		%edx = 'SMAP'
	movl	$20, %ecx			# size of the e820rec	%ecx = 0x14
	pushw	%ds				# data record.
	popw	%es				# es = 0x9000
	
	int	$0x15				# BIOS가 0xe820 함수를 지원하는지 알아보기 위해
						# eax의 값에 0xe820을 넣고 int 15를 발생시킨다.
						# BIOS가 0xe820 함수를 지원한다면 eax에 "SMAP"를 반환한다.
						# 0xe820 BIOS 함수에 의해 읽혀진 map은 0x90000+0x2d0(E820MAP)에
						# 저장되고 map은 최대 32개의 e820entry 구조체로 되어 있다.
						# 함수가 호출될 때마다 entry는 1개씩 읽혀지며, entry 번호는 
						# 0x90000(empty_zero_page에 복사될 내용)+0x1e8(E820NR)에 저장된다.

	
	jc	bail820				# fall to e801 if it fails

	cmpl	$SMAP, %eax			# check the return is `SMAP'  %eax가 'SMAP'라면
	jne	bail820				# fall to e801 if it fails

#	cmpl	$1, 16(%di)			# is this usable memory?
#	jne	again820

	# If this is usable memory, we save it by simply advancing %di by
	# sizeof(e820rec).
	#
good820:
	movb	(E820NR), %al			# up to 32 entries   %al = (0x901e8) = 0x00 (E820NR의 처음 값은 0이다)
	cmpb	$E820MAX, %al			# %al (0x00) - 0x20(32)
	jnl	bail820				# 크거나 같으면

	incb	(E820NR)			# (E820NR) = (E820NR) + 1  = 0x01
	movw	%di, %ax			# %di = 0x02d0
	addw	$20, %ax			# %ax = 0x02e4
	movw	%ax, %di			# %di = 0x02e4
again820:
	cmpl	$0, %ebx			# check to see if	 0x00 - 0x00 
	jne	jmpe820				# %ebx is set to EOF  %ebx가 0이아니면 e820이고 아니면 e820이 아님
						# E820MAP의 에러가 없다면 32번 체크를 하고 bail820으로...
bail820:







# method E801H:
# memory size is in 1k chunksizes, to avoid confusing loadlin.
# we store the 0xe801 memory size in a completely different place,
# because it will most likely be longer than 16 bits.
# (use 1e0 because that's what Larry Augustine uses in his
# alternative new memory detection scheme, and it's sensible
# to write everything into the same place.)

# 0xe810 BIOS function은 0x90000(empty_zero_page에 복사 될 내용)+0xe10 위치에 메모리 사이즈를 기록한다.
meme801:
	stc					# fix to work around buggy	캐리플레그를 1로셋
	xorw	%cx,%cx				# BIOSes which dont clear/set	cx = 0
	xorw	%dx,%dx				# carry on pass/error of	dx = 0
						# e801h memory size call
						# or merely pass cx,dx though
						# without changing them.
	movw	$0xe801, %ax
	int	$0x15
	jc	mem88

	cmpw	$0x0, %cx			# Kludge to handle BIOSes
	jne	e801usecxdx			# which report their extended
	cmpw	$0x0, %dx			# memory in AX/BX rather than
	jne	e801usecxdx			# CX/DX.  The spec I have read
	movw	%ax, %cx			# seems to indicate AX/BX 
	movw	%bx, %dx			# are more reasonable anyway...

e801usecxdx:
	andl	$0xffff, %edx			# clear sign extend
	shll	$6, %edx			# and go from 64k to 1k chunks
	movl	%edx, (0x1e0)			# store extended memory size
	andl	$0xffff, %ecx			# clear sign extend
 	addl	%ecx, (0x1e0)			# and add lower memory into
						# total size.

# Ye Olde Traditional Methode.  Returns the memory size (up to 16mb or
# 64mb, depending on the bios) in ax.

	
# BIOS function 0x88은 0x90002 위치에 구한 확장 메모리 사이즈를 기록한다. 단 64Mb 까지만 확인 가능	

	
	
	
mem88:

#endif
	movb	$0x88, %ah
	int	$0x15		# 확장메모리 사이즈 결정
	movw	%ax, (2)	# 0x90002 위치에 구한 확장 메모리 사이즈를 기록한다.






# Set the keyboard repeat rate to the max
	movw	$0x0305, %ax		# ah = 03, al = 05
	xorw	%bx, %bx		# bx = 0x00
	int	$0x16			# 키보드의 delay time = 250ms,  rate time = 30.0 




# Check for video adapter and its parameters and allow the
# user to browse video modes.
	call	video				# NOTE: we need %ds pointing
						# to bootsector




# Get hd0 data...
	xorw	%ax, %ax			# %ax = 0x00
	movw	%ax, %ds			# %ds = 0x00
	ldsw	(4 * 0x41), %si			# %si = (4*0x41)
						# 40:41 위치에 BIOS에서 수집한 disk정보가 있음. (interrupt table의 biosdataarea.html 참조)
	
	movw	%cs, %ax			# aka SETUPSEG		%ax = 0x9020
	subw	$DELTA_INITSEG, %ax		# aka INITSEG		%ax = 0x9000
	pushw	%ax
	movw	%ax, %es			# %es = 0x9000
	movw	$0x0080, %di			# %di = 0x0080
	movw	$0x10, %cx			# %cx = 0x10
	pushw	%cx
	cld					# direct flag = 0
	rep					# %ds(0):%si(4*0x41) -> %es(0x9000):%di(0x80)   %cx(16)byte만큼 copy한다.
 	movsb					# BIOS에서 수집한 hd0의 파라메타를 0x90080으로 16byte만큼 복사한다.
# Get hd1 data...
	xorw	%ax, %ax
	movw	%ax, %ds
	ldsw	(4 * 0x46), %si
	popw	%cx
	popw	%es
	movw	$0x0090, %di
	rep
	movsb					# %ds(0):%si(4*0x46) -> %es(0x9000):%di(0x90) 16byte만큼 copy한다.
# Check that there IS a hd1 :-) ㅡㅡ;
	movw	$0x01500, %ax
	movb	$0x81, %dl
	int	$0x13				# hd1이 없다면
	jc	no_disk1
	
	cmpb	$3, %ah				# hd1이 있다면
	je	is_disk1

no_disk1:
	movw	%cs, %ax			# aka SETUPSEG
	subw	$DELTA_INITSEG, %ax 		# aka INITSEG
	movw	%ax, %es
	movw	$0x0090, %di
	movw	$0x10, %cx
	xorw	%ax, %ax
	cld
	rep
	stosb					# %ds(0):%si(4*0x46) -> %es(0x9000):%di(0x90) 16byte만큼 0으로 초기화한다.

is_disk1:



# check for Micro Channel (MCA) bus   IBM의 혼자살기 전략 실패작
	movw	%cs, %ax			# aka SETUPSEG		%ax = 0x9020
	subw	$DELTA_INITSEG, %ax		# aka INITSEG		%ax = 0x9000
	movw	%ax, %ds			# %ds = 0x9000
	xorw	%ax, %ax			# %ax = 0x0
	movw	%ax, (0xa0)			# set table length to 0		(0x900a0)(IBM PS/2 데스크탑 사용 유무정보) = 0x0
	movb	$0xc0, %ah			# %ah = 0xc0
	stc
	int	$0x15				# moves feature table to es:bx    IBM PS/2데스크탑에 관한 정보를 가져온다.
	jc	no_mca

	pushw	%ds
	movw	%es, %ax
	movw	%ax, %ds
	movw	%cs, %ax			# aka SETUPSEG
	subw	$DELTA_INITSEG, %ax		# aka INITSEG
	movw	%ax, %es
	movw	%bx, %si
	movw	$0xa0, %di
	movw	(%si), %cx
	addw	$2, %cx				# table length is a short
	cmpw	$0x10, %cx
	jc	sysdesc_ok

	movw	$0x10, %cx			# we keep only first 16 bytes
sysdesc_ok:
	rep
	movsb
	popw	%ds
no_mca:



# Check for PS/2 pointing device     PS/2 마우스 설정
	movw	%cs, %ax			# aka SETUPSEG
	subw	$DELTA_INITSEG, %ax		# aka INITSEG
	movw	%ax, %ds
	movw	$0, (0x1ff)			# default is no pointing device		(0x901ff) = 0x0000
	int	$0x11				# int 0x11: equipment list	BIOS의 정보를 %ax에 가져온다.
	testb	$0x04, %al			# check if mouse installed	
						# %al의 0x04는 ps/2마우스가 있으니깐 0x04가 된다.
	jz	no_psmouse

	movw	$0xAA, (0x1ff)			# device present	(0x901ff) =  0xaa (있다는 말입니다.)
no_psmouse:



# APM BIOS인가 확인하고 APM BIOS면 관련설정 (내 설정에서는 들어가는 부분)
#if defined(CONFIG_APM) || defined(CONFIG_APM_MODULE)
# Then check for an APM BIOS...
						# %ds points to the bootsector
	movw	$0, 0x40			# version = 0 means no APM BIOS
	movw	$0x05300, %ax			# APM BIOS installation check
	xorw	%bx, %bx
	int	$0x15				# apm의 작동 유무를 확인  
	jc	done_apm_bios			# Nope, no APM BIOS
	
	cmpw	$0x0504d, %bx			# Check for "PM" signature  bx의 값을 "PM"과 비교
	jne	done_apm_bios			# No signature, no APM BIOS

	andw	$0x02, %cx			# Is 32 bit supported?
	je	done_apm_bios			# No 32-bit, no (good) APM BIOS

	movw	$0x05304, %ax			# Disconnect first just in case
	xorw	%bx, %bx
	int	$0x15				# ignore return code
	movw	$0x05303, %ax			# 32 bit connect
	xorl	%ebx, %ebx
	xorw	%cx, %cx			# paranoia :-)
	xorw	%dx, %dx			#   ...
	xorl	%esi, %esi			#   ...
	xorw	%di, %di			#   ...
	int	$0x15
	jc	no_32_apm_bios			# Ack, error. 

	movw	%ax,  (66)			# BIOS code segment
	movl	%ebx, (68)			# BIOS entry point offset
	movw	%cx,  (72)			# BIOS 16 bit code segment
	movw	%dx,  (74)			# BIOS data segment
	movl	%esi, (78)			# BIOS code segment lengths
	movw	%di,  (82)			# BIOS data segment length
# Redo the installation check as the 32 bit connect
# modifies the flags returned on some BIOSs
	movw	$0x05300, %ax			# APM BIOS installation check
	xorw	%bx, %bx
	xorw	%cx, %cx			# paranoia
	int	$0x15
	jc	apm_disconnect			# error -> shouldn't happen

	cmpw	$0x0504d, %bx			# check for "PM" signature
	jne	apm_disconnect			# no sig -> shouldn't happen

	movw	%ax, (64)			# record the APM BIOS version
	movw	%cx, (76)			# and flags
	jmp	done_apm_bios

apm_disconnect:					# Tidy up
	movw	$0x05304, %ax			# Disconnect
	xorw	%bx, %bx
	int	$0x15				# ignore return code

	jmp	done_apm_bios

no_32_apm_bios:
	andw	$0xfffd, (76)			# remove 32 bit support bit
done_apm_bios:
#endif





# Now we want to move to protected mode ...
	cmpw	$0, %cs:realmode_swtch		# (0x90200):realmode_swtch 변수가 0x0가 이면... jump..
						# (0x90200)에는 short jump to start of setup code aka "reserved" field.
	jz	rmodeswtch_normal		
	lcall	%cs:realmode_swtch

	jmp	rmodeswtch_end

rmodeswtch_normal:
        pushw	%cs
	call	default_switch			# default_switch로 call

rmodeswtch_end:
# we get the code32 start address and modify the below 'jmpi'
# (loader may have changed it)

# code32_start		( 이것은 code32_start의 내용입니다.)
# __BIG_KERNEL__
#		.long	0x1000
#.. else
#		.long	0x100000
# 
	movl	%cs:code32_start, %eax		# 지금 BIG Kernel이면 %eax = 0x100000 아니면 %eax = 0x1000
	movl	%eax, %cs:code32		# code32라는 변수에 eax의 값을 넣는다.

# Now we move the system to its rightful place ... but we check if we have a
# big-kernel. In that case we *must* not move it ...
	testb	$LOADED_HIGH, %cs:loadflags	# LOADED_HIGH = 1, loadflags = 1	and 하니깐 당근 1이다.
	jz	do_move0			# .. then we have a normal low
						# loaded zImage
						# .. or else we have a high
						# loaded bzImage
	jmp	end_move			# ... and we skip moving	Big kernel은 end_move로 점프

do_move0:
	movw	$0x100, %ax			# start of destination segment
	movw	%cs, %bp			# aka SETUPSEG
	subw	$DELTA_INITSEG, %bp		# aka INITSEG
	movw	%cs:start_sys_seg, %bx		# start of source segment
	cld
do_move:
	movw	%ax, %es			# destination segment
	incb	%ah				# instead of add ax,#0x100
	movw	%bx, %ds			# source segment
	addw	$0x100, %bx
	subw	%di, %di
	subw	%si, %si
	movw 	$0x800, %cx
	rep
	movsw
	cmpw	%bp, %bx			# assume start_sys_seg > 0x200,
						# so we will perhaps read one
						# page more than needed, but
						# never overwrite INITSEG
						# because destination is a
						# minimum one page below source
	jb	do_move

end_move:
# then we load the segment descriptors
	movw	%cs, %ax			# aka SETUPSEG
	movw	%ax, %ds			# %ds = 0x9020
		
# Check whether we need to be downward compatible with version <=201
	cmpl	$0, cmd_line_ptr	# cmd_line_ptr = 0
	jne	end_move_self		# loader uses version >=202 features
	cmpb	$0x20, type_of_loader	# type_of_loader = 0
	je	end_move_self		# bootsect loader, we know of it

# Boot loader doesnt support boot protocol version 2.02.
# If we have our code not at 0x90000, we need to move it there now.
# We also then need to move the params behind it (commandline)
# Because we would overwrite the code on the current IP, we move
# it in two steps, jumping high after the first one.
	movw	%cs, %ax			# %ax = 0x9020
	cmpw	$SETUPSEG, %ax	
	je	end_move_self			# 여기서 점프

	cli					# make sure we really have
						# interrupts disabled !
						# because after this the stack
						# should not be used
	subw	$DELTA_INITSEG, %ax		# aka INITSEG
	movw	%ss, %dx
	cmpw	%ax, %dx
	jb	move_self_1

	addw	$INITSEG, %dx
	subw	%ax, %dx			# this will go into %ss after
						# the move
move_self_1:
	movw	%ax, %ds
	movw	$INITSEG, %ax			# real INITSEG
	movw	%ax, %es
	movw	%cs:setup_move_size, %cx
	std					# we have to move up, so we use
						# direction down because the
						# areas may overlap
	movw	%cx, %di
	decw	%di
	movw	%di, %si
	subw	$move_self_here+0x200, %cx
	rep
	movsb
	ljmp	$SETUPSEG, $move_self_here

move_self_here:
	movw	$move_self_here+0x200, %cx
	rep
	movsb
	movw	$SETUPSEG, %ax
	movw	%ax, %ds
	movw	%dx, %ss
end_move_self:					# now we are at the right place

#
# Enable A20.  This is at the very best an annoying procedure.
# A20 code ported from SYSLINUX 1.52-1.63 by H. Peter Anvin.
# AMD Elan bug fix by Robert Schwebel.
#

#if defined(CONFIG_MELAN)
	movb $0x02, %al			# alternate A20 gate	%al = 0x02
	outb %al, $0x92			# this works on SC410/SC520	0x92포트로 02를 출력한다.
a20_elan_wait:
# address 20을 enable시킨다.
        call a20_test
        jz a20_elan_wait
	jmp a20_done
#endif


A20_TEST_LOOPS		=  32		# Iterations per wait
A20_ENABLE_LOOPS	= 255		# Total loops to try		


a20_try_loop:

	# First, see if we are on a system with no A20 gate.
a20_none:
	call	a20_test
	jnz	a20_done

	# Next, try the BIOS (INT 0x15, AX=0x2401)
a20_bios:
	movw	$0x2401, %ax
	pushfl					# Be paranoid about flags
	int	$0x15
	popfl

	call	a20_test
	jnz	a20_done

	# Try enabling A20 through the keyboard controller
a20_kbc:
	call	empty_8042

	call	a20_test			# Just in case the BIOS worked
	jnz	a20_done			# but had a delayed reaction.

	movb	$0xD1, %al			# command write
	outb	%al, $0x64
	call	empty_8042

	movb	$0xDF, %al			# A20 on
	outb	%al, $0x60
	call	empty_8042

	# Wait until a20 really *is* enabled; it can take a fair amount of
	# time on certain systems; Toshiba Tecras are known to have this
	# problem.
a20_kbc_wait:
	xorw	%cx, %cx
a20_kbc_wait_loop:
	call	a20_test
	jnz	a20_done
	loop	a20_kbc_wait_loop

	# Final attempt: use "configuration port A"
a20_fast:
	inb	$0x92, %al			# Configuration Port A
	orb	$0x02, %al			# "fast A20" version
	andb	$0xFE, %al			# don't accidentally reset
	outb	%al, $0x92

	# Wait for configuration port A to take effect
a20_fast_wait:
	xorw	%cx, %cx
a20_fast_wait_loop:
	call	a20_test
	jnz	a20_done
	loop	a20_fast_wait_loop

	# A20 is still not responding.  Try frobbing it again.
	# 
	decb	(a20_tries)
	jnz	a20_try_loop
	
	movw	$a20_err_msg, %si
	call	prtstr

a20_die:
	hlt
	jmp	a20_die

a20_tries:
	.byte	A20_ENABLE_LOOPS

a20_err_msg:
	.ascii	"linux: fatal error: A20 gate not responding!"
	.byte	13, 10, 0

	# If we get here, all is good
a20_done:

# set up gdt and idt
	lidt	idt_48				# load idt with 0,0	%idtr = idt_48
	xorl	%eax, %eax			# Compute gdt_base	%eax = 0x00
	movw	%ds, %ax			# (Convert %ds:gdt to a linear ptr)	%ax = 0x9020
	shll	$4, %eax			# %eax = 0x90200
	addl	$gdt, %eax			# %eax = $gdt($가 붙어서 gdt변수의 주소를 나타낸다) + 0x90200	(즉, gdt 테이블의 시작 주소를 의미)
	movl	%eax, (gdt_48+2)		# (gdt_48+2) = %eax(gdt base) 		(base를 gdt 테이블의 시작 주소로 설정)
	lgdt	gdt_48				# load gdt with whatever is	%gdtr = gdt_48
						# appropriate

# make sure any possible coprocessor is properly reset..
	xorw	%ax, %ax			# %ax = 0x00
	outb	%al, $0xf0				
	call	delay

	outb	%al, $0xf1			
	call	delay				# 0xf0포트로 %al의 값을 보낸다. (coprocess reset)


# well, that went ok, I hope. Now we mask all interrupts - the rest
# is done in init_IRQ().
# 모든 interrupt를 disable
	movb	$0xFF, %al			# mask all interrupts for now
	outb	%al, $0xA1
	call	delay
	
	movb	$0xFB, %al			# mask all irq's but irq2 which
	outb	%al, $0x21			# is cascaded  8259의 마스트에 IRQ2번
						# IRQ2번(cascad)만 살려둠

# Well, that certainly wasn't fun :-(. Hopefully it works, and we don't
# need no steenking BIOS anyway (except for the initial loading :-).
# The BIOS-routine wants lots of unnecessary data, and it's less
# "interesting" anyway. This is how REAL programmers do it.
#
# Well, now's the time to actually move into protected mode. To make
# things as simple as possible, we do no register set-up or anything,
# we let the gnu-compiled 32-bit programs do that. We just jump to
# absolute address 0x1000 (or the loader supplied one),
# in 32-bit protected mode.
#
# Note that the short jump isn't strictly needed, although there are
# reasons why it might be a good idea. It won't hurt in any case.

# protected mode로 전환
	movw	$1, %ax				# protected mode (PE) bit	5ax = 0x1
	lmsw	%ax				# %cr0의 (PE)bit를 1로 셋  (i386은 32bit control register가 5개)
	jmp	flush_instr

flush_instr:
	xorw	%bx, %bx			# Flag to indicate a boot	%bx = 0x00
	xorl	%esi, %esi			# Pointer to real-mode code	%esi = 0x00000000
	movw	%cs, %si			# %si = 0x9020
	subw	$DELTA_INITSEG, %si		# %si = 0x9000
	shll	$4, %esi			# Convert to 32-bit pointer	%esi = 0x90000
# NOTE: For high loaded big kernels we need a
#	jmpi    0x100000,__KERNEL_CS
#
#	but we yet haven't reloaded the CS register, so the default size 
#	of the target offset still is 16 bit.
#       However, using an operand prefix (0x66), the CPU will properly
#	take our 48 bit far pointer. (INTeL 80386 Programmer's Reference
#	Manual, Mixing 16-bit and 32-bit code, page 16-6)

	.byte 0x66, 0xea			# prefix + jmpi-opcode		head.S에게 제어권이 넘어 간다. 
code32:	.long	0x1000				# will be set to 0x100000
						# for big kernels
	.word	__KERNEL_CS

# Here's a bunch of information about your current kernel..
kernel_version:	.ascii	UTS_RELEASE
		.ascii	" ("
		.ascii	LINUX_COMPILE_BY
		.ascii	"@@"
		.ascii	LINUX_COMPILE_HOST
		.ascii	") "
		.ascii	UTS_VERSION
		.byte	0

# This is the default real mode switch routine.
# to be called just before protected mode transition
default_switch:
# NMI(Non-Maskable Interrupt)를 포함하여 모든 인터럽트를 disable한다.
	cli					# no interrupts allowed !
	movb	$0x80, %al			# disable NMI for bootup
						# sequence
	outb	%al, $0x70
	lret

# This routine only gets called, if we get loaded by the simple
# bootsect loader _and_ have a bzImage to load.
# Because there is no place left in the 512 bytes of the boot sector,
# we must emigrate to code space here.
bootsect_helper:
# gdt 테이블 생성
	cmpw	$0, %cs:bootsect_es	 # 0x9000(cs):0의 값은 1이다.
	jnz	bootsect_second

	movb	$0x20, %cs:type_of_loader
	movw	%es, %ax
	shrw	$4, %ax
	movb	%ah, %cs:bootsect_src_base+2
	movw	%es, %ax
	movw	%ax, %cs:bootsect_es
	subw	$SYSSEG, %ax
	lret					# nothing else to do for now

bootsect_second:
	pushw	%cx
	pushw	%si
	pushw	%bx
	testw	%bx, %bx			# 64K full?   %bx = 0이니깐
	jne	bootsect_ex

	movw	$0x8000, %cx			# full 64K, INT15 moves words
	pushw	%cs
	popw	%es				# %es = 0x9000
	movw	$bootsect_gdt, %si		# %si = 0x00
	movw	$0x8700, %ax			# %ax = 0x8700
	int	$0x15				# 0x900000번지의 gdt를 0x8000(32768*2 = 64k)만큼 이동시킴
	jc	bootsect_panic			# this, if INT15 fails

	movw	%cs:bootsect_es, %es		# we reset %es to always point	%es = 1
	incb	%cs:bootsect_dst_base+2		# to 0x10000 	64k만큼 늘어남
bootsect_ex:
	movb	%cs:bootsect_dst_base+2, %ah	# %ah = 0x11
	shlb	$4, %ah				# we now have the number of
						# moved frames in %ax	%ah = 0x10
	xorb	%al, %al
	popw	%bx
	popw	%si
	popw	%cx
	lret

bootsect_gdt:
	.word	0, 0, 0, 0
	.word	0, 0, 0, 0

bootsect_src:
	.word	0xffff

bootsect_src_base:
	.byte	0x00, 0x00, 0x01		# base = 0x010000
	.byte	0x93				# typbyte
	.word	0				# limit16,base24 =0

bootsect_dst:
	.word	0xffff

bootsect_dst_base:
# gdt의 첫번째 디스크립트 테이블의 엔트리
	.byte	0x00, 0x00, 0x10		# base = 0x100000
	.byte	0x93				# typbyte
	.word	0				# limit16,base24 =0
	.word	0, 0, 0, 0			# BIOS CS
	.word	0, 0, 0, 0			# BIOS DS

bootsect_es:
	.word	0

bootsect_panic:
	pushw	%cs
	popw	%ds
	cld
	leaw	bootsect_panic_mess, %si
	call	prtstr
	
bootsect_panic_loop:
	jmp	bootsect_panic_loop

bootsect_panic_mess:
	.string	"INT15 refuses to access high mem, giving up."


# This routine tests whether or not A20 is enabled.  If so, it
# exits with zf = 0.
#
# The memory address used, 0x200, is the int $0x80 vector, which
# should be safe.

A20_TEST_ADDR = 4*0x80

a20_test:
	pushw	%cx
	pushw	%ax
	xorw	%cx, %cx			# %cx = 0
	movw	%cx, %fs			# Low memory  %fs = 0
	decw	%cx				# %cx = 최고로 높은 값으로 만든다. 0xffff
	movw	%cx, %gs			# High memory area	%gs = 0xffff
	movw	$A20_TEST_LOOPS, %cx		# %cx = 0x20
	movw	%fs:(A20_TEST_ADDR), %ax	# %ax = (4*0x80) 
	pushw	%ax
a20_test_wait:
	incw	%ax				# %ax = %ax + 1
	movw	%ax, %fs:(A20_TEST_ADDR)	# (4*0x80) = (4*0x80) + 1
	call	delay				# Serialize and make delay constant
	cmpw	%gs:(A20_TEST_ADDR+0x10), %ax	# %ax - (0xffff0 + (4*0x80) + 0x10) 
	loope	a20_test_wait			# cx = 0이거나 zero flag가 1일때까지 loop를 돈다.

	popw	%fs:(A20_TEST_ADDR)
	popw	%ax
	popw	%cx
	ret	

# This routine checks that the keyboard command queue is empty
# (after emptying the output buffers)
#
# Some machines have delusions that the keyboard buffer is always full
# with no keyboard attached...
#
# If there is no keyboard controller, we will usually get 0xff
# to all the reads.  With each IO taking a microsecond and
# a timeout of 100,000 iterations, this can take about half a
# second ("delay" == outb to port 0x80). That should be ok,
# and should also be plenty of time for a real keyboard controller
# to empty.
#

empty_8042:
	pushl	%ecx
	movl	$100000, %ecx

empty_8042_loop:
	decl	%ecx
	jz	empty_8042_end_loop

	call	delay

	inb	$0x64, %al			# 8042 status port
	testb	$1, %al				# output buffer?
	jz	no_output

	call	delay
	inb	$0x60, %al			# read it
	jmp	empty_8042_loop

no_output:
	testb	$2, %al				# is input buffer full?
	jnz	empty_8042_loop			# yes - loop
empty_8042_end_loop:
	popl	%ecx
	ret

# Read the cmos clock. Return the seconds in al
gettime:
	pushw	%cx
	movb	$0x02, %ah
	int	$0x1a
	movb	%dh, %al			# %dh contains the seconds
	andb	$0x0f, %al
	movb	%dh, %ah
	movb	$0x04, %cl
	shrb	%cl, %ah
	aad
	popw	%cx
	ret

# Delay is needed after doing I/O
delay:
	outb	%al,$0x80
	ret

# Descriptor tables
gdt:
	.word	0, 0, 0, 0			# dummy
	.word	0, 0, 0, 0			# unused

	.word	0xFFFF				# 4Gb - (0x100000*0x1000 = 4Gb)		kernel code segment
	.word	0				# base address = 0
	.word	0x9A00				# code read/exec
	.word	0x00CF				# granularity = 4096, 386
						#  (+5th nibble of limit)

	.word	0xFFFF				# 4Gb - (0x100000*0x1000 = 4Gb)		kernel data segment
	.word	0				# base address = 0
	.word	0x9200				# data read/write
	.word	0x00CF				# granularity = 4096, 386
						#  (+5th nibble of limit)
idt_48:
	.word	0				# idt limit = 0
	.word	0, 0				# idt base = 0L
gdt_48:
	.word	0x8000				# gdt limit=2048,
						#  256 GDT entries

	.word	0, 0				# gdt base (filled in later)  위에 있는 gdt의 address가 들어감

# Include video setup & detection code

#include "video.S"

# Setup signature -- must be last
setup_sig1:	.word	SIG1
setup_sig2:	.word	SIG2

# After this point, there is some free space which is used by the video mode
# handling code to store the temporary mode table (not used by the kernel).

modelist:

.text
endtext:
.data
enddata:
.bss
endbss:
@


1.1.1.1
log
@linux 2.4.20 분석
@
text
@@
