////////////////////////////////////////////////////////////////////////////

#include <16f877.H>
#use delay(clock=4000000)
#use fast_io(A)
#use fast_io(B)
#use fast_io(C)
//#use rs232(baud=9600, xmit=PIN_A0,rcv=PIN_B0)
#use rs232(baud=9600, xmit=PIN_A0)

#byte cf_control=0x05	//port a
#byte userport	=0x06	//b
#byte vscontrol	=0x07	//c
#byte cf_data	=0x08	//d
#byte cf_addr	=0x09	//port e
#byte tris_cf_control   =0x85	//port a
#byte tris_userport	=0x86	//b
#byte tris_vscontrol	=0x87	//c
#byte tris_cf_data	=0x88	//d
#byte tris_cf_addr	=0x89	//port e
#byte option_reg=0x81
//----------------------FOR UART
#byte SPBRG =	0x99
#byte TXREG =	0x19
#byte RCREG =	0x1A
#byte TXSTA =	    0x98
#bit CSRC  = 0x98.7 
#bit TX9   = 0x98.6
#bit TXEN  = 0x98.5 
#bit SYNC  = 0x98.4 
//#bit---  = 0x98.3 
#bit BRGH  = 0x98.2 
#bit TRMT  = 0x98.1 
#bit TX9D  = 0x98.0
#byte RCSTA=	    0x18
#bit SPEN  = 0x18.7 
#bit RX9   = 0x18.6
#bit SREN  = 0x18.5 
#bit CREN  = 0x18.4 
#bit ADDEN = 0x18.3 
#bit FERR  = 0x18.2 
#bit OERR  = 0x18.1 
#bit RX9D  = 0x18.0 
//FOR SSP
#byte SSPBUF  = 0X13
#byte SSPADD  = 0X93
#byte SSPCON  =      0X14
#bit WCOL   = 0x14.7 
#bit SSPOV  = 0x14.6
#bit SSPEN  = 0x14.5 
#bit CKP    = 0x14.4 
#bit SSPM3  = 0x14.3 
#bit SSPM2  = 0x14.2 
#bit SSPM1  = 0x14.1 
#bit SSPM0  = 0x14.0 
#byte SSPCON2  =      0X91
#bit GKEN    = 0x91.7 
#bit ACKSTAT = 0x91.6
#bit ACKDT   = 0x91.5 
#bit ACKEN   = 0x91.4 
#bit RCEN    = 0x91.3 
#bit PEN     = 0x91.2 
#bit RSEN    = 0x91.1 
#bit SEN     = 0x91.0
#byte SSPSTAT  =      0X94
#bit SMP  = 0x94.7 
#bit CKE  = 0x94.6
#bit DA   = 0x94.5 
#bit P    = 0x94.4 
#bit S    = 0x94.3 
#bit RW   = 0x94.2 
#bit UA   = 0x94.1 
#bit BF   = 0x94.0
//FOR A/D
#byte ADCON0  = 0X1F
#byte ADCON1  = 0X9F
#byte ADCON1  = 0x9F
#byte ADRESH  = 0X1E
#byte ADRESL  = 0X9E
//for interrupts
#byte intcon  = 0X0B

////////////for decoder
#bit BSYNC	=vscontrol.0
#bit DREQ	=vscontrol.1
#bit XCS	=vscontrol.2
#bit SCLK 	=vscontrol.3
#bit SO 	=vscontrol.4
#bit SI 	=vscontrol.5
#bit DCLK 	=vscontrol.6
#bit SDATA 	=vscontrol.7
#bit xreset 	=userport.2

//////for flash card
#bit CE1	=userport.1
#bit CD1	=cf_control.1
#bit RESET	=cf_control.2
#bit OE 	=cf_control.3
#bit WE 	=cf_control.4
#bit RDY 	=cf_control.5

//userport (buttons)
//#bit USERRESET  =userport.3
//#bit BASSBOOST  =userport.4
//#bit VOLUME	=userport.5
//#bit SKIPBUTTON =userport.6
//#bit SURROUND   =userport.7


// CF CARD REGISTER ADDRESSES
//******************************************************************************
//  ADDRESS VALUES, LOW 3 BITS AS FOLLOWS:
//		(X,X,X,X,X,A2,A1,A0)

