fload.cpp

Jazmyn is a 32-bit, protected mode, multitasking OS which runs on i386 & above CPU`s. Its complete

#include "..\include\stdlib.h"
#include "..\include\string.h"
#include "video.h"
#include "fat.h"

byte gbuf[512];
uint gstart,gend;

char get_part_info(uint &s,uint &e,char *OS_name,VideoMemory &vid);
int read_sec(uint start,uint num,void *buf);
int wait();


#define 	IDE_DR		0x1F0	//data register 16-bits r/w
#define	IDE_ER		0x1F1	//error register r
#define	IDE_PRECOMP		0x1F1	//precompensation w
#define	IDE_SECCNT		0x1F2	//sector count r/w
#define	IDE_SECNUM		0x1F3	//sector number r/w
#define	IDE_CYLLSB		0x1F4	//cylinder LSB r/w
#define	IDE_CYLMSB		0x1F5	//cylinder MSB r/w
#define	IDE_DRHD		0x1F6	//drive/head r/w
#define	IDE_SR		0x1F7	//status register r
#define	IDE_CR		0x1F7	//command register w
#define	IDE_ASR		0x3F6	//alternate status register r
#define	IDE_DOR		0x3F6	//digital output register w
#define 	IDE_DA		0x3F7	//drive address

#define	ERR			0x01
#define	INDEX			0x02
#define	ECC			0x04
#define	DATA			0x08
#define	SEEK			0x10
#define	WRERR			0x20
#define	READY			0x40
#define	BUSY			0x80

#define	MAX_LOG_SEC		255

#define	IDE_READ          0x20
#define	IDE_WRITE         0x30

typedef union
{
	unsigned l			:32;
	struct
	{
		unsigned ll		:8;	
		unsigned lh		:8;	
		unsigned hl		:8;	
		unsigned hh		:8;	
	}b;
}long2byte;


void dummy_loop()
{
        for(int i=0;i<30000;i++)
        for(int j=0;j<5000;j++);
}


void __insw(short __p,void *__b,int __n)
{
	__asm__ __volatile__("cld;rep insw"::"d" (__p),"D" ((uint)__b),"c" (__n));
}

int read_FAT_entry(uint N,VideoMemory &vid)
{
        /* return the Nth FAT entry*/
	uint FAToffset = N * 4;
        uint ThisFATSecNum = rsc + (FAToffset / bps);
        uint ThisFATSecOff = FAToffset % bps;
        int ret = read_sec(gstart+ThisFATSecNum,1,gbuf);
        uint entry = (*((DWORD*)&gbuf[ThisFATSecOff])) & 0x0FFFFFFF;
	return entry;
}

void disp(VideoMemory &vid,char *str,uint n)
{
        vid.Write(str);
        vid.displaynum(n,10);
        vid.putch('\n');
}

int main()
{
        VideoMemory vid;
        vid.clrscr();
        vid.Write("\n\n Jazmyn bootloader Version 0.1\n\n");
        vid.Write("Searching for Jazmyn boot record...\n");
        char boot_drv = get_part_info(gstart,gend,"JAZMYN.1",vid);

        vid.Write("Loading kernel image of Jazmyn...\n\n");
        dummy_loop();

        rsc = *(ushort*)&gbuf[14];
        numFATs = gbuf[16];
        FATsz32 = *(uint*)&gbuf[36];
        fds = rsc + (numFATs*FATsz32) + 0;

        uint sc = 2;
        uint ss = FSOC(2);

        int ret;
        fdir dir_ent[128];
        char *kernel_buf = (char*)0x2000;
        uint fcok = 0;
	  
        while(1)
        {
                if(read_sec(gstart+ss,8,(void*)dir_ent) < 0)
                {
                          vid.Write("failed\n");
                          while(1);
                }
                        
                for(int i=0;i<128;i++)
                {
                                
                                if(strncmp((char*)dir_ent[i].dir_name,"KER     COM",11) == 0)
				{
                                        fcok = (dir_ent[i].dir_fst_clusHI<<16)|dir_ent[i].dir_fst_clusLO;
                                        vid.displaynum(fcok,10);vid.putch('\n');
                                        break;
				}
                }
   	  	if(fcok) break;
                sc = read_FAT_entry(sc,vid);
		if(sc == EOC) break;
		ss = FSOC(sc);
      }
      if(fcok)
      {
		while(1)
		{
                  ss = FSOC(fcok);
                  if(read_sec(gstart+ss,8,(void*)kernel_buf) < 0)
                  {
                          vid.Write("failed\n");
                          while(1);
                  }
                  fcok = read_FAT_entry(fcok,vid);
                  if(fcok == EOC)
                  {
  	                break;
                  }
                  kernel_buf += 4096;
                }
      }
      else
      {
		vid.Write("KER.COM Missing\n");
		while(1);
      }
      __asm__ __volatile__("ljmp $0x8,$0x2000"::);

}


int wait()
{
	int error=100000;
        byte val;
	while(1)
	{
		val = inportb(IDE_ASR);
		if((val & DATA)!=DATA && (val & BUSY)==BUSY)
		{
			error --;
			if(error == 0) return -1;
		}
		else	break;
	}
        return 0;
}

int read_sec(uint start,uint num,void *buf)
{
	/* ide specific code */

	long2byte lb = {start};
        byte val;
        while(inportb(IDE_ASR) & BUSY);

        outportb(IDE_SECCNT,num);


        outportb(IDE_SECNUM,lb.b.ll);
	outportb(IDE_CYLLSB,lb.b.lh);
	outportb(IDE_CYLMSB,lb.b.hl);
        val =  0xE0 | (0<<4) | (lb.b.hh & 0x0F);
        outportb(IDE_DRHD,val);

        outportb(IDE_CR,IDE_READ);

        if(wait() < 0) return -1;

	WORD *kbuf = (WORD*)buf;
        for(int i=0;i<num;i++)
        {
                __insw(IDE_DR,kbuf,256);
                inportb(IDE_SR);
                if(wait() < 0) return -1;
                kbuf += 256;
	}
        inportb(IDE_SR);
	return 0;
}

char get_part_info(uint &s,uint &e,char *OS_name,VideoMemory &vid)
{
	uint start,num_sec;
	uint ext_start = 0;
        uint endpart;
        char boot_drv = 'C';
	do
	{
                read_sec(ext_start,1,gbuf);
                start = *(uint*)&gbuf[454] + ext_start;
                num_sec = *(uint*)&gbuf[458];
                ext_start = start + num_sec;
                endpart = *(uint*)&gbuf[470];

                read_sec(start,1,gbuf);

                int i;

                vid.Write("Drive : ");
                vid.putch(boot_drv);vid.putch('\n');
                vid.Write("Partition :");


                char *Boot_OS = (char*)&gbuf[3];
                for(i=0;i<8;i++)
                vid.putch(Boot_OS[i]);vid.putch('\n');

                if(strncmp(Boot_OS,OS_name,8) == 0)
                {
                        char *mem = (char*)0x6400000;
                        *mem = boot_drv;
                        vid.Write("Jazmyn installed in ");
                        vid.putch(boot_drv);
                        vid.Write(" drive\n");
                        break;
                }
                dummy_loop();
                boot_drv++;
        }while(endpart);
	s = start;
	e = start + num_sec - 1;
        return boot_drv;
}