Subversion Repositories HelenOS

#include <efi.h>

#include <efilib.h>

#include <../../../../../../kernel/arch/ia64/include/bootinfo.h>

#define KERNEL_LOAD_ADDRESS 0x4400000

#define MEM_MAP_DESCRIPTOR_OFFSET_TYPE 0        

#define MEM_MAP_DESCRIPTOR_OFFSET_BASE 8    

#define MEM_MAP_DESCRIPTOR_OFFSET_PAGES 24    

//Link image as a data array into hello - usefull with network boot

//#define IMAGE_LINKED

bootinfo_t *bootinfo=(bootinfo_t *)BOOTINFO_ADDRESS;

#ifdef IMAGE_LINKED

extern char HOSimage[];

extern int HOSimagesize;

#endif

static CHAR16 *

a2u (char *str)

{

    static CHAR16 mem[2048];

    int i;

    for (i = 0; str[i]; ++i)

        mem[i] = (CHAR16) str[i];

    mem[i] = 0;

    return mem;

}

EFI_STATUS

efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)

{

    SIMPLE_TEXT_OUTPUT_INTERFACE *conout;

    EFI_INPUT_KEY efi_input_key;

    EFI_STATUS efi_status;

    InitializeLib(image, systab);

    Print(L"HelloLib application started\n");

    EFI_GUID LoadedImageProtocol=LOADED_IMAGE_PROTOCOL;

    EFI_GUID DevicePathProtocol=DEVICE_PATH_PROTOCOL;

    EFI_GUID FileSystemProtocol=SIMPLE_FILE_SYSTEM_PROTOCOL;

    EFI_LOADED_IMAGE *LoadedImage;

    EFI_DEVICE_PATH *DevicePath;

    BS->HandleProtocol(image,

    &LoadedImageProtocol,

    &LoadedImage);

    BS->HandleProtocol(LoadedImage->DeviceHandle,

    &DevicePathProtocol,

    &DevicePath);

    Print (L"Image device : %s\n", DevicePathToStr (DevicePath));

    Print (L"Image file   : %s\n", DevicePathToStr (LoadedImage->FilePath));

    Print (L"Image Base   : %X\n", LoadedImage->ImageBase);

    Print (L"Image Size   : %X\n", LoadedImage->ImageSize);

    EFI_FILE_IO_INTERFACE *Vol;

    EFI_FILE *CurDir;

    EFI_FILE *FileHandle;

    BS->HandleProtocol(LoadedImage->DeviceHandle, &FileSystemProtocol, &Vol);

    char FileName[1024];

    char *OsKernelBuffer;

    int i;

    int defaultLoad;

    int imageLoad;

    UINTN Size;

    StrCpy(FileName,DevicePathToStr(LoadedImage->FilePath));

    for(i=StrLen(FileName);i>=0 && FileName[i]!='\\';i--);

    FileName[i] = 0;

    FileName[0] = 0;

    Print(L"%s\n",LoadedImage->LoadOptions);

    i=0;

    CHAR16 *LoadOptions = LoadedImage->LoadOptions;

    while(1) if(LoadOptions[i++]!=L' ') break;

    while(LoadOptions[i]!=L' '){   

        if(LoadOptions[i]==0) break;

        i++;

    }

    while(LoadOptions[i]==L' ') if(LoadOptions[i++]==0) break;

    if(LoadOptions[i++]==0){

        StrCat(FileName,L"\\image.bin");

        defaultLoad=1;

    }  

/*  else{

        CHAR16 buf[1024];

        //buf[0]='\\';

        i--;

        int j;

        for(j=0;LoadOptions[i+j]!=L' '&&LoadOptions[i+j]!=0;j++)

            buf[j+1]=LoadOptions[i+j];

        buf[j+1]=0;

        StrCat(FileName,buf);

        defaultLoad=0;

    }*/

    else{

        CHAR16 buf[1024];

        //buf[0]='\\';

        i--;

        int j;

        for(j=0;LoadOptions[i+j]!=L' '&&LoadOptions[i+j]!=0;j++)

            buf[j]=LoadOptions[i+j];

        buf[j+1]=0;

        StrCat(FileName,buf);

        defaultLoad=0;

    }

    imageLoad=1;

#ifdef IMAGE_LINKED

    if(defaultLoad) {

        Print(L"Using Linked Image\n");

        imageLoad=0;

    }    

#endif  

    char *  HOS;

    if(imageLoad)

    {

        Size = 0x00400000;

            Vol->OpenVolume (Vol, &CurDir);

        EFI_STATUS stat;

        stat=CurDir->Open(CurDir, &FileHandle, FileName, EFI_FILE_MODE_READ, 0);

        if(EFI_ERROR(stat)){

            Print(L"Error Opening Image %s\n",FileName);

            return 0;

        }

            BS->AllocatePool(EfiLoaderData, Size, &OsKernelBuffer);

        FileHandle->Read(FileHandle, &Size, OsKernelBuffer);

        FileHandle->Close(FileHandle);

        HOS = OsKernelBuffer;  

            if(Size<1) return 0;

    }      

#ifdef IMAGE_LINKED

    else {

        HOS = HOSimage;  

        Size = HOSimagesize;

        Print(L"Image start %llX\n",(long long)HOS);

        Print(L"Image size %llX\n",(long long)Size);

        Print(L"Image &size %llX\n",(long long)&Size);

    }

#endif  

    int HOSSize = Size;  

    rArg rSAL;

    rArg rPAL;

    //Setup AP's wake up address

    LibSalProc(0x01000000,2,0x4400200,0,0,0,0,0,&rSAL);

    //Get System Frequency

    UINT64 sys_freq;

    LibSalProc(0x01000012,0,0,0,0,0,0,0,&rSAL);

    sys_freq=rSAL.p1;

    UINT64 freq_scale;

    //Get CPU Frequency to System Frequency ratio

    LibPalProc(14,0,0,0,&rPAL);

    freq_scale=rPAL.p1;

        UINT64 sapic;

        LibGetSalIpiBlock(&sapic);

        Print (L"SAPIC:%X\n", sapic);

    //bootinfo->sapic=sapic;

        UINT64 wakeup_intno;

        LibGetSalWakeupVector(&wakeup_intno);

        Print (L"WAKEUP INTNO:%X\n", wakeup_intno);

        UINTN cookie;

        void *p=(void *)KERNEL_LOAD_ADDRESS;

        UINTN mapsize,descsize;

        UINT32 desver;

        EFI_STATUS status;

        status=BS->AllocatePages(AllocateAnyPages,EfiLoaderData,/*(HOSSize>>12)+1*/ 1,p);

        if(EFI_ERROR(status)){

        Print(L"Error 0\n");

        if(status == EFI_OUT_OF_RESOURCES) Print(L"EFI_OUT_OF_RESOURCES\n");

        if(status == EFI_INVALID_PARAMETER) Print(L"EFI_INVALID_PARAMETER\n");

        if(status == EFI_NOT_FOUND) Print(L"EFI_NOT_FOUND\n");

        return EFI_SUCCESS;

        }

        UINTN no_entryes;

        void * mds;

        mds=LibMemoryMap(&no_entryes,&cookie,&descsize,&desver);

        for(i=0;i<no_entryes;i++)

        {

            unsigned int type=*((unsigned int *)(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_TYPE));

            unsigned long long base=*((unsigned long long *)(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_BASE));

            unsigned long long pages=*((unsigned long long *)(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_PAGES));

            Print(L"T:%02d %016llX %016llX\n",type,base,pages*EFI_PAGE_SIZE);

        }

        status=BS->ExitBootServices(image,cookie); 

        if(EFI_ERROR(status)){

        Print(L"Error 2\n");

        return EFI_SUCCESS;

        }

    int a;

    for(a=0;a<HOSSize;a++){

        ((char *)(0x4400000))[a]=HOS[a];

    }

    bootinfo->sapic=(unsigned long *)sapic;

    bootinfo->wakeup_intno=wakeup_intno;

    bootinfo->sys_freq=sys_freq;

    bootinfo->freq_scale=freq_scale;

    bootinfo->hello_configured=1;

        bootinfo->memmap_items=0;

        for(i=0;i<no_entryes;i++)

        {

            unsigned int type=*((unsigned int *)(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_TYPE));

            unsigned long long base=*((unsigned long long *)(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_BASE));

            unsigned long long pages=*((unsigned long long *)(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_PAGES));

            switch (type)

            {

                case EfiConventionalMemory:

                bootinfo->memmap[bootinfo->memmap_items].type=EFI_MEMMAP_FREE_MEM;      

                bootinfo->memmap[bootinfo->memmap_items].base=base;    

                bootinfo->memmap[bootinfo->memmap_items].size=pages*EFI_PAGE_SIZE;      

                    bootinfo->memmap_items++;

                    break;

                case EfiMemoryMappedIO:

                bootinfo->memmap[bootinfo->memmap_items].type=EFI_MEMMAP_IO;    

                bootinfo->memmap[bootinfo->memmap_items].base=base;    

                bootinfo->memmap[bootinfo->memmap_items].size=pages*EFI_PAGE_SIZE;      

                    bootinfo->memmap_items++;

                    break;

                case EfiMemoryMappedIOPortSpace:

                bootinfo->memmap[bootinfo->memmap_items].type=EFI_MEMMAP_IO_PORTS;      

                bootinfo->memmap[bootinfo->memmap_items].base=base;    

                bootinfo->memmap[bootinfo->memmap_items].size=pages*EFI_PAGE_SIZE;      

                    bootinfo->memmap_items++;

                    break;

                default :

                    break;

            }

        }

    //Run Kernel

    asm volatile(  

        "nop.i 0x00 ;;\n"

        "movl r15 = 0x4400000 ;;\n"

        "mov b0 = r15;;"

        "br.few b0;;\n"

    );

    //Not reached      

    return EFI_SUCCESS;

}