![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to start.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / i386|
Return to start.s CVS log | Up to [Apple XNU] / XNU / osfmk / i386 |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * @OSF_COPYRIGHT@ ! 24: */ ! 25: /* ! 26: * Mach Operating System ! 27: * Copyright (c) 1991,1990 Carnegie Mellon University ! 28: * All Rights Reserved. ! 29: * ! 30: * Permission to use, copy, modify and distribute this software and its ! 31: * documentation is hereby granted, provided that both the copyright ! 32: * notice and this permission notice appear in all copies of the ! 33: * software, derivative works or modified versions, and any portions ! 34: * thereof, and that both notices appear in supporting documentation. ! 35: * ! 36: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 37: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 38: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 39: * ! 40: * Carnegie Mellon requests users of this software to return to ! 41: * ! 42: * Software Distribution Coordinator or [email protected] ! 43: * School of Computer Science ! 44: * Carnegie Mellon University ! 45: * Pittsburgh PA 15213-3890 ! 46: * ! 47: * any improvements or extensions that they make and grant Carnegie Mellon ! 48: * the rights to redistribute these changes. ! 49: */ ! 50: /* ! 51: */ ! 52: ! 53: #include <platforms.h> ! 54: #include <cpus.h> ! 55: #include <mach_kdb.h> ! 56: ! 57: #include <i386/asm.h> ! 58: #include <i386/proc_reg.h> ! 59: #include <assym.s> ! 60: ! 61: #if NCPUS > 1 ! 62: ! 63: #define CX(addr,reg) addr(,reg,4) ! 64: ! 65: #else ! 66: ! 67: #define CPU_NUMBER(reg) ! 68: #define CX(addr,reg) addr ! 69: ! 70: #endif /* NCPUS > 1 */ ! 71: ! 72: #include <i386/AT386/mp/mp.h> ! 73: ! 74: /* ! 75: * GAS won't handle an intersegment jump with a relocatable offset. ! 76: */ ! 77: #define LJMP(segment,address) \ ! 78: .byte 0xea ;\ ! 79: .long address ;\ ! 80: .word segment ! 81: ! 82: ! 83: ! 84: #define KVTOPHYS (-KERNELBASE) ! 85: #define KVTOLINEAR LINEAR_KERNELBASE ! 86: ! 87: ! 88: #define PA(addr) (addr)+KVTOPHYS ! 89: #define VA(addr) (addr)-KVTOPHYS ! 90: ! 91: .data ! 92: .align 2 ! 93: .globl EXT(_kick_buffer_) ! 94: EXT(_kick_buffer_): ! 95: .long 1 ! 96: .long 3 ! 97: .set .,.+16836 ! 98: /* ! 99: * Interrupt and bootup stack for initial processor. ! 100: */ ! 101: .align ALIGN ! 102: .globl EXT(intstack) ! 103: EXT(intstack): ! 104: .set ., .+INTSTACK_SIZE ! 105: .globl EXT(eintstack) ! 106: EXT(eintstack:) ! 107: ! 108: #if NCPUS == 1 ! 109: .globl EXT(int_stack_high) /* all interrupt stacks */ ! 110: EXT(int_stack_high): /* must lie below this */ ! 111: .long EXT(eintstack) /* address */ ! 112: ! 113: .globl EXT(int_stack_top) /* top of interrupt stack */ ! 114: EXT(int_stack_top): ! 115: .long EXT(eintstack) ! 116: #endif ! 117: ! 118: #if MACH_KDB ! 119: /* ! 120: * Kernel debugger stack for each processor. ! 121: */ ! 122: .align ALIGN ! 123: .globl EXT(db_stack_store) ! 124: EXT(db_stack_store): ! 125: .set ., .+(INTSTACK_SIZE*NCPUS) ! 126: ! 127: /* ! 128: * Stack for last-ditch debugger task for each processor. ! 129: */ ! 130: .align ALIGN ! 131: .globl EXT(db_task_stack_store) ! 132: EXT(db_task_stack_store): ! 133: .set ., .+(INTSTACK_SIZE*NCPUS) ! 134: #endif /* MACH_KDB */ ! 135: ! 136: /* ! 137: * per-processor kernel debugger stacks ! 138: */ ! 139: .align ALIGN ! 140: .globl EXT(kgdb_stack_store) ! 141: EXT(kgdb_stack_store): ! 142: .set ., .+(INTSTACK_SIZE*NCPUS) ! 143: ! 144: ! 145: /* ! 146: * Pointers to GDT and IDT. These contain linear addresses. ! 147: */ ! 148: .align ALIGN ! 149: .globl EXT(gdtptr) ! 150: LEXT(gdtptr) ! 151: .word Times(8,GDTSZ)-1 ! 152: .long EXT(gdt)+KVTOLINEAR ! 153: ! 154: .align ALIGN ! 155: .globl EXT(idtptr) ! 156: LEXT(idtptr) ! 157: .word Times(8,IDTSZ)-1 ! 158: .long EXT(idt)+KVTOLINEAR ! 159: ! 160: #if NCPUS > 1 ! 161: .data ! 162: /* ! 163: * start_lock is very special. We initialize the ! 164: * lock at allocation time rather than at run-time. ! 165: * Although start_lock should be an instance of a ! 166: * hw_lock, we hand-code all manipulation of the lock ! 167: * because the hw_lock code may require function calls; ! 168: * and we'd rather not introduce another dependency on ! 169: * a working stack at this point. ! 170: */ ! 171: .globl EXT(start_lock) ! 172: EXT(start_lock): ! 173: .long 0 /* synchronizes processor startup */ ! 174: ! 175: .globl EXT(master_is_up) ! 176: EXT(master_is_up): ! 177: .long 0 /* 1 when OK for other processors */ ! 178: /* to start */ ! 179: .globl EXT(mp_boot_pde) ! 180: EXT(mp_boot_pde): ! 181: .long 0 ! 182: #endif /* NCPUS > 1 */ ! 183: ! 184: /* ! 185: * All CPUs start here. ! 186: * ! 187: * Environment: ! 188: * protected mode, no paging, flat 32-bit address space. ! 189: * (Code/data/stack segments have base == 0, limit == 4G) ! 190: */ ! 191: .text ! 192: .align ALIGN ! 193: .globl EXT(pstart) ! 194: .globl EXT(_start) ! 195: LEXT(_start) ! 196: LEXT(pstart) ! 197: mov $0,%ax /* fs must be zeroed; */ ! 198: mov %ax,%fs /* some bootstrappers don`t do this */ ! 199: mov %ax,%gs ! 200: ! 201: #if NCPUS > 1 ! 202: jmp 1f ! 203: 0: cmpl $0,PA(EXT(start_lock)) ! 204: jne 0b ! 205: 1: movb $1,%eax ! 206: xchgl %eax,PA(EXT(start_lock)) /* locked */ ! 207: testl %eax,%eax ! 208: jnz 0b ! 209: ! 210: cmpl $0,PA(EXT(master_is_up)) /* are we first? */ ! 211: jne EXT(slave_start) /* no -- system already up. */ ! 212: movl $1,PA(EXT(master_is_up)) /* others become slaves */ ! 213: #endif /* NCPUS > 1 */ ! 214: ! 215: /* ! 216: * Get startup parameters. ! 217: */ ! 218: ! 219: #include <i386/AT386/asm_startup.h> ! 220: ! 221: /* ! 222: * Build initial page table directory and page tables. ! 223: * %ebx holds first available physical address. ! 224: */ ! 225: ! 226: addl $(NBPG-1),%ebx /* round first avail physical addr */ ! 227: andl $(-NBPG),%ebx /* to machine page size */ ! 228: leal -KVTOPHYS(%ebx),%eax /* convert to virtual address */ ! 229: movl %eax,PA(EXT(kpde)) /* save as kernel page table directory */ ! 230: movl %ebx,%cr3 /* set physical address in CR3 now */ ! 231: ! 232: movl %ebx,%edi /* clear page table directory */ ! 233: movl $(PTES_PER_PAGE),%ecx /* one page of ptes */ ! 234: xorl %eax,%eax ! 235: cld ! 236: rep ! 237: stosl /* edi now points to next page */ ! 238: ! 239: /* ! 240: * Use next few pages for page tables. ! 241: */ ! 242: addl $(KERNELBASEPDE),%ebx /* point to pde for kernel base */ ! 243: movl %edi,%esi /* point to end of current pte page */ ! 244: ! 245: /* ! 246: * Enter 1-1 mappings for kernel and for kernel page tables. ! 247: */ ! 248: movl $(INTEL_PTE_KERNEL),%eax /* set up pte prototype */ ! 249: 0: ! 250: cmpl %esi,%edi /* at end of pte page? */ ! 251: jb 1f /* if so: */ ! 252: movl %edi,%edx /* get pte address (physical) */ ! 253: andl $(-NBPG),%edx /* mask out offset in page */ ! 254: orl $(INTEL_PTE_KERNEL),%edx /* add pte bits */ ! 255: movl %edx,(%ebx) /* set pde */ ! 256: addl $4,%ebx /* point to next pde */ ! 257: movl %edi,%esi /* point to */ ! 258: addl $(NBPG),%esi /* end of new pte page */ ! 259: 1: ! 260: movl %eax,(%edi) /* set pte */ ! 261: addl $4,%edi /* advance to next pte */ ! 262: addl $(NBPG),%eax /* advance to next phys page */ ! 263: cmpl %edi,%eax /* have we mapped this pte page yet? */ ! 264: jb 0b /* loop if not */ ! 265: ! 266: /* ! 267: * Zero rest of last pte page. ! 268: */ ! 269: xor %eax,%eax /* don`t map yet */ ! 270: 2: cmpl %esi,%edi /* at end of pte page? */ ! 271: jae 3f ! 272: movl %eax,(%edi) /* zero mapping */ ! 273: addl $4,%edi ! 274: jmp 2b ! 275: 3: ! 276: ! 277: #if NCPUS > 1 ! 278: /* ! 279: * Grab (waste?) another page for a bootstrap page directory ! 280: * for the other CPUs. We don't want the running CPUs to see ! 281: * addresses 0..3fffff mapped 1-1. ! 282: */ ! 283: movl %edi,PA(EXT(mp_boot_pde)) /* save its physical address */ ! 284: movl $(PTES_PER_PAGE),%ecx /* and clear it */ ! 285: rep ! 286: stosl ! 287: #endif /* NCPUS > 1 */ ! 288: movl %edi,PA(EXT(first_avail)) /* save first available phys addr */ ! 289: ! 290: /* ! 291: * pmap_bootstrap will enter rest of mappings. ! 292: */ ! 293: ! 294: /* ! 295: * Fix initial descriptor tables. ! 296: */ ! 297: lea PA(EXT(idt)),%esi /* fix IDT */ ! 298: movl $(IDTSZ),%ecx ! 299: movl $(PA(fix_idt_ret)),%ebx ! 300: jmp fix_desc_common /* (cannot use stack) */ ! 301: fix_idt_ret: ! 302: ! 303: lea PA(EXT(gdt)),%esi /* fix GDT */ ! 304: movl $(GDTSZ),%ecx ! 305: movl $(PA(fix_gdt_ret)),%ebx ! 306: jmp fix_desc_common /* (cannot use stack) */ ! 307: fix_gdt_ret: ! 308: ! 309: lea PA(EXT(ldt)),%esi /* fix LDT */ ! 310: movl $(LDTSZ),%ecx ! 311: movl $(PA(fix_ldt_ret)),%ebx ! 312: jmp fix_desc_common /* (cannot use stack) */ ! 313: fix_ldt_ret: ! 314: ! 315: /* ! 316: * Turn on paging. ! 317: */ ! 318: movl %cr3,%eax /* retrieve kernel PDE phys address */ ! 319: movl KERNELBASEPDE(%eax),%ecx ! 320: movl %ecx,(%eax) /* set it also as pte for location */ ! 321: /* 0..3fffff, so that the code */ ! 322: /* that enters paged mode is mapped */ ! 323: /* to identical addresses after */ ! 324: /* paged mode is enabled */ ! 325: ! 326: movl $EXT(pag_start),%ebx /* first paged code address */ ! 327: ! 328: movl %cr0,%eax ! 329: orl $(CR0_PG),%eax /* set PG bit in CR0 */ ! 330: orl $(CR0_WP),%eax ! 331: movl %eax,%cr0 /* to enable paging */ ! 332: ! 333: jmp *%ebx /* flush prefetch queue */ ! 334: ! 335: /* ! 336: * We are now paging, and can run with correct addresses. ! 337: */ ! 338: LEXT(pag_start) ! 339: lgdt EXT(gdtptr) /* load GDT */ ! 340: lidt EXT(idtptr) /* load IDT */ ! 341: LJMP(KERNEL_CS,EXT(vstart)) /* switch to kernel code segment */ ! 342: ! 343: /* ! 344: * Master is now running with correct addresses. ! 345: */ ! 346: LEXT(vstart) ! 347: mov $(KERNEL_DS),%ax /* set kernel data segment */ ! 348: mov %ax,%ds ! 349: mov %ax,%es ! 350: mov %ax,%ss ! 351: mov %ax,EXT(ktss)+TSS_SS0 /* set kernel stack segment */ ! 352: /* for traps to kernel */ ! 353: #if MACH_KDB ! 354: mov %ax,EXT(dbtss)+TSS_SS0 /* likewise for debug task switch */ ! 355: mov %cr3,%eax /* get PDBR into debug TSS */ ! 356: mov %eax,EXT(dbtss)+TSS_PDBR ! 357: mov $0,%eax ! 358: #endif ! 359: ! 360: movw $(KERNEL_LDT),%ax /* get LDT segment */ ! 361: lldt %ax /* load LDT */ ! 362: #if MACH_KDB ! 363: mov %ax,EXT(ktss)+TSS_LDT /* store LDT in two TSS, as well... */ ! 364: mov %ax,EXT(dbtss)+TSS_LDT /* ...matters if we switch tasks */ ! 365: #endif ! 366: movw $(KERNEL_TSS),%ax ! 367: ltr %ax /* set up KTSS */ ! 368: ! 369: mov $CPU_DATA,%ax ! 370: mov %ax,%gs ! 371: ! 372: lea EXT(eintstack),%esp /* switch to the bootup stack */ ! 373: call EXT(machine_startup) /* run C code */ ! 374: /*NOTREACHED*/ ! 375: hlt ! 376: ! 377: #if NCPUS > 1 ! 378: /* ! 379: * master_up is used by the master cpu to signify that it is done ! 380: * with the interrupt stack, etc. See the code in pstart and svstart ! 381: * that this interlocks with. ! 382: */ ! 383: .align ALIGN ! 384: .globl EXT(master_up) ! 385: LEXT(master_up) ! 386: pushl %ebp /* set up */ ! 387: movl %esp,%ebp /* stack frame */ ! 388: movl $0,%ecx /* unlock start_lock */ ! 389: xchgl %ecx,EXT(start_lock) /* since we are no longer using */ ! 390: /* bootstrap stack */ ! 391: leave /* pop stack frame */ ! 392: ret ! 393: ! 394: /* ! 395: * We aren't the first. Call slave_main to initialize the processor ! 396: * and get Mach going on it. ! 397: */ ! 398: .align ALIGN ! 399: .globl EXT(slave_start) ! 400: LEXT(slave_start) ! 401: cli /* disable interrupts, so we don`t */ ! 402: /* need IDT for a while */ ! 403: movl EXT(kpde)+KVTOPHYS,%ebx /* get PDE virtual address */ ! 404: addl $(KVTOPHYS),%ebx /* convert to physical address */ ! 405: ! 406: movl PA(EXT(mp_boot_pde)),%edx /* point to the bootstrap PDE */ ! 407: movl KERNELBASEPDE(%ebx),%eax ! 408: /* point to pte for KERNELBASE */ ! 409: movl %eax,KERNELBASEPDE(%edx) ! 410: /* set in bootstrap PDE */ ! 411: movl %eax,(%edx) /* set it also as pte for location */ ! 412: /* 0..3fffff, so that the code */ ! 413: /* that enters paged mode is mapped */ ! 414: /* to identical addresses after */ ! 415: /* paged mode is enabled */ ! 416: movl %edx,%cr3 /* use bootstrap PDE to enable paging */ ! 417: ! 418: movl $EXT(spag_start),%edx /* first paged code address */ ! 419: ! 420: movl %cr0,%eax ! 421: orl $(CR0_PG),%eax /* set PG bit in CR0 */ ! 422: orl $(CR0_WP),%eax ! 423: movl %eax,%cr0 /* to enable paging */ ! 424: ! 425: jmp *%edx /* flush prefetch queue. */ ! 426: ! 427: /* ! 428: * We are now paging, and can run with correct addresses. ! 429: */ ! 430: LEXT(spag_start) ! 431: ! 432: lgdt EXT(gdtptr) /* load GDT */ ! 433: lidt EXT(idtptr) /* load IDT */ ! 434: LJMP(KERNEL_CS,EXT(svstart)) /* switch to kernel code segment */ ! 435: ! 436: /* ! 437: * Slave is now running with correct addresses. ! 438: */ ! 439: LEXT(svstart) ! 440: mov $(KERNEL_DS),%ax /* set kernel data segment */ ! 441: mov %ax,%ds ! 442: mov %ax,%es ! 443: mov %ax,%ss ! 444: ! 445: movl %ebx,%cr3 /* switch to the real kernel PDE */ ! 446: ! 447: CPU_NUMBER(%eax) ! 448: movl CX(EXT(interrupt_stack),%eax),%esp /* get stack */ ! 449: addl $(INTSTACK_SIZE),%esp /* point to top */ ! 450: xorl %ebp,%ebp /* for completeness */ ! 451: ! 452: movl $0,%ecx /* unlock start_lock */ ! 453: xchgl %ecx,EXT(start_lock) /* since we are no longer using */ ! 454: /* bootstrap stack */ ! 455: ! 456: /* ! 457: * switch to the per-cpu descriptor tables ! 458: */ ! 459: ! 460: pushl %eax /* pass CPU number */ ! 461: call EXT(mp_desc_init) /* set up local table */ ! 462: /* pointer returned in %eax */ ! 463: subl $4,%esp /* get space to build pseudo-descriptors */ ! 464: ! 465: CPU_NUMBER(%eax) ! 466: movw $(GDTSZ*8-1),0(%esp) /* set GDT size in GDT descriptor */ ! 467: movl CX(EXT(mp_gdt),%eax),%edx ! 468: addl $KVTOLINEAR,%edx ! 469: movl %edx,2(%esp) /* point to local GDT (linear address) */ ! 470: lgdt 0(%esp) /* load new GDT */ ! 471: ! 472: movw $(IDTSZ*8-1),0(%esp) /* set IDT size in IDT descriptor */ ! 473: movl CX(EXT(mp_idt),%eax),%edx ! 474: addl $KVTOLINEAR,%edx ! 475: movl %edx,2(%esp) /* point to local IDT (linear address) */ ! 476: lidt 0(%esp) /* load new IDT */ ! 477: ! 478: movw $(KERNEL_LDT),%ax ! 479: lldt %ax /* load new LDT */ ! 480: ! 481: movw $(KERNEL_TSS),%ax ! 482: ltr %ax /* load new KTSS */ ! 483: ! 484: mov $CPU_DATA,%ax ! 485: mov %ax,%gs ! 486: ! 487: call EXT(slave_main) /* start MACH */ ! 488: /*NOTREACHED*/ ! 489: hlt ! 490: #endif /* NCPUS > 1 */ ! 491: ! 492: /* ! 493: * Convert a descriptor from fake to real format. ! 494: * ! 495: * Calls from assembly code: ! 496: * %ebx = return address (physical) CANNOT USE STACK ! 497: * %esi = descriptor table address (physical) ! 498: * %ecx = number of descriptors ! 499: * ! 500: * Calls from C: ! 501: * 0(%esp) = return address ! 502: * 4(%esp) = descriptor table address (physical) ! 503: * 8(%esp) = number of descriptors ! 504: * ! 505: * Fake descriptor format: ! 506: * bytes 0..3 base 31..0 ! 507: * bytes 4..5 limit 15..0 ! 508: * byte 6 access byte 2 | limit 19..16 ! 509: * byte 7 access byte 1 ! 510: * ! 511: * Real descriptor format: ! 512: * bytes 0..1 limit 15..0 ! 513: * bytes 2..3 base 15..0 ! 514: * byte 4 base 23..16 ! 515: * byte 5 access byte 1 ! 516: * byte 6 access byte 2 | limit 19..16 ! 517: * byte 7 base 31..24 ! 518: * ! 519: * Fake gate format: ! 520: * bytes 0..3 offset ! 521: * bytes 4..5 selector ! 522: * byte 6 word count << 4 (to match fake descriptor) ! 523: * byte 7 access byte 1 ! 524: * ! 525: * Real gate format: ! 526: * bytes 0..1 offset 15..0 ! 527: * bytes 2..3 selector ! 528: * byte 4 word count ! 529: * byte 5 access byte 1 ! 530: * bytes 6..7 offset 31..16 ! 531: */ ! 532: .globl EXT(fix_desc) ! 533: LEXT(fix_desc) ! 534: pushl %ebp /* set up */ ! 535: movl %esp,%ebp /* stack frame */ ! 536: pushl %esi /* save registers */ ! 537: pushl %ebx ! 538: movl B_ARG0,%esi /* point to first descriptor */ ! 539: movl B_ARG1,%ecx /* get number of descriptors */ ! 540: lea 0f,%ebx /* get return address */ ! 541: jmp fix_desc_common /* call internal routine */ ! 542: 0: popl %ebx /* restore registers */ ! 543: popl %esi ! 544: leave /* pop stack frame */ ! 545: ret /* return */ ! 546: ! 547: fix_desc_common: ! 548: 0: ! 549: movw 6(%esi),%dx /* get access byte */ ! 550: movb %dh,%al ! 551: andb $0x14,%al ! 552: cmpb $0x04,%al /* gate or descriptor? */ ! 553: je 1f ! 554: ! 555: /* descriptor */ ! 556: movl 0(%esi),%eax /* get base in eax */ ! 557: rol $16,%eax /* swap 15..0 with 31..16 */ ! 558: /* (15..0 in correct place) */ ! 559: movb %al,%dl /* combine bits 23..16 with ACC1 */ ! 560: /* in dh/dl */ ! 561: movb %ah,7(%esi) /* store bits 31..24 in correct place */ ! 562: movw 4(%esi),%ax /* move limit bits 0..15 to word 0 */ ! 563: movl %eax,0(%esi) /* store (bytes 0..3 correct) */ ! 564: movw %dx,4(%esi) /* store bytes 4..5 */ ! 565: jmp 2f ! 566: ! 567: /* gate */ ! 568: 1: ! 569: movw 4(%esi),%ax /* get selector */ ! 570: shrb $4,%dl /* shift word count to proper place */ ! 571: movw %dx,4(%esi) /* store word count / ACC1 */ ! 572: movw 2(%esi),%dx /* get offset 16..31 */ ! 573: movw %dx,6(%esi) /* store in correct place */ ! 574: movw %ax,2(%esi) /* store selector in correct place */ ! 575: 2: ! 576: addl $8,%esi /* bump to next descriptor */ ! 577: loop 0b /* repeat */ ! 578: jmp *%ebx /* all done */ ! 579: ! 580: /* ! 581: * put arg in kbd leds and spin a while ! 582: * eats eax, ecx, edx ! 583: */ ! 584: #define K_RDWR 0x60 ! 585: #define K_CMD_LEDS 0xed ! 586: #define K_STATUS 0x64 ! 587: #define K_IBUF_FULL 0x02 /* input (to kbd) buffer full */ ! 588: #define K_OBUF_FULL 0x01 /* output (from kbd) buffer full */ ! 589: ! 590: ENTRY(set_kbd_leds) ! 591: mov S_ARG0,%cl /* save led value */ ! 592: ! 593: 0: inb $(K_STATUS),%al /* get kbd status */ ! 594: testb $(K_IBUF_FULL),%al /* input busy? */ ! 595: jne 0b /* loop until not */ ! 596: ! 597: mov $(K_CMD_LEDS),%al /* K_CMD_LEDS */ ! 598: outb %al,$(K_RDWR) /* to kbd */ ! 599: ! 600: 0: inb $(K_STATUS),%al /* get kbd status */ ! 601: testb $(K_OBUF_FULL),%al /* output present? */ ! 602: je 0b /* loop if not */ ! 603: ! 604: inb $(K_RDWR),%al /* read status (and discard) */ ! 605: ! 606: 0: inb $(K_STATUS),%al /* get kbd status */ ! 607: testb $(K_IBUF_FULL),%al /* input busy? */ ! 608: jne 0b /* loop until not */ ! 609: ! 610: mov %cl,%al /* move led value */ ! 611: outb %al,$(K_RDWR) /* to kbd */ ! 612: ! 613: movl $10000000,%ecx /* spin */ ! 614: 0: nop ! 615: nop ! 616: loop 0b /* a while */ ! 617: ! 618: ret
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.