#define  DATA_REG	0x00	// ADDRESS OF DATA REGISTER
#define  ERROR_REG	0x01	// ADDRESS OF ERROR REGISTER
#define  FEATURES_REG	0x01	// ADDRESS OF FEATURES REGISTER
#define  SEC_CNT_REG	0x02	// ADDRESS OF SECTOR COUNT REGISTER
#define  SEC_NUM_REG	0x03	// ADDRESS OF SECTOR NUMBER REGISTER
#define  CYL_LO_REG	0x04	// ADDRESS OF LOW CYLINDER REGISTER
#define  CYL_HI_REG	0x05	// ADDRESS OF HIGH CYLINDER REGISTER
#define  HEAD_REG	0x06	// ADDRESS OF HEAD/DRIVE REGISTER
#define  STATUS_REG	0x07	// ADDRESS OF STATUS REGISTER
#define  COMMAND_REG	0x07	// ADDRESS OF COMMAND REGISTER

// COMMAND VALUES, 8 BITS


#define  IDENTIFY	0xEC
#define  WRITE_SEC	0x30
#define  READ_SEC	0x20

//BYTE CONST TABLE4 [6]= {125,250,001,125,250,001};


//BYTE CONST RNDH [256]= {64,117,40,109,176,242,151,125,214,29,46,110,55,248,96,199,84,220,213,0,206,119,118,32,251,10,97,66
//,236,34,233,27,149,164,106,19,60,14,126,75,209,230,69,72,237,196,183,1,121,135,82,50,250,8,210,122,101,13,217,166,68,58
//,134,192,168,48,246,227,152,77,187,161,61,163,234,112,108,221,67,74,146,17,190,89,219,253,254,92,128,16,255,174,44,145
//,81,207,184,195,159,107,4,99,226,155,162,102,87,156,98,185,173,131,115,208,42,70,21,204,165,49,6,18,150,238,22,63
//,38,130,30,31,28,216,20,240,224,23,179,73,47,85,198,39,138,104,175,228,136,35,194,211,11,157,182,188,120,103,200,215
//,57,223,114,65,153,189,53,79,239,158,100,93,7,123,160,142,76,141,144,78,201,86,88,94,83,247,140,15,36,111,243,51
//,2,169,24,132,124,232,91,170,37,186,5,171,229,191,25,26,193,241,105,52,154,249,235,129,147,133,181,231,56,43,90,9
//,202,143,45,148,212,59,178,180,33,116,113,172,95,177,3,137,167,54,139,71,205,225,218,80,12,222,245,62,41,127,244,252,203,197
//};


BYTE CONST RNDL [256]= {208,75,137,110,218,247,165,23,248,216,204,59,118,35,193,29,83,158,93,57,224,194,3,207,205,149,203,22,129,171,10,
142,251,99,249,244,144,16,17,238,37,197,111,151,4,192,104,7,95,150,67,101,69,15,132,186,87,156,206,27,166,20,182, 
163,92,198,119,213,180,61,152,39,185,19,58,45,33,64,24,160,40,222,172,131,227,221,105,108,177,183,73,43,157,12,199,
113,9,245,126,130,106,120,210,215,31,167,246,76,139,195,239,50,229,169,55,122,212,30,112,6,85,141,82,236,21,32,89,
219,173,188,127,74,214,187,190,176,62,123,189,121,184,148,225,34,1,196,28,49,46,79,77,54,117,240,175,242,140,231,
13,128,25,97,146,228,179,116,70,53,178,18,254,78,109,155,241,233,81,255,159,202,102,2,174,14,147,234,60,8,84,52,98,
100,230,145,211,125,11,181,164,26,90,134,161,36,71,223,143,232,136,63,68,51,96,243,66,65,235,47,154,237,252,72,209,
114,138,115,86,250,5,94,133,42,44,88,226,103,253,124,168,91,48,217,56,80,135,220,107,191,201,162,153,38,170,41,200,0};
//char pointerh, pointerl, globalpointer;
char random_byte;//global variable for the random number generator (keeps the last value around for seeding purposes?)


//--------------------------------------prototypes


