source: mainline/boot/arch/ia64/loader/gefi/HelenOS/hello.c@ c716d94

#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;
        
        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;
        }

        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;
}