Emulation/switch-coreboot
1
0
Fork 0
mirror of https://github.com/fail0verflow/switch-coreboot.git synced 2025-05-04 01:39:18 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fix the indent and whitespace to match LinuxBIOS standards

Browse source 
Signed-off-by: Jordan Crouse <jordan.crouse@amd.com>
Acked-by: Stefan Reinauer <stepan@coresystems.de>



git-svn-id: svn://svn.coreboot.org/coreboot/trunk@2650 2b7e53f0-3cfb-0310-b3e9-8179ed1497e1
This commit is contained in:
Jordan Crouse 2007-05-10 18:32:28 +00:00 • committed by Stefan Reinauer
parent f8030bd924
commit 9934b813da
5 changed files with 388 additions and 449 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
src/cpu/amd/model_lx/cpubug.c
View file

@ -30,7 +30,6 @@
#include <cpu/x86/msr.h> #include <cpu/x86/msr.h>
#include <cpu/amd/lxdef.h> #include <cpu/amd/lxdef.h>
/************************************************************************** /**************************************************************************
* *
* pcideadlock * pcideadlock
@ -40,7 +39,8 @@
* There is also fix code in cache and PCI functions. This bug is very is pervasive. * There is also fix code in cache and PCI functions. This bug is very is pervasive.
* *
**************************************************************************/ **************************************************************************/
static void pcideadlock(void){ static void pcideadlock(void)
{
msr_t msr; msr_t msr;
/* /*
@ -52,15 +52,14 @@ static void pcideadlock(void){
msr.lo |= DM_CONFIG0_LOWER_MISSER_SET; msr.lo |= DM_CONFIG0_LOWER_MISSER_SET;
wrmsr(CPU_DM_CONFIG0, msr); wrmsr(CPU_DM_CONFIG0, msr);
/* write serialize memory hole to PCI. Need to unWS when something is /* write serialize memory hole to PCI. Need to unWS when something is
* shadowed regardless of cachablility. * shadowed regardless of cachablility.
*/ */
msr.lo = 0x021212121; msr.lo = 0x021212121;
msr.hi = 0x021212121; msr.hi = 0x021212121;
wrmsr( CPU_RCONF_A0_BF, msr); wrmsr(CPU_RCONF_A0_BF, msr);
wrmsr( CPU_RCONF_C0_DF, msr); wrmsr(CPU_RCONF_C0_DF, msr);
wrmsr( CPU_RCONF_E0_FF, msr); wrmsr(CPU_RCONF_E0_FF, msr);
} }
/****************************************************************************/ /****************************************************************************/
@ -74,7 +73,8 @@ static void pcideadlock(void){
/** to maintain coherency with and the cache is not enabled yet.*/ /** to maintain coherency with and the cache is not enabled yet.*/
/***/ /***/
/****************************************************************************/ /****************************************************************************/
static void disablememoryreadorder(void){ static void disablememoryreadorder(void)
{
msr_t msr; msr_t msr;
msr = rdmsr(MC_CF8F_DATA); msr = rdmsr(MC_CF8F_DATA);
@ -83,7 +83,8 @@ static void disablememoryreadorder(void){
} }
/* For cpu version C3. Should be the only released version */ /* For cpu version C3. Should be the only released version */
void cpubug(void) { void cpubug(void)
{
pcideadlock(); pcideadlock();
disablememoryreadorder(); disablememoryreadorder();
printk_debug("Done cpubug fixes \n"); printk_debug("Done cpubug fixes \n");

121
src/cpu/amd/model_lx/cpureginit.c
View file

@ -25,7 +25,8 @@
;* SetDelayControl ;* SetDelayControl
;* ;*
;*************************************************************************/ ;*************************************************************************/
void SetDelayControl(void){ void SetDelayControl(void)
{
unsigned int msrnum, glspeed; unsigned int msrnum, glspeed;
unsigned char spdbyte0, spdbyte1; unsigned char spdbyte0, spdbyte1;
msr_t msr; msr_t msr;
@ -46,7 +47,7 @@ void SetDelayControl(void){
msrnum = CPU_BC_MSS_ARRAY_CTL2; msrnum = CPU_BC_MSS_ARRAY_CTL2;
msr.hi = 0x00000106; msr.hi = 0x00000106;
msr.lo = 0x83104104; msr.lo = 0x83104104;
wrmsr(msrnum,msr); wrmsr(msrnum, msr);
msrnum = GLCP_FIFOCTL; msrnum = GLCP_FIFOCTL;
msr = rdmsr(msrnum); msr = rdmsr(msrnum);
@ -59,38 +60,34 @@ void SetDelayControl(void){
msr.lo = 0x00000001; msr.lo = 0x00000001;
wrmsr(msrnum, msr); wrmsr(msrnum, msr);
/* Debug Delay Control Setup Check /* Debug Delay Control Setup Check
Leave it alone if it has been setup. FS2 or something is here.*/ Leave it alone if it has been setup. FS2 or something is here. */
msrnum = GLCP_DELAY_CONTROLS; msrnum = GLCP_DELAY_CONTROLS;
msr = rdmsr(msrnum); msr = rdmsr(msrnum);
if (msr.lo & ~(0x7C0)){ if (msr.lo & ~(0x7C0)) {
return; return;
} }
/* /*
; Delay Controls based on DIMM loading. UGH! * Delay Controls based on DIMM loading. UGH!
; # of Devices = Module Width (SPD6) / Device Width(SPD13) * Physical Banks(SPD5) * # of Devices = Module Width (SPD6) / Device Width(SPD13) * Physical Banks(SPD5)
; Note - We only support module width of 64. * Note - We only support module width of 64.
*/ */
spdbyte0 = spd_read_byte(DIMM0, SPD_PRIMARY_SDRAM_WIDTH); spdbyte0 = spd_read_byte(DIMM0, SPD_PRIMARY_SDRAM_WIDTH);
if (spdbyte0 !=0xFF){ if (spdbyte0 != 0xFF) {
spdbyte0 = (unsigned char) 64/spdbyte0 * (unsigned char) (spd_read_byte(DIMM0, SPD_NUM_DIMM_BANKS)); spdbyte0 = (unsigned char)64 / spdbyte0 *
} (unsigned char)(spd_read_byte(DIMM0, SPD_NUM_DIMM_BANKS));
else{ } else {
spdbyte0=0; spdbyte0 = 0;
} }
spdbyte1 = spd_read_byte(DIMM1, SPD_PRIMARY_SDRAM_WIDTH); spdbyte1 = spd_read_byte(DIMM1, SPD_PRIMARY_SDRAM_WIDTH);
if (spdbyte1 !=0xFF){ if (spdbyte1 != 0xFF) {
spdbyte1 = (unsigned char) 64/spdbyte1 * (unsigned char) (spd_read_byte(DIMM1, SPD_NUM_DIMM_BANKS)); spdbyte1 = (unsigned char)64 / spdbyte1 *
(unsigned char)(spd_read_byte(DIMM1, SPD_NUM_DIMM_BANKS));
} else {
spdbyte1 = 0;
} }
else{
spdbyte1=0;
}
/* The current thinking. Subject to change... /* The current thinking. Subject to change...
@ -141,103 +138,90 @@ void SetDelayControl(void){
*/ */
msr.hi = msr.lo = 0; msr.hi = msr.lo = 0;
if (spdbyte0 == 0 || spdbyte1 == 0){ if (spdbyte0 == 0 || spdbyte1 == 0) {
/* one dimm solution */ /* one dimm solution */
if (spdbyte1 == 0){ if (spdbyte1 == 0) {
msr.hi |= 0x000800000; msr.hi |= 0x000800000;
} }
spdbyte0 += spdbyte1; spdbyte0 += spdbyte1;
if (spdbyte0 > 8){ if (spdbyte0 > 8) {
/* large dimm */ /* large dimm */
if (glspeed < 334){ if (glspeed < 334) {
msr.hi |= 0x0837100AA; msr.hi |= 0x0837100AA;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} } else {
else{
msr.hi |= 0x082710055; msr.hi |= 0x082710055;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} }
} } else if (spdbyte0 > 4) {
else if (spdbyte0 > 4){
/* medium dimm */ /* medium dimm */
if (glspeed < 334){ if (glspeed < 334) {
msr.hi |= 0x0837100AA; msr.hi |= 0x0837100AA;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} } else {
else{
msr.hi |= 0x0827100AA; msr.hi |= 0x0827100AA;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} }
} } else {
else{
/* small dimm */ /* small dimm */
if (glspeed < 334){ if (glspeed < 334) {
msr.hi |= 0x0837100FF; msr.hi |= 0x0837100FF;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} } else {
else{
msr.hi |= 0x0827100FF; msr.hi |= 0x0827100FF;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} }
} }
} } else {
else{
/* two dimm solution */ /* two dimm solution */
spdbyte0 += spdbyte1; spdbyte0 += spdbyte1;
if (spdbyte0 > 24){ if (spdbyte0 > 24) {
/* huge dimms */ /* huge dimms */
if (glspeed < 334){ if (glspeed < 334) {
msr.hi |= 0x0B37100A5; msr.hi |= 0x0B37100A5;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} } else {
else{
msr.hi |= 0x0B2710000; msr.hi |= 0x0B2710000;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} }
} } else if (spdbyte0 > 16) {
else if (spdbyte0 > 16){
/* large dimms */ /* large dimms */
if (glspeed < 334){ if (glspeed < 334) {
msr.hi |= 0x0B37100A5; msr.hi |= 0x0B37100A5;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} } else {
else{
msr.hi |= 0x0B27100A5; msr.hi |= 0x0B27100A5;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} }
} } else if (spdbyte0 >= 8) {
else if (spdbyte0 >= 8){
/* medium dimms */ /* medium dimms */
if (glspeed < 334){ if (glspeed < 334) {
msr.hi |= 0x0937100A5; msr.hi |= 0x0937100A5;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} } else {
else{
msr.hi |= 0x0C27100A5; msr.hi |= 0x0C27100A5;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} }
} } else {
else{
/* small dimms */ /* small dimms */
if (glspeed < 334){ if (glspeed < 334) {
msr.hi |= 0x0837100A5; msr.hi |= 0x0837100A5;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} } else {
else{
msr.hi |= 0x082710000; msr.hi |= 0x082710000;
msr.lo |= 0x056960004; msr.lo |= 0x056960004;
} }
} }
} }
wrmsr(GLCP_DELAY_CONTROLS,msr); wrmsr(GLCP_DELAY_CONTROLS, msr);
return; return;
} }
/* ***************************************************************************/ /* ***************************************************************************/
/* * cpuRegInit*/ /* * cpuRegInit*/
/* ***************************************************************************/ /* ***************************************************************************/
void void cpuRegInit(void)
cpuRegInit (void){ {
int msrnum; int msrnum;
msr_t msr; msr_t msr;
@ -273,22 +257,20 @@ cpuRegInit (void){
/* Set the Delay Control in GLCP */ /* Set the Delay Control in GLCP */
SetDelayControl(); SetDelayControl();
/* Enable RSDC*/ /* Enable RSDC */
msrnum = CPU_AC_SMM_CTL; msrnum = CPU_AC_SMM_CTL;
msr = rdmsr(msrnum); msr = rdmsr(msrnum);
msr.lo |= SMM_INST_EN_SET; msr.lo |= SMM_INST_EN_SET;
wrmsr(msrnum, msr); wrmsr(msrnum, msr);
/* FPU imprecise exceptions bit */ /* FPU imprecise exceptions bit */
msrnum = CPU_FPU_MSR_MODE; msrnum = CPU_FPU_MSR_MODE;
msr = rdmsr(msrnum); msr = rdmsr(msrnum);
msr.lo |= FPU_IE_SET; msr.lo |= FPU_IE_SET;
wrmsr(msrnum, msr); wrmsr(msrnum, msr);
/* Power Savers (Do after BIST) */ /* Power Savers (Do after BIST) */
/* Enable Suspend on HLT & PAUSE instructions*/ /* Enable Suspend on HLT & PAUSE instructions */
msrnum = CPU_XC_CONFIG; msrnum = CPU_XC_CONFIG;
msr = rdmsr(msrnum); msr = rdmsr(msrnum);
msr.lo |= XC_CONFIG_SUSP_ON_HLT | XC_CONFIG_SUSP_ON_PAUSE; msr.lo |= XC_CONFIG_SUSP_ON_HLT | XC_CONFIG_SUSP_ON_PAUSE;
@ -302,17 +284,18 @@ cpuRegInit (void){
msr.lo |= 0x002000000; /* PBZ213: Set PAUSEDLY = 2 */ msr.lo |= 0x002000000; /* PBZ213: Set PAUSEDLY = 2 */
wrmsr(msrnum, msr); wrmsr(msrnum, msr);
/* Disable the debug clock to save power.*/ /* Disable the debug clock to save power. */
/* NOTE: leave it enabled for fs2 debug */ /* NOTE: leave it enabled for fs2 debug */
/* msrnum = GLCP_DBGCLKCTL; #if 0
msrnum = GLCP_DBGCLKCTL;
msr.hi = 0; msr.hi = 0;
msr.lo = 0; msr.lo = 0;
wrmsr(msrnum, msr); wrmsr(msrnum, msr);
*/ #endif
/* Setup throttling delays to proper mode if it is ever enabled. */ /* Setup throttling delays to proper mode if it is ever enabled. */
msrnum = GLCP_TH_OD; msrnum = GLCP_TH_OD;
msr.hi = 0; msr.hi = 0;
msr.lo = 0x00000603C; msr.lo = 0x00000603C;
wrmsr(msrnum, msr); wrmsr(msrnum, msr);
} }

17
src/cpu/amd/model_lx/model_lx_init.c
View file

@ -33,12 +33,9 @@
static void vsm_end_post_smi(void) static void vsm_end_post_smi(void)
{ {
__asm__ volatile ( __asm__ volatile ("push %ax\n"
"push %ax\n"
"mov $0x5000, %ax\n" "mov $0x5000, %ax\n"
".byte 0x0f, 0x38\n" ".byte 0x0f, 0x38\n" "pop %ax\n");
"pop %ax\n"
);
} }
static void model_lx_init(device_t dev) static void model_lx_init(device_t dev)
@ -55,9 +52,9 @@ static void model_lx_init(device_t dev)
vsm_end_post_smi(); vsm_end_post_smi();
// Set gate A20 (legacy vsm disables it in late init) // Set gate A20 (legacy vsm disables it in late init)
printk_debug("A20 (0x92): %d\n",inb(0x92)); printk_debug("A20 (0x92): %d\n", inb(0x92));
outb(0x02,0x92); outb(0x02, 0x92);
printk_debug("A20 (0x92): %d\n",inb(0x92)); printk_debug("A20 (0x92): %d\n", inb(0x92));
printk_debug("CPU model_lx_init DONE\n"); printk_debug("CPU model_lx_init DONE\n");
}; };
@ -67,8 +64,8 @@ static struct device_operations cpu_dev_ops = {
}; };
static struct cpu_device_id cpu_table[] = { static struct cpu_device_id cpu_table[] = {
{ X86_VENDOR_AMD, 0x05A2 }, {X86_VENDOR_AMD, 0x05A2},
{ 0, 0 }, {0, 0},
}; };
static struct cpu_driver driver __cpu_driver = { static struct cpu_driver driver __cpu_driver = {

8
src/cpu/amd/model_lx/syspreinit.c
View file

@ -29,14 +29,14 @@
/* * Destroys: Al,*/ /* * Destroys: Al,*/
/* **/ /* **/
/* ***************************************************************************/ /* ***************************************************************************/
void void StartTimer1(void)
StartTimer1(void){ {
outb(0x56, 0x43); outb(0x56, 0x43);
outb(0x12, 0x41); outb(0x12, 0x41);
} }
void void SystemPreInit(void)
SystemPreInit(void){ {
/* they want a jump ... */ /* they want a jump ... */
#ifndef USE_DCACHE_RAM #ifndef USE_DCACHE_RAM

220
src/cpu/amd/model_lx/vsmsetup.c
View file

@ -69,9 +69,9 @@
* software, even if advised of the possibility of such damage. * software, even if advised of the possibility of such damage.
* *
* $Id: vsmsetup.c,v 1.8 2006/09/08 12:47:57 andrei Exp $ * $Id: vsmsetup.c,v 1.8 2006/09/08 12:47:57 andrei Exp $
* *
* Copyright (C) 2007 Advanced Micro Devices * Copyright (C) 2007 Advanced Micro Devices
* *
*--------------------------------------------------------------------*/ *--------------------------------------------------------------------*/
/* Modified to be a self sufficient plug in so that it can be used /* Modified to be a self sufficient plug in so that it can be used
@ -84,53 +84,44 @@
/* Declare a temporary global descriptor table - necessary because the /* Declare a temporary global descriptor table - necessary because the
Core part of the bios no longer sets up any 16 bit segments */ Core part of the bios no longer sets up any 16 bit segments */
__asm__ ( __asm__(
/* pointer to original gdt */ /* pointer to original gdt */
"gdtarg: \n" "gdtarg: \n"
" .word gdt_limit \n" " .word gdt_limit \n"
" .long gdt \n" " .long gdt \n"
/* compute the table limit */ /* compute the table limit */
"__mygdt_limit = __mygdt_end - __mygdt - 1 \n" "__mygdt_limit = __mygdt_end - __mygdt - 1 \n"
"__mygdtaddr: \n" "__mygdtaddr: \n"
" .word __mygdt_limit \n" " .word __mygdt_limit \n"
" .long __mygdt \n" " .long __mygdt \n"
"__mygdt: \n" "__mygdt: \n"
/* selgdt 0, unused */ /* selgdt 0, unused */
" .word 0x0000, 0x0000 \n" " .word 0x0000, 0x0000 \n"
" .byte 0x00, 0x00, 0x00, 0x00 \n" " .byte 0x00, 0x00, 0x00, 0x00 \n"
/* selgdt 8, unused */ /* selgdt 8, unused */
" .word 0x0000, 0x0000 \n" " .word 0x0000, 0x0000 \n"
" .byte 0x00, 0x00, 0x00, 0x00 \n" " .byte 0x00, 0x00, 0x00, 0x00 \n"
/* selgdt 0x10, flat code segment */ /* selgdt 0x10, flat code segment */
" .word 0xffff, 0x0000 \n" " .word 0xffff, 0x0000 \n"
" .byte 0x00, 0x9b, 0xcf, 0x00 \n" " .byte 0x00, 0x9b, 0xcf, 0x00 \n"
/* selgdt 0x18, flat data segment */ /* selgdt 0x18, flat data segment */
" .word 0xffff, 0x0000 \n" " .word 0xffff, 0x0000 \n"
" .byte 0x00, 0x93, 0xcf, 0x00 \n" " .byte 0x00, 0x93, 0xcf, 0x00 \n"
/* selgdt 0x20, unused */ /* selgdt 0x20, unused */
" .word 0x0000, 0x0000 \n" " .word 0x0000, 0x0000 \n"
" .byte 0x00, 0x00, 0x00, 0x00 \n" " .byte 0x00, 0x00, 0x00, 0x00 \n"
/* selgdt 0x28 16-bit 64k code at 0x00000000 */ /* selgdt 0x28 16-bit 64k code at 0x00000000 */
" .word 0xffff, 0x0000 \n" " .word 0xffff, 0x0000 \n"
" .byte 0, 0x9a, 0, 0 \n" " .byte 0, 0x9a, 0, 0 \n"
/* selgdt 0x30 16-bit 64k data at 0x00000000 */ /* selgdt 0x30 16-bit 64k data at 0x00000000 */
" .word 0xffff, 0x0000 \n" " .word 0xffff, 0x0000 \n"
" .byte 0, 0x92, 0, 0 \n" " .byte 0, 0x92, 0, 0 \n"
"__mygdt_end: \n" "__mygdt_end: \n"
); );
/* Declare a pointer to where our idt is going to be i.e. at mem zero */ /* Declare a pointer to where our idt is going to be i.e. at mem zero */
__asm__ ("__myidt: \n" __asm__(
"__myidt: \n"
/* 16-bit limit */ /* 16-bit limit */
" .word 1023 \n" " .word 1023 \n"
/* 24-bit base */ /* 24-bit base */
@ -144,36 +135,32 @@ static void real_mode_switch_call_vsm(unsigned long smm, unsigned long sysm)
uint16_t entryHi = (VSA2_ENTRY_POINT & 0xffff0000) >> 4; uint16_t entryHi = (VSA2_ENTRY_POINT & 0xffff0000) >> 4;
uint16_t entryLo = (VSA2_ENTRY_POINT & 0xffff); uint16_t entryLo = (VSA2_ENTRY_POINT & 0xffff);
__asm__ __volatile__ ( __asm__ __volatile__(
// paranoia -- does ecx get saved? not sure. This is // paranoia -- does ecx get saved? not sure. This is
// the easiest safe thing to do. // the easiest safe thing to do.
" pushal \n" " pushal \n"
/* save the stack */ /* save the stack */
" mov %%esp, __stack \n" " mov %%esp, __stack \n"
" jmp 1f \n" " jmp 1f \n"
"__stack: .long 0 \n" "__stack: .long 0 \n" "1:\n"
"1:\n"
/* get devfn into %%ecx */ /* get devfn into %%ecx */
" movl %%esp, %%ebp \n" " movl %%esp, %%ebp \n"
#if 0 #if 0
/* I'm not happy about that pushal followed by esp-relative references. /* I'm not happy about that pushal followed by esp-relative
* just do hard-codes for now * references. Just do hard-codes for now
*/ */
" movl 8(%%ebp), %%ecx \n" " movl 8(%%ebp), %%ecx \n"
" movl 12(%%ebp), %%edx \n" " movl 12(%%ebp), %%edx \n"
#endif #endif
" movl %0, %%ecx \n" " movl %0, %%ecx \n"
" movl %1, %%edx \n" " movl %1, %%edx \n"
/* load 'our' gdt */ /* load 'our' gdt */
" lgdt %%cs:__mygdtaddr \n" " lgdt %%cs:__mygdtaddr \n"
/* This configures CS properly for real mode. */ /* This configures CS properly for real mode. */
" ljmp $0x28, $__rms_16bit\n" " ljmp $0x28, $__rms_16bit\n"
"__rms_16bit: \n" "__rms_16bit: \n"
" .code16 \n" " .code16 \n"
/* 16 bit code from here on... */ /* 16 bit code from here on... */
/* Load the segment registers w/ properly configured segment /* Load the segment registers w/ properly configured segment
* descriptors. They will retain these configurations (limits, * descriptors. They will retain these configurations (limits,
* writability, etc.) once protected mode is turned off. */ * writability, etc.) once protected mode is turned off. */
@ -183,30 +170,28 @@ static void real_mode_switch_call_vsm(unsigned long smm, unsigned long sysm)
" mov %%ax, %%fs \n" " mov %%ax, %%fs \n"
" mov %%ax, %%gs \n" " mov %%ax, %%gs \n"
" mov %%ax, %%ss \n" " mov %%ax, %%ss \n"
/* Turn off protection (bit 0 in CR0) */ /* Turn off protection (bit 0 in CR0) */
" movl %%cr0, %%eax \n" " movl %%cr0, %%eax \n"
" andl $0xFFFFFFFE, %%eax \n" " andl $0xFFFFFFFE, %%eax \n"
" movl %%eax, %%cr0 \n" " movl %%eax, %%cr0 \n"
/* Now really going into real mode */ /* Now really going into real mode */
" ljmp $0, $__rms_real\n" " ljmp $0, $__rms_real\n"
"__rms_real: \n" "__rms_real: \n"
/* put the stack at the end of page zero. /* put the stack at the end of page zero.
* that way we can easily share it between real and protected, * that way we can easily share it between real and protected,
* since the 16-bit ESP at segment 0 will work for any case. */ * since the 16-bit ESP at segment 0 will work for any case.
*/
/* Setup a stack */ /* Setup a stack */
" mov $0x0, %%ax \n" " mov $0x0, %%ax \n"
" mov %%ax, %%ss \n" " mov %%ax, %%ss \n"
" movl $0x1000, %%eax \n" " movl $0x1000, %%eax \n"
" movl %%eax, %%esp \n" " movl %%eax, %%esp \n"
/* Load our 16 it idt */ /* Load our 16 it idt */
" xor %%ax, %%ax \n" " xor %%ax, %%ax \n"
" mov %%ax, %%ds \n" " mov %%ax, %%ds \n"
" lidt __myidt \n" " lidt __myidt \n"
/* Dump zeros in the other segregs */ /* Dump zeros in the other segregs */
" mov %%ax, %%es \n" " mov %%ax, %%es \n"
/* FixMe: Big real mode for gs, fs? */ /* FixMe: Big real mode for gs, fs? */
@ -217,16 +202,13 @@ static void real_mode_switch_call_vsm(unsigned long smm, unsigned long sysm)
//" mov %%cx, %%ax \n" //" mov %%cx, %%ax \n"
" movl %0, %%ecx \n" " movl %0, %%ecx \n"
" movl %1, %%edx \n" " movl %1, %%edx \n"
/* call the VSA2 entry point address */ /* call the VSA2 entry point address */
" lcall %2, %3\n" " lcall %2, %3\n"
/* if we got here, just about done. /* if we got here, just about done.
* Need to get back to protected mode */ * Need to get back to protected mode */
" movl %%cr0, %%eax \n" " movl %%cr0, %%eax \n"
" orl $0x0000001, %%eax\n" /* PE = 1 */ " orl $0x0000001, %%eax\n" /* PE = 1 */
" movl %%eax, %%cr0 \n" " movl %%eax, %%cr0 \n"
/* Now that we are in protected mode jump to a 32 bit code segment. */ /* Now that we are in protected mode jump to a 32 bit code segment. */
" data32 ljmp $0x10, $vsmrestart\n" " data32 ljmp $0x10, $vsmrestart\n"
"vsmrestart:\n" "vsmrestart:\n"
@ -237,19 +219,18 @@ static void real_mode_switch_call_vsm(unsigned long smm, unsigned long sysm)
" mov %%ax, %%fs \n" " mov %%ax, %%fs \n"
" mov %%ax, %%gs \n" " mov %%ax, %%gs \n"
" mov %%ax, %%ss \n" " mov %%ax, %%ss \n"
/* restore proper gdt and idt */ /* restore proper gdt and idt */
" lgdt %%cs:gdtarg \n" " lgdt %%cs:gdtarg \n"
" lidt idtarg \n" " lidt idtarg \n"
".globl vsm_exit \n" ".globl vsm_exit \n"
"vsm_exit: \n" "vsm_exit: \n"
" mov __stack, %%esp \n" " mov __stack, %%esp \n"
" popal \n" " popal \n"::
:: "g" (smm), "g" (sysm), "g" (entryHi), "g" (entryLo)); "g" (smm), "g"(sysm), "g"(entryHi), "g"(entryLo)
);
} }
__asm__ (".text\n""real_mode_switch_end:\n"); __asm__(".text\n" "real_mode_switch_end:\n");
extern char real_mode_switch_end[]; extern char real_mode_switch_end[];
// andrei: some VSA virtual register helpers: raw read and MSR read // andrei: some VSA virtual register helpers: raw read and MSR read
@ -257,16 +238,14 @@ extern char real_mode_switch_end[];
uint32_t VSA_vrRead(uint16_t classIndex) uint32_t VSA_vrRead(uint16_t classIndex)
{ {
unsigned eax, ebx, ecx, edx; unsigned eax, ebx, ecx, edx;
asm volatile( asm volatile (
"movw $0x0AC1C, %%dx \n" "movw $0x0AC1C, %%dx \n"
"orl $0x0FC530000, %%eax \n" "orl $0x0FC530000, %%eax \n"
"outl %%eax, %%dx \n" "outl %%eax, %%dx \n"
"addb $2, %%dl \n" "addb $2, %%dl \n"
"inw %%dx, %%ax \n" "inw %%dx, %%ax \n"
: "=a" (eax), "=b"(ebx), "=c"(ecx), "=d"(edx)
: "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a"(classIndex)
: "a" (classIndex)
); );
return eax; return eax;
@ -275,16 +254,14 @@ uint32_t VSA_vrRead(uint16_t classIndex)
uint32_t VSA_msrRead(uint32_t msrAddr) uint32_t VSA_msrRead(uint32_t msrAddr)
{ {
unsigned eax, ebx, ecx, edx; unsigned eax, ebx, ecx, edx;
asm volatile( asm volatile (
"movw $0x0AC1C, %%dx \n" "movw $0x0AC1C, %%dx \n"
"movl $0x0FC530007, %%eax \n" "movl $0x0FC530007, %%eax \n"
"outl %%eax, %%dx \n" "outl %%eax, %%dx \n"
"addb $2, %%dl \n" "addb $2, %%dl \n"
"inw %%dx, %%ax \n" "inw %%dx, %%ax \n"
: "=a" (eax), "=b"(ebx), "=c"(ecx), "=d"(edx)
: "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) : "c"(msrAddr)
: "c" (msrAddr)
); );
return eax; return eax;
@ -296,14 +273,14 @@ void do_vsmbios(void)
unsigned long busdevfn; unsigned long busdevfn;
unsigned int rom = 0; unsigned int rom = 0;
unsigned char *buf; unsigned char *buf;
unsigned int size = SMM_SIZE*1024; unsigned int size = SMM_SIZE * 1024;
int i; int i;
unsigned long ilen, olen; unsigned long ilen, olen;
printk_err("do_vsmbios\n"); printk_err("do_vsmbios\n");
/* clear vsm bios data area */ /* clear vsm bios data area */
for (i = 0x400; i < 0x500; i++) { for (i = 0x400; i < 0x500; i++) {
*(volatile unsigned char *) i = 0; *(volatile unsigned char *)i = 0;
} }
/* declare rom address here - keep any config data out of the way /* declare rom address here - keep any config data out of the way
@ -312,22 +289,17 @@ void do_vsmbios(void)
/* this is the base of rom on the LX at present. At some point, this has to be /* this is the base of rom on the LX at present. At some point, this has to be
* much better parameterized * much better parameterized
*/ */
//rom = 0xfff80000;
//rom = 0xfffc0000;
/* the VSA starts at the base of rom - 64 */ /* the VSA starts at the base of rom - 64 */
//rom = ((unsigned long) 0) - (ROM_SIZE + 64*1024); //rom = ((unsigned long) 0) - (ROM_SIZE + 64*1024);
//rom = 0xfffc8000;
//VSA is cat onto the end after LB builds //VSA is cat onto the end after LB builds
rom = ((unsigned long) 0) - (ROM_SIZE + 36 * 1024); rom = ((unsigned long)0) - (ROM_SIZE + 36 * 1024);
buf = (unsigned char *) VSA2_BUFFER; buf = (unsigned char *)VSA2_BUFFER;
olen = unrv2b((uint8_t *)rom, buf, &ilen); olen = unrv2b((uint8_t *) rom, buf, &ilen);
printk_debug("buf ilen %d olen%d\n", ilen, olen); printk_debug("buf ilen %d olen%d\n", ilen, olen);
printk_debug("buf %p *buf %d buf[256k] %d\n", printk_debug("buf %p *buf %d buf[256k] %d\n",
buf, buf[0], buf[SMM_SIZE*1024]); buf, buf[0], buf[SMM_SIZE * 1024]);
printk_debug("buf[0x20] signature is %x:%x:%x:%x\n", printk_debug("buf[0x20] signature is %x:%x:%x:%x\n",
buf[0x20] ,buf[0x21] ,buf[0x22],buf[0x23]); buf[0x20], buf[0x21], buf[0x22], buf[0x23]);
/* check for post code at start of vsainit.bin. If you don't see it, /* check for post code at start of vsainit.bin. If you don't see it,
don't bother. */ don't bother. */
if ((buf[0x20] != 0xb0) || (buf[0x21] != 0x10) || if ((buf[0x20] != 0xb0) || (buf[0x21] != 0x10) ||
@ -336,11 +308,6 @@ void do_vsmbios(void)
return; return;
} }
//memcpy((void *) VSA2_BUFFER, buf, size);
//for (i = 0; i < 0x800000; i++)
// outb(0xaa, 0x80);
/* ecx gets smm, edx gets sysm */ /* ecx gets smm, edx gets sysm */
printk_err("Call real_mode_switch_call_vsm\n"); printk_err("Call real_mode_switch_call_vsm\n");
real_mode_switch_call_vsm(MSR_GLIU0_SMM, MSR_GLIU0_SYSMEM); real_mode_switch_call_vsm(MSR_GLIU0_SMM, MSR_GLIU0_SYSMEM);
@ -350,12 +317,13 @@ void do_vsmbios(void)
outb(0x12, 0x41); outb(0x12, 0x41);
// check that VSA is running OK // check that VSA is running OK
if(VSA_vrRead(SIGNATURE) == VSA2_SIGNATURE) if (VSA_vrRead(SIGNATURE) == VSA2_SIGNATURE)
printk_debug("do_vsmbios: VSA2 VR signature verified\n"); printk_debug("do_vsmbios: VSA2 VR signature verified\n");
else printk_err("do_vsmbios: VSA2 VR signature not valid, install failed!\n"); else
printk_err
("do_vsmbios: VSA2 VR signature not valid, install failed!\n");
} }
// we had hoped to avoid this. // we had hoped to avoid this.
// this is a stub IDT only. It's main purpose is to ignore calls // this is a stub IDT only. It's main purpose is to ignore calls
// to the BIOS. // to the BIOS.
@ -381,7 +349,7 @@ struct realidt {
// so the handler is relocatable. // so the handler is relocatable.
void handler(void) void handler(void)
{ {
__asm__ __volatile__ ( __asm__ __volatile__(
" .code16 \n" " .code16 \n"
"idthandle: \n" "idthandle: \n"
" pushal \n" " pushal \n"
@ -394,7 +362,7 @@ void handler(void)
void debughandler(void) void debughandler(void)
{ {
__asm__ __volatile__ ( __asm__ __volatile__(
" .code16 \n" " .code16 \n"
"debughandle: \n" "debughandle: \n"
" pushw %cx \n" " pushw %cx \n"
@ -416,13 +384,12 @@ void debughandler(void)
// returns back to the INTx caller (i.e. vgabios) // returns back to the INTx caller (i.e. vgabios)
void callbiosint(void) void callbiosint(void)
{ {
__asm__ __volatile__ ( __asm__ __volatile__(
" .code16 \n" " .code16 \n"
"callbiosint16: \n" "callbiosint16: \n"
" push %ds \n" " push %ds \n"
" push %es \n" " push %es \n"
" push %fs \n" " push %fs \n" " push %gs \n"
" push %gs \n"
// clean up the int #. To save space we put it in the lower // clean up the int #. To save space we put it in the lower
// byte. But the top 24 bits are junk. // byte. But the top 24 bits are junk.
" andl $0xff, %eax\n" " andl $0xff, %eax\n"
@ -439,12 +406,12 @@ void callbiosint(void)
" data32 ljmp $0x10, $biosprotect\n" " data32 ljmp $0x10, $biosprotect\n"
"biosprotect: \n" "biosprotect: \n"
" .code32 \n" " .code32 \n"
" movw $0x18, %ax \n" " movw $0x18, %ax\n"
" mov %ax, %ds \n" " mov %ax, %ds\n"
" mov %ax, %es \n" " mov %ax, %es\n"
" mov %ax, %fs \n" " mov %ax, %fs\n"
" mov %ax, %gs \n" " mov %ax, %gs\n"
" mov %ax, %ss \n" " mov %ax, %ss\n"
" lidt idtarg \n" " lidt idtarg \n"
" call biosint \n" " call biosint \n"
// back to real mode ... // back to real mode ...
@ -455,22 +422,19 @@ void callbiosint(void)
/* Load the segment registers w/ properly configured segment /* Load the segment registers w/ properly configured segment
* descriptors. They will retain these configurations (limits, * descriptors. They will retain these configurations (limits,
* writability, etc.) once protected mode is turned off. */ * writability, etc.) once protected mode is turned off. */
" mov $0x30, %ax \n" " mov $0x30, %ax\n"
" mov %ax, %ds \n" " mov %ax, %ds\n"
" mov %ax, %es \n" " mov %ax, %es\n"
" mov %ax, %fs \n" " mov %ax, %fs\n"
" mov %ax, %gs \n" " mov %ax, %gs\n"
" mov %ax, %ss \n" " mov %ax, %ss\n"
/* Turn off protection (bit 0 in CR0) */ /* Turn off protection (bit 0 in CR0) */
" movl %cr0, %eax \n" " movl %cr0, %eax \n"
" andl $0xFFFFFFFE, %eax \n" " andl $0xFFFFFFFE, %eax \n"
" movl %eax, %cr0 \n" " movl %eax, %cr0 \n"
/* Now really going into real mode */ /* Now really going into real mode */
" ljmp $0, $__rms_real2 \n" " ljmp $0, $__rms_real2 \n"
"__rms_real2: \n" "__rms_real2: \n"
/* Setup a stack /* Setup a stack
* FixME: where is esp? */ * FixME: where is esp? */
/* no need for a fix here. The esp is shared from 32-bit and 16-bit mode. /* no need for a fix here. The esp is shared from 32-bit and 16-bit mode.
@ -479,23 +443,19 @@ void callbiosint(void)
*/ */
" mov $0x0, %ax \n" " mov $0x0, %ax \n"
" mov %ax, %ss \n" " mov %ax, %ss \n"
/* debugging for RGM */ /* debugging for RGM */
" mov $0x11, %al \n" " mov $0x11, %al \n"
" outb %al, $0x80 \n" " outb %al, $0x80 \n"
/* Load our 16 bit idt */ /* Load our 16 bit idt */
" xor %ax, %ax \n" " xor %ax, %ax \n"
" mov %ax, %ds \n" " mov %ax, %ds \n"
" lidt __myidt \n" " lidt __myidt \n"
/* Dump zeros in the other segregs */ /* Dump zeros in the other segregs */
" mov %ax, %es \n" " mov %ax, %es \n"
" mov %ax, %fs \n" " mov %ax, %fs \n"
" mov %ax, %gs \n" " mov %ax, %gs \n"
" mov $0x40, %ax \n" " mov $0x40, %ax \n"
" mov %ax, %ds \n" " mov %ax, %ds \n"
/* pop the INT # that you pushed earlier */ /* pop the INT # that you pushed earlier */
" popl %eax \n" " popl %eax \n"
" pop %gs \n" " pop %gs \n"
@ -504,8 +464,7 @@ void callbiosint(void)
" pop %ds \n" " pop %ds \n"
" popal \n" " popal \n"
" iret \n" " iret \n"
" .code32 \n" " .code32 \n");
);
} }
enum { enum {
@ -519,8 +478,8 @@ int pcibios(unsigned long *pedi, unsigned long *pesi, unsigned long *pebp,
int handleint21(unsigned long *pedi, unsigned long *pesi, unsigned long *pebp, int handleint21(unsigned long *pedi, unsigned long *pesi, unsigned long *pebp,
unsigned long *pesp, unsigned long *pebx, unsigned long *pedx, unsigned long *pesp, unsigned long *pebx, unsigned long *pedx,
unsigned long *pecx, unsigned long *peax, unsigned long *pflags unsigned long *pecx, unsigned long *peax,
); unsigned long *pflags);
int biosint(unsigned long intnumber, int biosint(unsigned long intnumber,
unsigned long gsfs, unsigned long dses, unsigned long gsfs, unsigned long dses,
@ -551,13 +510,13 @@ int biosint(unsigned long intnumber,
// cases in a good compiler are just as good as your own tables. // cases in a good compiler are just as good as your own tables.
switch (intnumber) { switch (intnumber) {
case 0 ... 15: case 0...15:
// These are not BIOS service, but the CPU-generated exceptions // These are not BIOS service, but the CPU-generated exceptions
printk_info("biosint: Oops, exception %u\n", intnumber); printk_info("biosint: Oops, exception %u\n", intnumber);
if (esp < 0x1000) { if (esp < 0x1000) {
printk_debug("Stack contents: "); printk_debug("Stack contents: ");
while (esp < 0x1000) { while (esp < 0x1000) {
printk_debug("0x%04x ", *(unsigned short *) esp); printk_debug("0x%04x ", *(unsigned short *)esp);
esp += 2; esp += 2;
} }
printk_debug("\n"); printk_debug("\n");
@ -568,7 +527,7 @@ int biosint(unsigned long intnumber,
break; break;
case PCIBIOS: case PCIBIOS:
ret = pcibios( &edi, &esi, &ebp, &esp, ret = pcibios(&edi, &esi, &ebp, &esp,
&ebx, &edx, &ecx, &eax, &flags); &ebx, &edx, &ecx, &eax, &flags);
break; break;
case MEMSIZE: case MEMSIZE:
@ -577,12 +536,11 @@ int biosint(unsigned long intnumber,
ret = 0; ret = 0;
break; break;
case 0x15: case 0x15:
ret=handleint21( &edi, &esi, &ebp, &esp, ret = handleint21(&edi, &esi, &ebp, &esp,
&ebx, &edx, &ecx, &eax, &flags); &ebx, &edx, &ecx, &eax, &flags);
break; break;
default: default:
printk_info("BIOSINT: Unsupport int #0x%x\n", printk_info("BIOSINT: Unsupport int #0x%x\n", intnumber);
intnumber);
break; break;
} }
if (ret) if (ret)
@ -593,14 +551,13 @@ int biosint(unsigned long intnumber,
return ret; return ret;
} }
void setup_realmode_idt(void) void setup_realmode_idt(void)
{ {
extern unsigned char idthandle, end_idthandle; extern unsigned char idthandle, end_idthandle;
extern unsigned char debughandle, end_debughandle; extern unsigned char debughandle, end_debughandle;
int i; int i;
struct realidt *idts = (struct realidt *) 0; struct realidt *idts = (struct realidt *)0;
int codesize = &end_idthandle - &idthandle; int codesize = &end_idthandle - &idthandle;
unsigned char *intbyte, *codeptr; unsigned char *intbyte, *codeptr;
@ -615,8 +572,8 @@ void setup_realmode_idt(void)
// and get it that way. But that's really disgusting. // and get it that way. But that's really disgusting.
for (i = 0; i < 256; i++) { for (i = 0; i < 256; i++) {
idts[i].cs = 0; idts[i].cs = 0;
codeptr = (unsigned char*) 4096 + i * codesize; codeptr = (unsigned char *)4096 + i * codesize;
idts[i].offset = (unsigned) codeptr; idts[i].offset = (unsigned)codeptr;
memcpy(codeptr, &idthandle, codesize); memcpy(codeptr, &idthandle, codesize);
intbyte = codeptr + 3; intbyte = codeptr + 3;
*intbyte = i; *intbyte = i;
@ -628,7 +585,7 @@ void setup_realmode_idt(void)
// int10. // int10.
// calling convention here is the same as INTs, we can reuse // calling convention here is the same as INTs, we can reuse
// the int entry code. // the int entry code.
codeptr = (unsigned char*) 0xff065; codeptr = (unsigned char *)0xff065;
memcpy(codeptr, &idthandle, codesize); memcpy(codeptr, &idthandle, codesize);
intbyte = codeptr + 3; intbyte = codeptr + 3;
*intbyte = 0x42; /* int42 is the relocated int10 */ *intbyte = 0x42; /* int42 is the relocated int10 */
@ -637,11 +594,9 @@ void setup_realmode_idt(void)
TF bit is set upon call to real mode */ TF bit is set upon call to real mode */
idts[1].cs = 0; idts[1].cs = 0;
idts[1].offset = 16384; idts[1].offset = 16384;
memcpy((void*)16384, &debughandle, &end_debughandle - &debughandle); memcpy((void *)16384, &debughandle, &end_debughandle - &debughandle);
} }
enum { enum {
CHECK = 0xb001, CHECK = 0xb001,
FINDDEV = 0xb102, FINDDEV = 0xb102,
@ -674,14 +629,14 @@ pcibios(unsigned long *pedi, unsigned long *pesi, unsigned long *pebp,
unsigned long ecx = *pecx; unsigned long ecx = *pecx;
unsigned long eax = *peax; unsigned long eax = *peax;
unsigned long flags = *pflags; unsigned long flags = *pflags;
unsigned short func = (unsigned short) eax; unsigned short func = (unsigned short)eax;
int retval = 0; int retval = 0;
unsigned short devid, vendorid, devfn; unsigned short devid, vendorid, devfn;
short devindex; /* Use short to get rid of gabage in upper half of 32-bit register */ short devindex; /* Use short to get rid of gabage in upper half of 32-bit register */
unsigned char bus; unsigned char bus;
device_t dev; device_t dev;
switch(func) { switch (func) {
case CHECK: case CHECK:
*pedx = 0x4350; *pedx = 0x4350;
*pecx = 0x2049; *pecx = 0x2049;
@ -705,7 +660,8 @@ pcibios(unsigned long *pedi, unsigned long *pesi, unsigned long *pebp,
// devfn is an int, so we mask it off. // devfn is an int, so we mask it off.
busdevfn = (dev->bus->secondary << 8) busdevfn = (dev->bus->secondary << 8)
| (dev->path.u.pci.devfn & 0xff); | (dev->path.u.pci.devfn & 0xff);
printk_debug("0x%x: return 0x%x\n", func, busdevfn); printk_debug("0x%x: return 0x%x\n", func,
busdevfn);
*pebx = busdevfn; *pebx = busdevfn;
retval = 0; retval = 0;
} else { } else {
@ -730,13 +686,15 @@ pcibios(unsigned long *pedi, unsigned long *pesi, unsigned long *pebp,
bus = *pebx >> 8; bus = *pebx >> 8;
reg = *pedi; reg = *pedi;
dev = dev_find_slot(bus, devfn); dev = dev_find_slot(bus, devfn);
if (! dev) { if (!dev) {
printk_debug("0x%x: BAD DEVICE bus %d devfn 0x%x\n", func, bus, devfn); printk_debug
("0x%x: BAD DEVICE bus %d devfn 0x%x\n",
func, bus, devfn);
// idiots. the pcibios guys assumed you'd never pass a bad bus/devfn! // idiots. the pcibios guys assumed you'd never pass a bad bus/devfn!
*peax = PCIBIOS_BADREG; *peax = PCIBIOS_BADREG;
retval = -1; retval = -1;
} }
switch(func) { switch (func) {
case READCONFBYTE: case READCONFBYTE:
byte = pci_read_config8(dev, reg); byte = pci_read_config8(dev, reg);
*pecx = byte; *pecx = byte;
@ -765,7 +723,8 @@ pcibios(unsigned long *pedi, unsigned long *pesi, unsigned long *pebp,
if (retval) if (retval)
retval = PCIBIOS_BADREG; retval = PCIBIOS_BADREG;
printk_debug("0x%x: bus %d devfn 0x%x reg 0x%x val 0x%lx\n", printk_debug
("0x%x: bus %d devfn 0x%x reg 0x%x val 0x%lx\n",
func, bus, devfn, reg, *pecx); func, bus, devfn, reg, *pecx);
*peax = 0; *peax = 0;
retval = 0; retval = 0;
@ -783,41 +742,40 @@ int handleint21(unsigned long *edi, unsigned long *esi, unsigned long *ebp,
unsigned long *esp, unsigned long *ebx, unsigned long *edx, unsigned long *esp, unsigned long *ebx, unsigned long *edx,
unsigned long *ecx, unsigned long *eax, unsigned long *flags) unsigned long *ecx, unsigned long *eax, unsigned long *flags)
{ {
int res=-1; int res = -1;
printk_debug("handleint21, eax 0x%x\n", *eax); printk_debug("handleint21, eax 0x%x\n", *eax);
switch(*eax&0xffff) switch (*eax & 0xffff) {
{
case 0x5f19: case 0x5f19:
break; break;
case 0x5f18: case 0x5f18:
*eax=0x5f; *eax = 0x5f;
*ebx=0x545; // MCLK = 133, 32M frame buffer, 256 M main memory *ebx = 0x545; // MCLK = 133, 32M frame buffer, 256 M main memory
*ecx=0x060; *ecx = 0x060;
res=0; res = 0;
break; break;
case 0x5f00: case 0x5f00:
*eax = 0x8600; *eax = 0x8600;
break; break;
case 0x5f01: case 0x5f01:
*eax = 0x5f; *eax = 0x5f;
*ecx = (*ecx & 0xffffff00 ) | 2; // panel type = 2 = 1024 * 768 *ecx = (*ecx & 0xffffff00) | 2; // panel type = 2 = 1024 * 768
res = 0; res = 0;
break; break;
case 0x5f02: case 0x5f02:
*eax=0x5f; *eax = 0x5f;
*ebx= (*ebx & 0xffff0000) | 2; *ebx = (*ebx & 0xffff0000) | 2;
*ecx= (*ecx & 0xffff0000) | 0x401; // PAL + crt only *ecx = (*ecx & 0xffff0000) | 0x401; // PAL + crt only
*edx= (*edx & 0xffff0000) | 0; // TV Layout - default *edx = (*edx & 0xffff0000) | 0; // TV Layout - default
res=0; res = 0;
break; break;
case 0x5f0f: case 0x5f0f:
*eax=0x860f; *eax = 0x860f;
break; break;
case 0xBEA7: case 0xBEA7:
*eax=66; *eax = 66;
break; break;
case 0xBEA4: case 0xBEA4:
*eax=500; *eax = 500;
break; break;
} }
return res; return res;