void 	cfwrite(void);
void 	cfread(void);
void 	cfread_vssend(void);
void 	checkready(void);
void 	checkcard(void);
int16 	spicommand(char aa, char bb, char a, char b);
void 	sdi_out(data);
void 	resetvs1001(void);
void 	resetvs1001_hard(void);
void 	morezeroes(void);
void 	getdatafromcf(int32 lba);
void 	init(void);
short int printout(void);
void  straightthrough(void);
void  find_bpb(void);
void  cfskip(char count);
char  getsongstart(int32 filenumber);
char  song(int32 startsector,int32 endsector);
void printout_rootdir(void);
void printout_sector(int32 sector);
void find_highest_song_number(void);
int32 get_next_shuffle(void);
char rand(void);

//super fat functions::::

int32 readfat(int32 fatoffset);

//int16    option_keys();
//--------------------------------------end prototypes

char data_lo,data_hi,BPB_SecPerClus;
int16  bpbstart, RootDirSectors, FirstDataSector, BPB_ResvdSecCnt;
int32 FirstRootDirSecNum, songstarter, songlength, currentsong;
int16 BPB_BytsPerSec;

int32 fatstart, datsec;
int32 ccl, pcl, root_ccl;
int32 root_p_cl;
int32 highestsong;
int32 BPB_RootEntCnt, BPB_FATSz16, BPB_FATSz32, BPB_RootClus;
char BPB_NumFATs, fatmode;

char volume,offset;
char column_pointer[16];

#int_timer0
void volume_handler(void){
	if (!input(pin_b5)){
		volume = spicommand(0x03,0x0b,0x00,0x00);
		if (volume<255){
			volume++;
		}
		spicommand(0x02,0x0b,volume,volume);
	}
	if (!input(pin_b4)){
		volume = spicommand(0x03,0x0b,0x00,0x00);
		if (volume>0){
			volume--;
		}
		spicommand(0x02,0x0b,volume,volume);
	}
}



void main(void){
	char flag, result, n, shufflemode;

	init();
	we=1;
	oe=1;
	ce1=0;
//	delay_ms(500);
//	delay_ms(255);
//	delay_ms(900);
//	tris_cf_control =0b00100010;	//port a    xxio ooio
	BPB_BytsPerSec=0;
//	putc(13);putc(10);
//	printf("I am the King of France!");	putc(13);putc(10);
	checkcard();
//	printf("card ok");	putc(13);putc(10);
//	delay_ms(60);

	find_bpb();
	if(BPB_BytsPerSec!=0x200){
//		printf("POP");	putc(13);putc(10);
		find_bpb();
	}
//	printf("card parameters found");	putc(13);putc(10);
	resetvs1001();
//	printf("vs1001 reset");	putc(13);putc(10);
	volume=0x30;
	spicommand(0x02,0x0b,volume,volume);
//	printf("volume set");	putc(13);putc(10);
	currentsong=0x01;
	find_highest_song_number();
	root_ccl= BPB_RootClus;
	flag='s';
	result=0x00;
	shufflemode=0;
//	pointerl=0;
//	pointerh=0;
	enable_interrupts(GLOBAL);
	enable_interrupts(INT_TIMER0);
	if (!input(pin_b7)){
//		shufflemode=1;
		for(n=0;n<16;n++){
			column_pointer[n]=0;		
		}
		while(!input(pin_b7)){random_byte++; offset++;}
		while(1){
			if ((input(pin_b7))&&(input(pin_b6))){
				currentsong=get_next_shuffle();
				result=getsongstart(currentsong);
				if(result==0x01){
//					printf("playing: %lX ",currentsong);	putc(13);putc(10);	putc(13);putc(10);
					flag=song( songstarter,(songstarter+(songlength/512)) );
				}
			}
		}
	}
//	if (!input(pin_b6)){
//		shufflemode=1;
//		while(!input(pin_b6)){;}
//	}
	while(1){
////////////////////////////////////////////////////////auto track increment
		if (!input(pin_b7)){
			for(n=120;n>0;n--){
				delay_ms(3);
				if (input(pin_b7)){
					break;
				}
			}
			while (!input(pin_b7)){
				delay_ms(1);
				n++;
				if (n==15){
					n=0;
					currentsong++;
					if (currentsong>highestsong){currentsong=0x01;putc('s');}
					putc('f');
				}
			}
		}
		if (!input(pin_b6)){
			for(n=120;n>0;n--){
				delay_ms(3);
				if (input(pin_b6)){
					break;
				}
			}
			while (!input(pin_b6)){
				delay_ms(1);
				n++;
				if (n==15){
					n=0;
					currentsong--;
					if (currentsong==0x00){currentsong=highestsong; putc('s');}
					putc('f');
				}
			}
		}


//////////////////////////end AUTO TRACK INCREMENT	
		if ((input(pin_b7))&&(input(pin_b6))){
			n=0;
			result=getsongstart(currentsong);
			if(result==0x02){
				currentsong=0x01;
				flag='s';
			}
			else if(result==0x01){
//				printf("playing: %lX ",currentsong);	putc(13);putc(10);	putc(13);putc(10);
				flag=song( songstarter,(songstarter+(songlength/512)) );
			}
			if ((flag=='n')||(flag=='s')){
					currentsong++;
	//				printf("auto advanced");	putc(13);putc(10);
			}
			else if (flag=='p'){
				if (currentsong>1){
					currentsong--;
	//				printf("previous track attempt");	putc(13);putc(10);
				}
				else{currentsong=highestsong;}
			}
		}
	}
}


