![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to head.S CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / boot|
Return to head.S CVS log | Up to [Early Linux] / linux / boot |
1.1 ! root 1: /* ! 2: * linux/boot/head.s ! 3: * ! 4: * Copyright (C) 1991, 1992 Linus Torvalds ! 5: */ ! 6: ! 7: #if (MAX_MEGABYTES != 16) && (MAX_MEGABYTES != 32) ! 8: #error "MAX_MEGABYTES must be 16 or 32" ! 9: #endif ! 10: ! 11: /* ! 12: * head.s contains the 32-bit startup code. ! 13: * ! 14: * NOTE!!! Startup happens at absolute address 0x00000000, which is also where ! 15: * the page directory will exist. The startup code will be overwritten by ! 16: * the page directory. ! 17: */ ! 18: .text ! 19: .globl _idt,_gdt,_swapper_pg_dir,_tmp_floppy_area,_floppy_track_buffer ! 20: /* ! 21: * swapper_pg_dir is the main page directory, address 0x00000000 ! 22: */ ! 23: _swapper_pg_dir: ! 24: startup_32: ! 25: cld ! 26: movl $0x10,%eax ! 27: mov %ax,%ds ! 28: mov %ax,%es ! 29: mov %ax,%fs ! 30: mov %ax,%gs ! 31: lss _stack_start,%esp ! 32: call setup_idt ! 33: xorl %eax,%eax ! 34: 1: incl %eax # check that A20 really IS enabled ! 35: movl %eax,0x000000 # loop forever if it isn't ! 36: cmpl %eax,0x100000 ! 37: je 1b ! 38: /* check if it is 486 or 386. */ ! 39: movl %esp,%edi # save stack pointer ! 40: andl $0xfffffffc,%esp # align stack to avoid AC fault ! 41: pushfl # push EFLAGS ! 42: popl %eax # get EFLAGS ! 43: movl %eax,%ecx # save original EFLAGS ! 44: xorl $0x40000,%eax # flip AC bit in EFLAGS ! 45: pushl %eax # copy to EFLAGS ! 46: popfl # set EFLAGS ! 47: pushfl # get new EFLAGS ! 48: popl %eax # put it in eax ! 49: xorl %ecx,%eax # check if AC bit is changed. zero is 486. ! 50: jz 1f # 486 ! 51: pushl %ecx # restore original EFLAGS ! 52: popfl ! 53: movl %edi,%esp # restore esp ! 54: movl %cr0,%eax # 386 ! 55: andl $0x80000011,%eax # Save PG,PE,ET ! 56: orl $2,%eax # set MP ! 57: jmp 2f ! 58: /* ! 59: * NOTE! 486 should set bit 16, to check for write-protect in supervisor ! 60: * mode. Then it would be unnecessary with the "verify_area()"-calls. ! 61: * 486 users probably want to set the NE (#5) bit also, so as to use ! 62: * int 16 for math errors. ! 63: */ ! 64: 1: pushl %ecx # restore original EFLAGS ! 65: popfl ! 66: movl %edi,%esp # restore esp ! 67: movl %cr0,%eax # 486 ! 68: andl $0x80000011,%eax # Save PG,PE,ET ! 69: orl $0x10022,%eax # set NE and MP ! 70: 2: movl %eax,%cr0 ! 71: call check_x87 ! 72: jmp after_page_tables ! 73: ! 74: /* ! 75: * We depend on ET to be correct. This checks for 287/387. ! 76: */ ! 77: check_x87: ! 78: fninit ! 79: fstsw %ax ! 80: cmpb $0,%al ! 81: je 1f ! 82: movl %cr0,%eax /* no coprocessor: have to set bits */ ! 83: xorl $6,%eax /* reset MP, set EM */ ! 84: movl %eax,%cr0 ! 85: ret ! 86: .align 2 ! 87: 1: .byte 0xDB,0xE4 /* fsetpm for 287, ignored by 387 */ ! 88: ret ! 89: ! 90: /* ! 91: * setup_idt ! 92: * ! 93: * sets up a idt with 256 entries pointing to ! 94: * ignore_int, interrupt gates. It doesn't actually load ! 95: * idt - that can be done only after paging has been enabled ! 96: * and the kernel moved to 0xC0000000. Interrupts ! 97: * are enabled elsewhere, when we can be relatively ! 98: * sure everything is ok. This routine will be over- ! 99: * written by the page tables. ! 100: */ ! 101: setup_idt: ! 102: lea ignore_int,%edx ! 103: movl $0x00080000,%eax ! 104: movw %dx,%ax /* selector = 0x0008 = cs */ ! 105: movw $0x8E00,%dx /* interrupt gate - dpl=0, present */ ! 106: ! 107: lea _idt,%edi ! 108: mov $256,%ecx ! 109: rp_sidt: ! 110: movl %eax,(%edi) ! 111: movl %edx,4(%edi) ! 112: addl $8,%edi ! 113: dec %ecx ! 114: jne rp_sidt ! 115: ret ! 116: ! 117: /* ! 118: * I put the kernel page tables right after the page directory, ! 119: * using 4 of them to span 16 Mb of physical memory. People with ! 120: * more than 16MB will have to expand this. ! 121: * When MAX_MEGABYTES == 32, this is set up for a maximum of 32 MB ! 122: * (ref: 17Apr92) (redone for 0.97 kernel changes, 1Aug92, ref) ! 123: */ ! 124: .org 0x1000 ! 125: pg0: ! 126: ! 127: .org 0x2000 ! 128: pg1: ! 129: ! 130: .org 0x3000 ! 131: pg2: ! 132: ! 133: .org 0x4000 ! 134: pg3: ! 135: ! 136: .org 0x5000 ! 137: #if MAX_MEGABYTES == 32 ! 138: pg4: ! 139: ! 140: .org 0x6000 ! 141: pg5: ! 142: ! 143: .org 0x7000 ! 144: pg6: ! 145: ! 146: .org 0x8000 ! 147: pg7: ! 148: ! 149: .org 0x9000 ! 150: #endif ! 151: /* ! 152: * empty_bad_page is a bogus page that will be used when out of memory, ! 153: * so that a process isn't accidentally killed due to a page fault when ! 154: * it is running in kernel mode.. ! 155: */ ! 156: .globl _empty_bad_page ! 157: _empty_bad_page: ! 158: ! 159: #if MAX_MEGABYTES == 32 ! 160: .org 0xa000 ! 161: #else ! 162: .org 0x6000 ! 163: #endif ! 164: /* ! 165: * empty_bad_page_table is similar to the above, but is used when the ! 166: * system needs a bogus page-table ! 167: */ ! 168: .globl _empty_bad_page_table ! 169: _empty_bad_page_table: ! 170: ! 171: #if MAX_MEGABYTES == 32 ! 172: .org 0xb000 ! 173: #else ! 174: .org 0x7000 ! 175: #endif ! 176: /* ! 177: * tmp_floppy_area is used by the floppy-driver when DMA cannot ! 178: * reach to a buffer-block. It needs to be aligned, so that it isn't ! 179: * on a 64kB border. ! 180: */ ! 181: _tmp_floppy_area: ! 182: .fill 1024,1,0 ! 183: /* ! 184: * floppy_track_buffer is used to buffer one track of floppy data: it ! 185: * has to be separate from the tmp_floppy area, as otherwise a single- ! 186: * sector read/write can mess it up. It can contain one full track of ! 187: * data (18*2*512 bytes). ! 188: */ ! 189: _floppy_track_buffer: ! 190: .fill 512*2*18,1,0 ! 191: ! 192: after_page_tables: ! 193: call setup_paging ! 194: lgdt gdt_descr ! 195: lidt idt_descr ! 196: ljmp $0x08,$1f ! 197: 1: movl $0x10,%eax # reload all the segment registers ! 198: mov %ax,%ds # after changing gdt. ! 199: mov %ax,%es ! 200: mov %ax,%fs ! 201: mov %ax,%gs ! 202: lss _stack_start,%esp ! 203: pushl $0 # These are the parameters to main :-) ! 204: pushl $0 ! 205: pushl $0 ! 206: cld # gcc2 wants the direction flag cleared at all times ! 207: call _start_kernel ! 208: L6: ! 209: jmp L6 # main should never return here, but ! 210: # just in case, we know what happens. ! 211: ! 212: /* This is the default interrupt "handler" :-) */ ! 213: int_msg: ! 214: .asciz "Unknown interrupt\n\r" ! 215: .align 2 ! 216: ignore_int: ! 217: cld ! 218: pushl %eax ! 219: pushl %ecx ! 220: pushl %edx ! 221: push %ds ! 222: push %es ! 223: push %fs ! 224: movl $0x10,%eax ! 225: mov %ax,%ds ! 226: mov %ax,%es ! 227: mov %ax,%fs ! 228: pushl $int_msg ! 229: call _printk ! 230: popl %eax ! 231: pop %fs ! 232: pop %es ! 233: pop %ds ! 234: popl %edx ! 235: popl %ecx ! 236: popl %eax ! 237: iret ! 238: ! 239: ! 240: /* ! 241: * Setup_paging ! 242: * ! 243: * This routine sets up paging by setting the page bit ! 244: * in cr0. The page tables are set up, identity-mapping ! 245: * the first 16MB. The pager assumes that no illegal ! 246: * addresses are produced (ie >4Mb on a 4Mb machine). ! 247: * ! 248: * NOTE! Although all physical memory should be identity ! 249: * mapped by this routine, only the kernel page functions ! 250: * use the >1Mb addresses directly. All "normal" functions ! 251: * use just the lower 1Mb, or the local data space, which ! 252: * will be mapped to some other place - mm keeps track of ! 253: * that. ! 254: * ! 255: * For those with more memory than 16 Mb - tough luck. I've ! 256: * not got it, why should you :-) The source is here. Change ! 257: * it. (Seriously - it shouldn't be too difficult. Mostly ! 258: * change some constants etc. I left it at 16Mb, as my machine ! 259: * even cannot be extended past that (ok, but it was cheap :-) ! 260: * I've tried to show which constants to change by having ! 261: * some kind of marker at them (search for "16Mb"), but I ! 262: * won't guarantee that's all :-( ) ! 263: * ! 264: * (ref: added support for up to 32mb, 17Apr92) -- Rik Faith ! 265: * (ref: update, 25Sept92) -- [email protected] ! 266: */ ! 267: .align 2 ! 268: setup_paging: ! 269: #if MAXMEGABYTES == 32 ! 270: movl $1024*9,%ecx /* 9 pages - swapper_pg_dir+8 page tables */ ! 271: #else ! 272: movl $1024*5,%ecx /* 5 pages - swapper_pg_dir+4 page tables */ ! 273: #endif ! 274: xorl %eax,%eax ! 275: xorl %edi,%edi /* swapper_pg_dir is at 0x000 */ ! 276: cld;rep;stosl ! 277: /* Identity-map the kernel in low 4MB memory for ease of transition */ ! 278: movl $pg0+7,_swapper_pg_dir /* set present bit/user r/w */ ! 279: /* But the real place is at 0xC0000000 */ ! 280: movl $pg0+7,_swapper_pg_dir+3072 /* set present bit/user r/w */ ! 281: movl $pg1+7,_swapper_pg_dir+3076 /* --------- " " --------- */ ! 282: movl $pg2+7,_swapper_pg_dir+3080 /* --------- " " --------- */ ! 283: movl $pg3+7,_swapper_pg_dir+3084 /* --------- " " --------- */ ! 284: #if MAX_MEGABYTES == 32 ! 285: movl $pg4+7,_swapper_pg_dir+3088 /* --------- " " --------- */ ! 286: movl $pg5+7,_swapper_pg_dir+3092 /* --------- " " --------- */ ! 287: movl $pg6+7,_swapper_pg_dir+3096 /* --------- " " --------- */ ! 288: movl $pg7+7,_swapper_pg_dir+3100 /* --------- " " --------- */ ! 289: ! 290: movl $pg7+4092,%edi ! 291: movl $0x1fff007,%eax /* 32Mb - 4096 + 7 (r/w user,p) */ ! 292: #else ! 293: movl $pg3+4092,%edi ! 294: movl $0x0fff007,%eax /* 16Mb - 4096 + 7 (r/w user,p) */ ! 295: #endif ! 296: std ! 297: 1: stosl /* fill pages backwards - more efficient :-) */ ! 298: subl $0x1000,%eax ! 299: jge 1b ! 300: cld ! 301: xorl %eax,%eax /* swapper_pg_dir is at 0x0000 */ ! 302: movl %eax,%cr3 /* cr3 - page directory start */ ! 303: movl %cr0,%eax ! 304: orl $0x80000000,%eax ! 305: movl %eax,%cr0 /* set paging (PG) bit */ ! 306: ret /* this also flushes prefetch-queue */ ! 307: ! 308: /* ! 309: * The interrupt descriptor table has room for 256 idt's ! 310: */ ! 311: .align 4 ! 312: .word 0 ! 313: idt_descr: ! 314: .word 256*8-1 # idt contains 256 entries ! 315: .long 0xc0000000+_idt ! 316: ! 317: .align 4 ! 318: _idt: ! 319: .fill 256,8,0 # idt is uninitialized ! 320: ! 321: /* ! 322: * The real GDT is also 256 entries long - no real reason ! 323: */ ! 324: .align 4 ! 325: .word 0 ! 326: gdt_descr: ! 327: .word 256*8-1 ! 328: .long 0xc0000000+_gdt ! 329: ! 330: /* ! 331: * This gdt setup gives the kernel a 1GB address space at virtual ! 332: * address 0xC0000000 - space enough for expansion, I hope. ! 333: */ ! 334: .align 4 ! 335: _gdt: ! 336: .quad 0x0000000000000000 /* NULL descriptor */ ! 337: .quad 0xc0c39a000000ffff /* 1GB at 0xC0000000 */ ! 338: .quad 0xc0c392000000ffff /* 1GB */ ! 339: .quad 0x0000000000000000 /* TEMPORARY - don't use */ ! 340: .fill 252,8,0 /* space for LDT's and TSS's etc */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.