WebSVN – HelenOS – Diff – /branches/tracing/boot/arch/ia64/loader/gefi/HelenOS/hello.c


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

Rev 3623	Rev 3675
1	#include <efi.h>	1	#include <efi.h>
2	#include <efilib.h>	2	#include <efilib.h>
3		3
4	#include <../../../../../../kernel/arch/ia64/include/bootinfo.h>	4	#include <../../../../../../kernel/arch/ia64/include/bootinfo.h>
5		5
6	#define KERNEL_LOAD_ADDRESS 0x4400000	6	#define KERNEL_LOAD_ADDRESS 0x4400000
7		7
8	#define MEM_MAP_DESCRIPTOR_OFFSET_TYPE 0	8	#define MEM_MAP_DESCRIPTOR_OFFSET_TYPE 0
9	#define MEM_MAP_DESCRIPTOR_OFFSET_BASE 8	9	#define MEM_MAP_DESCRIPTOR_OFFSET_BASE 8
10	#define MEM_MAP_DESCRIPTOR_OFFSET_PAGES 24	10	#define MEM_MAP_DESCRIPTOR_OFFSET_PAGES 24
11		11
12		12
13		13
14	//Link image as a data array into hello - usefull with network boot	14	//Link image as a data array into hello - usefull with network boot
15	#define IMAGE_LINKED	15	#define IMAGE_LINKED
16		16
17	bootinfo_t bootinfo=(bootinfo_t )BOOTINFO_ADDRESS;	17	bootinfo_t bootinfo=(bootinfo_t )BOOTINFO_ADDRESS;
18		18
19		19
20	#ifdef IMAGE_LINKED	20	#ifdef IMAGE_LINKED
21	extern char HOSimage[];	21	extern char HOSimage[];
22	extern int HOSimagesize;	22	extern int HOSimagesize;
23	#endif	23	#endif
24		24
25		25
26		26
27	static CHAR16 *	27	static CHAR16 *
28	a2u (char *str)	28	a2u (char *str)
29	{	29	{
30	static CHAR16 mem[2048];	30	static CHAR16 mem[2048];
31	int i;	31	int i;
32		32
33	for (i = 0; str[i]; ++i)	33	for (i = 0; str[i]; ++i)
34	mem[i] = (CHAR16) str[i];	34	mem[i] = (CHAR16) str[i];
35	mem[i] = 0;	35	mem[i] = 0;
36	return mem;	36	return mem;
37	}	37	}
38		38
39	EFI_STATUS	39	EFI_STATUS
40	efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)	40	efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
41	{	41	{
42	SIMPLE_TEXT_OUTPUT_INTERFACE *conout;	42	SIMPLE_TEXT_OUTPUT_INTERFACE *conout;
43		43
44	EFI_INPUT_KEY efi_input_key;	44	EFI_INPUT_KEY efi_input_key;
45	EFI_STATUS efi_status;	45	EFI_STATUS efi_status;
46		46
47	InitializeLib(image, systab);	47	InitializeLib(image, systab);
48		48
49	Print(L"HelloLib application started\n");	49	Print(L"HelloLib application started\n");
50		50
51	EFI_GUID LoadedImageProtocol=LOADED_IMAGE_PROTOCOL;	51	EFI_GUID LoadedImageProtocol=LOADED_IMAGE_PROTOCOL;
52	EFI_GUID DevicePathProtocol=DEVICE_PATH_PROTOCOL;	52	EFI_GUID DevicePathProtocol=DEVICE_PATH_PROTOCOL;
53	EFI_GUID FileSystemProtocol=SIMPLE_FILE_SYSTEM_PROTOCOL;	53	EFI_GUID FileSystemProtocol=SIMPLE_FILE_SYSTEM_PROTOCOL;
54		54
55		55
56	EFI_LOADED_IMAGE *LoadedImage;	56	EFI_LOADED_IMAGE *LoadedImage;
57	EFI_DEVICE_PATH *DevicePath;	57	EFI_DEVICE_PATH *DevicePath;
58		58
59	BS->HandleProtocol(image,	59	BS->HandleProtocol(image,
60	&LoadedImageProtocol,	60	&LoadedImageProtocol,
61	&LoadedImage);	61	&LoadedImage);
62	BS->HandleProtocol(LoadedImage->DeviceHandle,	62	BS->HandleProtocol(LoadedImage->DeviceHandle,
63	&DevicePathProtocol,	63	&DevicePathProtocol,
64	&DevicePath);	64	&DevicePath);
65	Print (L"Image device : %s\n", DevicePathToStr (DevicePath));	65	Print (L"Image device : %s\n", DevicePathToStr (DevicePath));
66	Print (L"Image file : %s\n", DevicePathToStr (LoadedImage->FilePath));	66	Print (L"Image file : %s\n", DevicePathToStr (LoadedImage->FilePath));
67	Print (L"Image Base : %X\n", LoadedImage->ImageBase);	67	Print (L"Image Base : %X\n", LoadedImage->ImageBase);
68	Print (L"Image Size : %X\n", LoadedImage->ImageSize);	68	Print (L"Image Size : %X\n", LoadedImage->ImageSize);
69		69
70		70
71		71
72	EFI_FILE_IO_INTERFACE *Vol;	72	EFI_FILE_IO_INTERFACE *Vol;
73		73
74	EFI_FILE *CurDir;	74	EFI_FILE *CurDir;
75	EFI_FILE *FileHandle;	75	EFI_FILE *FileHandle;
76		76
77	BS->HandleProtocol(LoadedImage->DeviceHandle, &FileSystemProtocol, &Vol);	77	BS->HandleProtocol(LoadedImage->DeviceHandle, &FileSystemProtocol, &Vol);
78		78
79	char FileName[1024];	79	char FileName[1024];
80	char *OsKernelBuffer;	80	char *OsKernelBuffer;
81	int i;	81	int i;
82	int defaultLoad;	82	int defaultLoad;
83	int imageLoad;	83	int imageLoad;
84	UINTN Size;	84	UINTN Size;
85		85
86	StrCpy(FileName,DevicePathToStr(LoadedImage->FilePath));	86	StrCpy(FileName,DevicePathToStr(LoadedImage->FilePath));
87	for(i=StrLen(FileName);i>=0 && FileName[i]!='\\';i--);	87	for(i=StrLen(FileName);i>=0 && FileName[i]!='\\';i--);
88	FileName[i] = 0;	88	FileName[i] = 0;
89		89
90	Print(L"%s\n",LoadedImage->LoadOptions);	90	Print(L"%s\n",LoadedImage->LoadOptions);
91		91
92	i=0;	92	i=0;
93	CHAR16 *LoadOptions = LoadedImage->LoadOptions;	93	CHAR16 *LoadOptions = LoadedImage->LoadOptions;
94		94
95		95
96		96
97	while(1) if(LoadOptions[i++]!=L' ') break;	97	while(1) if(LoadOptions[i++]!=L' ') break;
98	while(LoadOptions[i]!=L' '){	98	while(LoadOptions[i]!=L' '){
99	if(LoadOptions[i]==0) break;	99	if(LoadOptions[i]==0) break;
100	i++;	100	i++;
101	}	101	}
102	while(LoadOptions[i]==L' ') if(LoadOptions[i++]==0) break;	102	while(LoadOptions[i]==L' ') if(LoadOptions[i++]==0) break;
103		103
104	if(LoadOptions[i++]==0){	104	if(LoadOptions[i++]==0){
105	StrCat(FileName,L"\\image.bin");	105	StrCat(FileName,L"\\image.bin");
106	defaultLoad=1;	106	defaultLoad=1;
107	}	107	}
108	else{	108	else{
109	CHAR16 buf[1024];	109	CHAR16 buf[1024];
110	buf[0]='\\';	110	buf[0]='\\';
111	i--;	111	i--;
112	int j;	112	int j;
113	for(j=0;LoadOptions[i+j]!=L' '&&LoadOptions[i+j]!=0;j++)	113	for(j=0;LoadOptions[i+j]!=L' '&&LoadOptions[i+j]!=0;j++)
114	buf[j+1]=LoadOptions[i+j];	114	buf[j+1]=LoadOptions[i+j];
115	buf[j+1]=0;	115	buf[j+1]=0;
116	StrCat(FileName,buf);	116	StrCat(FileName,buf);
117	defaultLoad=0;	117	defaultLoad=0;
118	}	118	}
119		119
120	imageLoad=1;	120	imageLoad=1;
121	#ifdef IMAGE_LINKED	121	#ifdef IMAGE_LINKED
122	if(defaultLoad) {	122	if(defaultLoad) {
123	Print(L"Using Linked Image\n");	123	Print(L"Using Linked Image\n");
124	imageLoad=0;	124	imageLoad=0;
125	}	125	}
126	#endif	126	#endif
127		127
128		128
129	char * HOS;	129	char * HOS;
130	if(imageLoad)	130	if(imageLoad)
131	{	131	{
132	Size = 0x00400000;	132	Size = 0x00400000;
133		133
134	Vol->OpenVolume (Vol, &CurDir);	134	Vol->OpenVolume (Vol, &CurDir);
135		135
136	EFI_STATUS stat;	136	EFI_STATUS stat;
137	stat=CurDir->Open(CurDir, &FileHandle, FileName, EFI_FILE_MODE_READ, 0);	137	stat=CurDir->Open(CurDir, &FileHandle, FileName, EFI_FILE_MODE_READ, 0);
138	if(EFI_ERROR(stat)){	138	if(EFI_ERROR(stat)){
139	Print(L"Error Opening Image %s\n",FileName);	139	Print(L"Error Opening Image %s\n",FileName);
140	return 0;	140	return 0;
141	}	141	}
142	BS->AllocatePool(EfiLoaderData, Size, &OsKernelBuffer);	142	BS->AllocatePool(EfiLoaderData, Size, &OsKernelBuffer);
143	FileHandle->Read(FileHandle, &Size, OsKernelBuffer);	143	FileHandle->Read(FileHandle, &Size, OsKernelBuffer);
144	FileHandle->Close(FileHandle);	144	FileHandle->Close(FileHandle);
145	HOS = OsKernelBuffer;	145	HOS = OsKernelBuffer;
146	if(Size<1) return 0;	146	if(Size<1) return 0;
147		147
148	}	148	}
149	#ifdef IMAGE_LINKED	149	#ifdef IMAGE_LINKED
150	else {	150	else {
151	HOS = HOSimage;	151	HOS = HOSimage;
152	Size = HOSimagesize;	152	Size = HOSimagesize;
153	Print(L"Image start %llX\n",(long long)HOS);	153	Print(L"Image start %llX\n",(long long)HOS);
154	Print(L"Image size %llX\n",(long long)Size);	154	Print(L"Image size %llX\n",(long long)Size);
155	Print(L"Image &size %llX\n",(long long)&Size);	155	Print(L"Image &size %llX\n",(long long)&Size);
156	}	156	}
157	#endif	157	#endif
158	int HOSSize = Size;	158	int HOSSize = Size;
159		159
160		160
161	rArg rSAL;	161	rArg rSAL;
162	rArg rPAL;	162	rArg rPAL;
163		163
164	//Setup AP's wake up address	164	//Setup AP's wake up address
165	LibSalProc(0x01000000,2,0x4400200,0,0,0,0,0,&rSAL);	165	LibSalProc(0x01000000,2,0x4400200,0,0,0,0,0,&rSAL);
166		166
167		167
168	//Get System Frequency	168	//Get System Frequency
169	UINT64 sys_freq;	169	UINT64 sys_freq;
170	LibSalProc(0x01000012,0,0,0,0,0,0,0,&rSAL);	170	LibSalProc(0x01000012,0,0,0,0,0,0,0,&rSAL);
171	sys_freq=rSAL.p1;	171	sys_freq=rSAL.p1;
172		172
173		173
174	UINT64 freq_scale;	174	UINT64 freq_scale;
175	//Get CPU Frequency to System Frequency ratio	175	//Get CPU Frequency to System Frequency ratio
176	LibPalProc(14,0,0,0,&rPAL);	176	LibPalProc(14,0,0,0,&rPAL);
177	freq_scale=rPAL.p1;	177	freq_scale=rPAL.p1;
178		178
179		179
180	UINT64 sapic;	180	UINT64 sapic;
181	LibGetSalIpiBlock(&sapic);	181	LibGetSalIpiBlock(&sapic);
182	Print (L"SAPIC:%X\n", sapic);	182	Print (L"SAPIC:%X\n", sapic);
183	//bootinfo->sapic=sapic;	183	//bootinfo->sapic=sapic;
184		184
185		185
186	UINT64 wakeup_intno;	186	UINT64 wakeup_intno;
187	LibGetSalWakeupVector(&wakeup_intno);	187	LibGetSalWakeupVector(&wakeup_intno);
188	Print (L"WAKEUP INTNO:%X\n", wakeup_intno);	188	Print (L"WAKEUP INTNO:%X\n", wakeup_intno);
189		189
190		190
191		191
192		192
193		193
194	UINTN cookie;	194	UINTN cookie;
195	void p=(void )KERNEL_LOAD_ADDRESS;	195	void p=(void )KERNEL_LOAD_ADDRESS;
196	UINTN mapsize,descsize;	196	UINTN mapsize,descsize;
197	UINT32 desver;	197	UINT32 desver;
198	EFI_STATUS status;	198	EFI_STATUS status;
199		199
200		200
201		201
202	status=BS->AllocatePages(AllocateAnyPages,EfiLoaderData,/(HOSSize>>12)+1/ 1,p);	202	status=BS->AllocatePages(AllocateAnyPages,EfiLoaderData,/(HOSSize>>12)+1/ 1,p);
203	if(EFI_ERROR(status)){	203	if(EFI_ERROR(status)){
204	Print(L"Error 0\n");	204	Print(L"Error 0\n");
205	if(status == EFI_OUT_OF_RESOURCES) Print(L"EFI_OUT_OF_RESOURCES\n");	205	if(status == EFI_OUT_OF_RESOURCES) Print(L"EFI_OUT_OF_RESOURCES\n");
206	if(status == EFI_INVALID_PARAMETER) Print(L"EFI_INVALID_PARAMETER\n");	206	if(status == EFI_INVALID_PARAMETER) Print(L"EFI_INVALID_PARAMETER\n");
207	if(status == EFI_NOT_FOUND) Print(L"EFI_NOT_FOUND\n");	207	if(status == EFI_NOT_FOUND) Print(L"EFI_NOT_FOUND\n");
208	return EFI_SUCCESS;	208	return EFI_SUCCESS;
209	}	209	}
210		210
211	UINTN no_entryes;	211	UINTN no_entryes;
212	void * mds;	212	void * mds;
213	mds=LibMemoryMap(&no_entryes,&cookie,&descsize,&desver);	213	mds=LibMemoryMap(&no_entryes,&cookie,&descsize,&desver);
214		214
215	for(i=0;i<no_entryes;i++)	215	for(i=0;i<no_entryes;i++)
216	{	216	{
217		217
218	unsigned int type=((unsigned int )(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_TYPE));	218	unsigned int type=((unsigned int )(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_TYPE));
219	unsigned long long base=((unsigned long long )(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_BASE));	219	unsigned long long base=((unsigned long long )(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_BASE));
220	unsigned long long pages=((unsigned long long )(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_PAGES));	220	unsigned long long pages=((unsigned long long )(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_PAGES));
221	Print(L"T:%02d %016llX %016llX\n",type,base,pages*EFI_PAGE_SIZE);	221	Print(L"T:%02d %016llX %016llX\n",type,base,pages*EFI_PAGE_SIZE);
222		222
223	}	223	}
224	status=BS->ExitBootServices(image,cookie);	224	status=BS->ExitBootServices(image,cookie);
225	if(EFI_ERROR(status)){	225	if(EFI_ERROR(status)){
226	Print(L"Error 2\n");	226	Print(L"Error 2\n");
227	return EFI_SUCCESS;	227	return EFI_SUCCESS;
228	}	228	}
229		229
230		230
231	int a;	231	int a;
232		232
233	for(a=0;a<HOSSize;a++){	233	for(a=0;a<HOSSize;a++){
234	((char *)(0x4400000))[a]=HOS[a];	234	((char *)(0x4400000))[a]=HOS[a];
235	}	235	}
236	bootinfo->sapic=(unsigned long *)sapic;	236	bootinfo->sapic=(unsigned long *)sapic;
237	bootinfo->wakeup_intno=wakeup_intno;	237	bootinfo->wakeup_intno=wakeup_intno;
238	bootinfo->sys_freq=sys_freq;	238	bootinfo->sys_freq=sys_freq;
239	bootinfo->freq_scale=freq_scale;	239	bootinfo->freq_scale=freq_scale;
-		240	bootinfo->hello_configured=1;
240		241
241		242
242	bootinfo->memmap_items=0;	243	bootinfo->memmap_items=0;
243		244
244	for(i=0;i<no_entryes;i++)	245	for(i=0;i<no_entryes;i++)
245	{	246	{
246		247
247	unsigned int type=((unsigned int )(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_TYPE));	248	unsigned int type=((unsigned int )(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_TYPE));
248	unsigned long long base=((unsigned long long )(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_BASE));	249	unsigned long long base=((unsigned long long )(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_BASE));
249	unsigned long long pages=((unsigned long long )(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_PAGES));	250	unsigned long long pages=((unsigned long long )(mds+i*descsize+MEM_MAP_DESCRIPTOR_OFFSET_PAGES));
250		251
251		252
252		253
253	switch (type)	254	switch (type)
254	{	255	{
255	case EfiConventionalMemory:	256	case EfiConventionalMemory:
256	bootinfo->memmap[bootinfo->memmap_items].type=EFI_MEMMAP_FREE_MEM;	257	bootinfo->memmap[bootinfo->memmap_items].type=EFI_MEMMAP_FREE_MEM;
257	bootinfo->memmap[bootinfo->memmap_items].base=base;	258	bootinfo->memmap[bootinfo->memmap_items].base=base;
258	bootinfo->memmap[bootinfo->memmap_items].size=pages*EFI_PAGE_SIZE;	259	bootinfo->memmap[bootinfo->memmap_items].size=pages*EFI_PAGE_SIZE;
259	bootinfo->memmap_items++;	260	bootinfo->memmap_items++;
260	break;	261	break;
261	case EfiMemoryMappedIO:	262	case EfiMemoryMappedIO:
262	bootinfo->memmap[bootinfo->memmap_items].type=EFI_MEMMAP_IO;	263	bootinfo->memmap[bootinfo->memmap_items].type=EFI_MEMMAP_IO;
263	bootinfo->memmap[bootinfo->memmap_items].base=base;	264	bootinfo->memmap[bootinfo->memmap_items].base=base;
264	bootinfo->memmap[bootinfo->memmap_items].size=pages*EFI_PAGE_SIZE;	265	bootinfo->memmap[bootinfo->memmap_items].size=pages*EFI_PAGE_SIZE;
265	bootinfo->memmap_items++;	266	bootinfo->memmap_items++;
266	break;	267	break;
267	case EfiMemoryMappedIOPortSpace:	268	case EfiMemoryMappedIOPortSpace:
268	bootinfo->memmap[bootinfo->memmap_items].type=EFI_MEMMAP_IO_PORTS;	269	bootinfo->memmap[bootinfo->memmap_items].type=EFI_MEMMAP_IO_PORTS;
269	bootinfo->memmap[bootinfo->memmap_items].base=base;	270	bootinfo->memmap[bootinfo->memmap_items].base=base;
270	bootinfo->memmap[bootinfo->memmap_items].size=pages*EFI_PAGE_SIZE;	271	bootinfo->memmap[bootinfo->memmap_items].size=pages*EFI_PAGE_SIZE;
271	bootinfo->memmap_items++;	272	bootinfo->memmap_items++;
272	break;	273	break;
273		274
274	default :	275	default :
275	break;	276	break;
276	}	277	}
277		278
278		279
279		280
280		281
281		282
282	}	283	}
283		284
284		285
285		286
286	//Run Kernel	287	//Run Kernel
287	asm volatile(	288	asm volatile(
288	"nop.i 0x00 ;;\n"	289	"nop.i 0x00 ;;\n"
289	"movl r15 = 0x4400000 ;;\n"	290	"movl r15 = 0x4400000 ;;\n"
290	"mov b0 = r15;;"	291	"mov b0 = r15;;"
291	"br.few b0;;\n"	292	"br.few b0;;\n"
292	);	293	);
293		294
294		295
295	//Not reached	296	//Not reached
296	return EFI_SUCCESS;	297	return EFI_SUCCESS;
297	}	298	}
298		299

Subversion Repositories HelenOS

(root)/branches/tracing/boot/arch/ia64/loader/gefi/HelenOS/hello.c – Rev 3623 → 3675