//-----------------------------------//this is limited to 2048 directiry entries
int32 get_next_shuffle(void){
int16 a, work;
char b, c;
	work=0xffff;
//	printf("seeking number----------:");
//	putc(13);putc(10);
	while(work>highestsong){
		b = rand();
		b = b/16;
//		printf("column number: %X ",b);
		//putc(13);putc(10);
//		printf("is up to: %X ",column_pointer[b]);
//		putc(13);putc(10);
		if (column_pointer[b]<255){
			c = column_pointer[b]++;
//			printf(" c is: %X ",c);
			c=c+offset;
			work=RNDL[c];
//			printf("work is: %lX ",work);
			a = (int16) b * 256;
			work=work+a;
//			printf("for a final number: %lX ",work);
		}
	}
//	printf("random hopeful!: %lX ",work);
	return (work);
}

/*
int32 get_next_shuffle(void){
int16 a, work;
char b, c, checker, bt, mask;
	mask=0x00000001;
	while(1){
		a=highestsong/0x0100;
		b=256/a;
		work= RNDH[pointerh++];
		work=work/b;
		c=RNDL[pointerl++];
		work=work*256;
		work=work+(int16) c;
//		write_eeprom(addr,val);	
		read_eeprom((work/8),bt);
		a=work & 0x000F;
		mask<<a;
		checker = bt & mask;
		if (checker==0){
			write_eeprom((work/8), (bt & mask));
			break;
		}						
	}
//		random_byte = SEEDS[pointer++];

}*/

char rand(void)	{
	char sum;
	sum = 0;
	// This calculates parity on the selected bits (mask = 0xb4).
	if(random_byte & 0x80){ sum   = 1;}
	if(random_byte & 0x20){ sum ^= 1;}
	if(random_byte & 0x10){ sum ^= 1;}
	if(random_byte & 0x04){ sum ^= 1;}
	random_byte <<= 1;
	random_byte |= sum;
	return(random_byte);
	
}


char	getsongstart(int32 filenumber){
	char Emm,Pee,Three;
	int32 Largeccl, ccltemp, eocmark;
	int16  x, y, z;
	
//				printf("getting song paramaters for: %lX ",filenumber);
		eocmark=0;
		if (fatmode==16){
			getdatafromcf((Firstrootdirsecnum+(filenumber/16))+bpbstart);
		}else{// if 32 mode:
			root_ccl= BPB_RootClus;
			y=filenumber/16;
			z=y;
			y=y/BPB_SecPerClus;
			x=y*BPB_SecPerClus;
			x=z-x;	
			while(y>0){
				root_p_cl=root_ccl;
				root_ccl=readfat(root_p_cl);
//				printf("current root cluster:%4LX   ",root_ccl);
				eocmark=root_ccl & 0x0FFFFFFF;
				y--;
			}
			if (eocmark>0x0fffffef){
//				printf("AAAAAAAAAAAAAAAAAAA");
				return (0x02);
			}
			ccltemp=root_ccl-2;
			ccltemp=ccltemp * (int32)BPB_SecPerClus;
			ccltemp=ccltemp + (int32)datsec;
			ccltemp=ccltemp + (int32)x;
			getdatafromcf(ccltemp); 
		}
	cfskip((filenumber & 0x000F)*16);
	cfread();
//	printf("firstCharOf File Name is:%X   ",data_lo);
	if(data_lo==0x00){
		return(0x00);//was 0x02
	}
	if(data_lo != 0xe5){
//		putc(254);putc(1);
//		putc(data_lo);putc(data_hi);
		cfread();
//		putc(data_lo);putc(data_hi);
		cfread();
//		putc(data_lo);putc(data_hi);
		cfread();
//		putc(data_lo);putc(data_hi);
//		putc('.');


//		cfskip(3);
		cfread();
//		putc(data_lo);putc(data_hi);
		Emm=data_lo;
		Pee=data_hi;
		cfread();
//		putc(data_lo);putc(data_hi);	putc(13);putc(10);
		Three=data_lo;
		if (((Emm=='m') || (Emm=='M')) && ((Pee=='P') || (Pee=='p')) && (Three=='3')){
			cfskip(4);
			cfread();
			if (fatmode==32){
				Largeccl= ((int16)data_hi<<8)+data_lo;// clusterf high bytes. they're in a funny place to maintain compatibility with fat16
				Largeccl=Largeccl<<16;
			}
			cfskip(2);
			cfread();
			ccl= ((int32)data_hi<<8)+data_lo;
			if (fatmode==32){
				ccl = ccl+ Largeccl;   //add on the high bytes of the cluster address
			}
			songstarter=( ((((int32)data_lo+((int32)data_hi<<8))-0)  *BPB_SecPerClus) +bpbstart+Firstdatasector);
			cfread();
			*(((char*)&songlength)+0)=data_lo;
 			*(((char*)&songlength)+1)=data_hi;
								//songlength=(int16)data_lo + ((int16)data_hi<<8);
			cfread();
			*(((char*)&songlength)+2)=data_lo;
			*(((char*)&songlength)+3)=data_hi;
								//songlength=songlength + (((int16)data_lo+((int16)data_hi<<8))  <<16);
			return(0x01);
		}
	}

	return(0x00);
}

void find_highest_song_number(void){
int32 clust_high;
int32 eocmark;
	root_ccl= BPB_RootClus;
	clust_high=0;
	do{
		root_p_cl=root_ccl;
		root_ccl=readfat(root_p_cl);
//		printf("cluster seek:%4LX   ",root_ccl);
		eocmark=root_ccl & 0x0FFFFFFF;
		clust_high++;
	}while(eocmark<0x0fffffef);
	highestsong=clust_high * BPB_SecPerClus;
	highestsong=	highestsong*16;
	highestsong--;
//	printf("clust_high:: %LX ",clust_high);	putc(13);putc(10);
//	printf("highestsong:: %LX ",highestsong);	putc(13);putc(10);
	
}

//-----------------------------------
char	song(int32 startsector,int32 endsector){
	int32 ccltemp;
	short int hardflag;
//	static char volume;
	char insanity, sectprint;
	char shutdowncounter, x ;
	x=0;
	insanity=0;
	sectprint=1;
	resetvs1001();
	startsector	=	startsector/BPB_SecPerClus;
	endsector	=	endsector/BPB_SecPerClus;
	for(;startsector<=endsector;startsector++){
		for (x=0;x<BPB_SecPerClus;x++){
			ccltemp=ccl-2;
			ccltemp=ccltemp * (int32)BPB_SecPerClus;
//			ccltemp=ccltemp + (int32)bpbstart;
//			ccltemp=ccltemp + (int32)firstdatasector;
			ccltemp=ccltemp + (int32)datsec;
			ccltemp=ccltemp + (int32)x;
			if (sectprint==1){
				printout_sector(ccltemp); 
				sectprint=0;
			}
			getdatafromcf(ccltemp);
			if(printout()){
				insanity++;
				if (insanity>120){
					volume = spicommand(0x03,0x0b,0x00,0x00);
					resetvs1001_hard();
					resetvs1001();
					spicommand(0x02,0x0b,volume,volume);
					insanity=0;
				}
			}else{insanity--;
				if(insanity<2){insanity=2;}
			}
			if (!input(pin_b7)){return('n');}
			if (!input(pin_b6)){
				if (currentsong>0){return('p');}
			}
		}
		pcl=ccl;
		ccl=readfat(pcl);
		if (!input(pin_b3)){
			hardflag=0;
			shutdowncounter=250;
			volume=spicommand(0x03,0x0b,0x03,0x14);
			while (!input(pin_b3)){
				delay_ms(8);
				if (shutdowncounter==0){
					xreset=0;
					hardflag=1;
				}
				shutdowncounter--;
			}
			intcon=0x08;
			sleep();
			intcon=0x00;
			if(hardflag){
				xreset=1;
				delay_ms(1);
				spicommand(0x02,0x00,0x03,0x04);
				delay_ms(1);
				spicommand(0x02,0x00,0x03,0x00);
				delay_ms(1);
				spicommand(0x02,0x0b,volume,volume);
			}
			morezeroes();
			enable_interrupts(GLOBAL);
			enable_interrupts(INT_TIMER0);
		}
/*
		if (!input(pin_b5)){
			volume = spicommand(0x03,0x0b,0x00,0x00);
			if (volume<255){
				volume++;
			}
			spicommand(0x02,0x0b,volume,volume);
		}
		if (!input(pin_b4)){
			volume = spicommand(0x03,0x0b,0x00,0x00);
			if (volume>0){
				volume--;
			}
			spicommand(0x02,0x0b,volume,volume);
		}
*/
	}
	return('s');
}

//super fat :::::
//-----------------------------------
////////////////////////////
int32 readfat(int32 fatoffset){
	int16 temp;
	int32 tempb;
	int8	los;
	temp=0;
	if (fatmode==32){
		fatoffset=fatoffset*2;
	}
	los = *(((char*)&fatoffset)+0);
	fatoffset=fatoffset / 256; 
	fatoffset+=fatstart;
	getdatafromcf(fatoffset);
	cfskip(los);
	cfread();
	temp = ((int16) data_hi * 256)+ (int16) data_lo;
	if (fatmode==16){
		return temp;
	}
	cfread();
	tempb=0;
	tempb = ((int16) data_hi * 256)+ (int16) data_lo;
	tempb=tempb<<16;
	tempb=tempb+(int32) temp;
//	printf(" cluster getter returns:::%4LX   ",tempb);
	return tempb;
}
//-----------------------------------


void find_bpb(){
int32 bigtemp;
	bpbstart=0;
	getdatafromcf(0x00000000);
	cfskip(0xE3);
	cfread();
	bpbstart=((int16) data_hi<<8);
	bpbstart+=data_lo;
	getdatafromcf((int32) bpbstart);

	cfskip(5);
	cfread();
	BPB_bytspersec=data_hi;	//11
	cfread();
	BPB_bytspersec=BPB_bytspersec+((int16) data_lo<<8); //11.12
	BPB_SecPerClus=data_hi;	//13
	cfread();
	BPB_ResvdSecCnt=((int16) data_hi<<8)+data_lo;  //14.15
	cfread();

	BPB_NumFATs=data_lo;  //16
	BPB_RootEntCnt=data_hi;  //17
	cfread();
	BPB_RootEntCnt=BPB_RootEntCnt+((int16) data_lo<<8);  //17.18
	cfread();
	cfread();
	BPB_FATSz16=data_lo+((int16) data_hi<<8);  //22.23

	cfskip(6);
	cfread();
	BPB_FATSz32=0;
	BPB_FATSz32=data_lo+((int32) data_hi<<8);  //36.37
	bigtemp=BPB_FATSz32;
	cfread();
	BPB_FATSz32=data_lo+((int32) data_hi<<8);  //36.37.38.39
	BPB_FATSz32=BPB_FATSz32 <<16;
	BPB_FATSz32=bigtemp+BPB_FATSz32;
	cfread();
	cfread();
	cfread();
	BPB_RootClus=data_lo+((int32) data_hi<<8);  //44.45
	bigtemp=BPB_RootClus;

	cfread();
	BPB_RootClus=data_lo+((int32) data_hi<<8);  //44.45.46.47
	BPB_RootClus=BPB_RootClus<<16;
	BPB_RootClus=BPB_RootClus+bigtemp;
	root_ccl=BPB_RootClus;

	fatstart=bpbstart+BPB_ResvdSecCnt;

	RootDirSectors = ((BPB_RootEntCnt * 32) + (BPB_BytsPerSec - 1)) / BPB_BytsPerSec;
	if(BPB_FATSz16 != 0){
		fatmode=16;
		FirstDataSector = BPB_ResvdSecCnt + (BPB_NumFATs * BPB_FATSz16) + RootDirSectors;
	}else{
 		fatmode=32;
		FirstDataSector = BPB_ResvdSecCnt + (BPB_NumFATs * BPB_FATSz32) + RootDirSectors;
	}
	FirstRootDirSecNum = BPB_ResvdSecCnt + ((int32) BPB_NumFATs * (int32) BPB_FATSz16);
		datsec = (int32)bpbstart + (int32)firstdatasector;




//printf("fm: %4D",fatmode);
//printf(" 16: %4LX",BPB_FATSz16); 
//printf(" clst: %4LX",BPB_RootClus);	
//printf(" bpb %4LX",bpbstart);
	



//	putc(13);putc(10); printf(" bpbstart::%4LX  ",bpbstart);
//	putc(13);putc(10); printf(" BPB_bytspersec:::%4LX  ",BPB_bytspersec);
//	putc(13);putc(10); printf(" BPB_SecPerClus::%4LX  ",BPB_SecPerClus);
//	putc(13);putc(10); printf(" BPB_ResvdSecCnt::%4LX  ",BPB_ResvdSecCnt);	  
//	putc(13);putc(10); printf(" BPB_NumFATs::::%4LX  ",BPB_NumFATs);	
//	putc(13);putc(10); printf(" BPB_RootEntCnt::%4LX  ",BPB_RootEntCnt);
//	putc(13);putc(10); printf(" BPB_FATSz16:::%4LX  ",BPB_FATSz16);
//	putc(13);putc(10); printf(" fatstart::: %4LX  ",fatstart);
//	putc(13);putc(10); printf(" FirstRootDirSecNum::%4LX  ",FirstRootDirSecNum);
//	putc(13);putc(10); printf(" FirstDataSector:::%4LX  ",FirstDataSector);
//	putc(13);putc(10); printf(" RootDirSectors::::%4LX  ",RootDirSectors);
//	putc(13);putc(10);







}


short int printout(void){
	char c,i;
	short int insane;
	insane = 1;
	tris_cf_data=0xFF;
	for (i=16;i>0;i--){
		while(!DREQ){insane=0;}
		for (c=16;c>0;c--){
			cfread_vssend();
		}
	}
	tris_cf_data=0x00;
	return (insane);
}

//-----------------------------------
void init(void){
	tris_userport	=0b11111001;	//port b
				//bit 2 must be  output for vs reset pin
	tris_vscontrol	=0xD2;	//port c    iioi ooio
	tris_cf_control =0b00100010;	//port a    xxio ooio
	tris_cf_data	=0x00;	//port d    oooo oooo
	tris_cf_addr	=0x00;	//port e    oooo oooo
	adcon1		=0x06;
	option_reg	=0b00000110;
	adcon0		=0x00;

	xcs=1;			//why are these here??
	cf_control	=0x18;	//
	cf_addr		=0x00;  //
	resetvs1001_hard();

//uart setup
	spen=1;
	spbrg		=0x00;
	sync=1;
	tx9=0;
	csrc=1;
	txen=1;
//spi setup
	cke=1;
	sspen=1;

//startup vs1001
	spicommand(0x02,0x0b,0x20,0x20);
}


//-----------------------------------
void getdatafromcf(int32 lba){
				//char lba0,lba1,lba2,lba3;
//#locate lba=0x58
	lba = lba & 0x0FFFFFFF;
	lba = lba | 0xE0000000;

	cf_data=*(((char*)&lba)+3);
	cf_addr=HEAD_REG;
	we=0;we=1;

	cf_data=*(((char*)&lba)+2);
	cf_addr=CYL_HI_REG;
	we=0;we=1;

	cf_data=*(((char*)&lba)+1);
	cf_addr=CYL_LO_REG;
	we=0;we=1;

	cf_data=*(((char*)&lba)+0);
	cf_addr=SEC_NUM_REG;
	we=0;we=1;

	cf_data=0x01;
	cf_addr=SEC_CNT_REG;
	we=0;we=1;

	cf_data=READ_SEC;
	cf_addr=COMMAND_REG;
	we=0;we=1;

	cf_addr=DATA_REG;

}

//-----------------------------------
void resetvs1001(void){
	spicommand(0x02,0x00,0x03,0x04);
	spicommand(0x02,0x00,0x03,0x00);
	morezeroes();
}

//-----------------------------------
void resetvs1001_hard(void){
#use standard_io(B)
	tris_userport	=0b11111001;
	xreset=0;
	delay_us(10);
	xreset=1;
#use fast_io(B)
}

//-----------------------------------
void morezeroes(void){
	int16 c;
	if (dreq){
		for(c=0;c<2048;c++){
			sdi_out(0);
		}
	}
}
//-----------------------------------
void cfread(){

	checkready();
	tris_cf_data=0xFF;
	CF_DATA=0;
	OE=false;
	data_lo=CF_DATA;
	OE=true;
	checkready();
	OE=false;
	data_hi=CF_DATA;
	OE=true;
	tris_cf_data=0x00;
}

//-----------------------------------
void cfskip(char count){
for (;count>0;count--){
		do{;
		}while(!RDY);
		OE=false;
		OE=true;
		do{;
		}while(!RDY);
		OE=false;
		OE=true;
	}
}

//-----

void cfread_vssend(void){
	checkready();
	OE=0;
	bsync=1;
	txreg=CF_DATA;
	OE=1;
	bsync=0;
	delay_us(5);
	OE=0;
	bsync=1;
	txreg=CF_DATA;
	OE=1;
	bsync=0;
	delay_us(2);
}
//-----------------------------------

int16 spicommand(char aa,bb,a,b){
	int16 indata;
	xcs=0;		//choose the vs1001

	sspbuf=aa;	//load the buffer with command value
	delay_us(12);

	sspbuf=bb;	//load the buffer with address
	delay_us(12);

	sspbuf=a;			//load buffer with hi out data(ignored on read command)
	delay_us(12);
	*(((char*)&indata)+1)=sspbuf;	//put hi byte recieved data into indata(ignored on write command)

	sspbuf=b;			//load buffer with data low value
	delay_us(12);
	*(((char*)&indata)+0)=sspbuf;	//put hi byte recieved data into indata

	delay_us(24);
	xcs=1;				//deselect the vs1001
	return(indata);
}
//-----------------------------------

void sdi_out(data){
	bsync=1;
	txreg=data;
	delay_us(2);
	bsync=0;
	delay_us(4);
}

//-----------------------------------

void cfwrite(void){
	checkready();
	WE=0;
	WE=1;
}
//-----------------------------------

void checkready(void){
	do{;
	}while(!RDY);
}
//-----------------------------------

void checkcard(void){	//also starts it up...
	oe=1;
	we=1;
	ce1=0;
	cf_addr		=0x00;
	do{;
	}while(CD1);
	reset=1;
	delay_us(20);
	reset=0;
	delay_ms(100);
	cf_addr=command_reg;
	cf_data=identify;
	cfwrite();
	cfread();

}


//----------------------------------------random number routines
//char random_byte;

//char rand(void)	{
//	char sum;
//	sum = 0;
//	// This calculates parity on the selected bits (mask = 0xb4).
//	if(random_byte & 0x80)
//		sum = 1;
//	if(random_byte & 0x20)
//		sum ^= 1;
//	if(random_byte & 0x10)
//		sum ^= 1;
//	if(random_byte & 0x04)
//		sum ^= 1;
//	random_byte <<= 1;
//	random_byte |= sum;
//	return(random_byte);
//}

//void srand(char seed) {
//	random_byte = seed;
//}


void printout_sector(int32 sector){ // i kept this in because it does some kind of magic to make everything work... i'll figure out what's going on here someday.
char loop, innerloop; // it doesn't take up much space, and it only takes about 1 ms once at the beginning of a song
//	getdatafromcf(sector);
	for(loop=32;loop>0;loop--){
//		putc('x');putc(13);putc(10);
		for(innerloop=8;innerloop>0;innerloop--){
			cfread();
//			putc(data_lo);putc(data_hi);////if you un-commment all these lines, this function will print out the whole sector contents via the uart.
//			 printf("%X",data_lo);
//			 printf("%X",data_hi);
//			putc('_');
		}
	}
}