//
//	EasyMP3(VS1001K) + MMC/SD MP3 Player(prototype)
//
//	MCU:		ATmega8
//				FUSE bit: D9EFh (external clock)
//	Compiler:	AVR-GCC
//
//	2003.6.3	KAWAKAMI Yukio
//


#include	<avr/io.h>
#include	<avr/signal.h>
#include	<avr/interrupt.h>
#include	<avr/pgmspace.h>

#define		LF	10
#define		ON	1
#define		OFF	0
#define		TRUE	1
#define		FALSE	0

#define		SPI_CS		2	// PORTB
#define		SPI_DIN		3
#define		SPI_CLK		5
#define		SPI_DOUT	4

//#define		MP3_SO		0	// PORTC 未使用
#define		MP3_SCLK	7	// PORTD
#define		MP3_CS		6
#define		MP3_SI		5
#define		MP3_BSYNC	4
#define		MP3_DCLK	3
#define		MP3_DREQ	2

// スイッチフラグの論理ビット
#define		SW_START	0
#define		SW_STOP		0
#define		SW_REW		1
#define		SW_FF		2
#define		SW_VOLDOWN	3
#define		SW_VOLUP	4

// スイッチの物理ビット
#define		SW_PORT_START	2	// PINC
#define		SW_PORT_STOP	2	// == SW_PORT_START
#define		SW_PORT_REW		1	// PINB
#define		SW_PORT_FF		0	// PINB
#define		SW_PORT_VOLDOWN	1	// PINC
#define		SW_PORT_VOLUP	0	// PIND  RxDと共用

#define		POWER		3	// PORTC
#define		CHARGE		4	// 充電ON/OFF
#define		VOLTAGE		5	// 電池電圧測定
#define		ACIN		1	// PORTD ACアダプターの検出 TxDと共用
#define		CARD_POWER	0	// PORTC MMC/SDカードの電源(HでOFF, LでON)

#define		BEEP_HIGH	0
#define		BEEP_LOW	1

#define		NOP		asm volatile("nop\n"::)
#define		WDR		asm volatile("wdr\n"::)
#define		SLEEP	asm volatile("sleep\n"::)

// EEPROM アドレス
#define		EEPROM_MUSIC		1	// 再生中の曲番号
#define		EEPROM_CLUSTER_L	2	// 再生中のクラスタ(LOW)
#define		EEPROM_CLUSTER_H	3	//      〃         (HIGH)
#define		EEPROM_REMAIN1		4	// 再生中の曲の残りセクタ数
#define		EEPROM_REMAIN2		5
#define		EEPROM_REMAIN3		6
#define		EEPROM_SIZE1		8	// 再生中の曲データの長さ
#define		EEPROM_SIZE2		9	// SDカードが交換されたかどうか
#define		EEPROM_SIZE3		10	// 判別するのに使う
#define		EEPROM_SIZE4		11
#define		EEPROM_VOLUME		12	// ボリューム


typedef	unsigned char	uchar;
typedef	unsigned int	uint;
typedef	unsigned long	ulong;

// バッテリー電圧  V/7.5*1024
#define		BATT_START		420		// 起動電圧 約3.1V 起動しないと充電できない
#define		BATT_SHUTDOWN	410		// シャットダウン電圧 約3.0V
#define		BATT_42			573		// 4.2V
#define		BATT_40			546		// バッテリー電圧 4.0V
#define		BATT_39			532		// 3.9V
#define		BATT_38			518		// 3.8V
#define		BATT_37			505		// 3.7V
#define		BATT_36			491		// 3.6V
#define		BATT_35			477		// 3.5V
#define		BATT_34			462		// 3.4V
#define		BATT_33			450		// 3.3V
#define		BATT_32			436		// 3.2V

#define		BATT_HIGH		570		// トリクル充電に切り替える電圧 約4.2V
#define		BATT_OVER		586		// 充電での最大電圧 約4.3V
#define		CHARGE_TIMEOVER	3600*15	// 充電時間の最大長(秒)
#define		CHARGE_DUTY		98		// 充電時のデューティサイクル(%)
#define		TRICKLE_DUTY	40		// トリクル充電時のデューティ(%)
#define		PLAY_TRICKLE_DUTY 90	// 再生中のトリクル充電デューティ

uchar	InitCard(void);
uchar	SPI_read_open(ulong adrs);
void	SPI_read_close(void);
uchar	SPI_command(uchar com, ulong arg);
uchar	SPI_in(void);
void	SPI_out(uchar data);
void	SPI_CS_ON(void);
void	SPI_CS_OFF(void);
void	SPI_dummy_clock(void);
void	SPI_wait(void);
void	InitWait(void);

void	read_32(ulong addr);
uint	read_word(ulong addr);
uchar	read_VFAT_info(void);

uint	search_MP3(uint num);
char	play_music(uint n, uint clst, ulong remainbyte);
uint	next_cluster(uint c);
void	beep(uchar n, char err);

void	MP3_sin(PGM_VOID_P data);
void	MP3_init(void);
void	MP3_command(uchar addr, uint arg);
void	MP3_com_write(uchar data);
uint	MP3_command_read(uchar addr);
void	MP3_init();

void	shutdown(char flag);
uint	check_batt(void);
void	write_eeprom(uchar adrs, uchar data);
uchar	read_eeprom(uchar adrs);
void	charge_job(void);
void	switch_wait(void);


// テスト用連続正弦波出力データ		Beepとして使う
PROGMEM uchar BeepData[] = { 0x53, 0xEF, 0x6E, 0x31, 0, 0, 0, 0 };	// 1500Hz
PROGMEM uchar ErrorBeep[] = { 0x53, 0xEF, 0x6E, 0x35, 0, 0, 0, 0 };	// 500Hz
PROGMEM uchar BeepStop[] = { 0x45, 0x78, 0x69, 0x74, 0, 0, 0, 0 };	// 止める


uchar	Buff[32];
uint	Buff_p;
uint	Cluster;		// 現在再生中のクラスタ
uint	NextCluster;	// 次回再生するクラスタ
uint	PlayMusic;		// 再生中の曲番号
uint	MusicCount;		// 現在のカードに入っている曲数
ulong	MusicSize;		// 再生中の曲のサイズ
ulong	RemainSec;		// 再生中の曲の残りセクタ数

uchar	FATtype;		// 0:FAT12  1:FAT16
uchar	SectorsPerCluster;		// 1クラスタのセクタ数
uint	RootDirEntriesCount;	// ルートディレクトリエントリー数
uint	FATstart;		// FAT開始セクタ
uint	DIRstart;		// ルートディレクトリ開始セクタ
ulong	DataStart;		// データ領域開始セクタ

volatile uchar	Volume;			// 音量
volatile uint	BattVolt;		// タイマー割り込みで取得した電源電圧
volatile uint	BattVoltOld;	// 平均値計算用
volatile uchar	SwitchFlag;		// タイマー割り込みで取得したスイッチの情報

volatile uchar	StopSw;		// START/STOPスイッチ入力フラグ
volatile uchar	RewSw;		// REWスイッチ入力フラグ
volatile uchar	FfSw;		// FFスイッチ入力フラグ
volatile uchar	VolUpSw;	// Vol upスイッチ入力フラグ
volatile uchar	VolDownSw;	// Vol downスイッチ入力フラグ

volatile uchar	ChargeFlag;		// 充電フラグ
volatile uchar	ChargeTimer1;	// 充電タイマー１
volatile uint	ChargeTimer2;	// 充電タイマー２（秒単位）

uchar	FATCache[512];	// FATキャッシュ
ulong	FATsec;			// FATキャッシュしているセクタ

char	Debug;			// デバッグフラグ

//*********************************
//	タイマー０オーバーフロー割り込み
//	8MHz/1024/78=100.16 約100Hz
//*********************************
SIGNAL(SIG_OVERFLOW0) {
//SIGNAL(SIG_OUTPUT_COMPARE2) {
	uchar	old_sw;

	// 次の割り込み設定
	outp((uchar)(256-(78-1)), TCNT0);

	// 充電処理
	charge_job();

	// スイッチチェック
	old_sw = SwitchFlag;
	SwitchFlag = 0;
	if (!(inp(PINC) & (1<<SW_PORT_STOP))){
		if (old_sw & (1<<SW_STOP)){
			if (++StopSw == 0)	StopSw = 255;
		} else {
			StopSw = 1;
		}
		SwitchFlag = (1<<SW_STOP);
	}

	if (!(inp(PINB) & (1<<SW_PORT_REW))){
		if (old_sw & (1<<SW_REW)){
			if (++RewSw == 0)	RewSw = 255;
		} else {
			RewSw = 1;
		}
		SwitchFlag |= (1<<SW_REW);
	}

	if (!(inp(PINB) & (1<<SW_PORT_FF))){
		if (old_sw & (1<<SW_FF)){
			if (++FfSw == 0)	FfSw = 255;
		} else {
			FfSw = 1;
		}
		SwitchFlag |= (1<<SW_FF);
	}

	if (!(inp(PINC) & (1<<SW_PORT_VOLDOWN))){
		if (++VolDownSw == 0)	VolDownSw = 255;
		if (VolDownSw >= 20){
			Volume += 8;
			if (Volume > 0xCF)	Volume = 0xCF;
			MP3_command(11, ((uint)Volume << 8)|((uint)Volume));	// 音量設定
			VolDownSw = 1;
		}
		SwitchFlag |= (1<<SW_VOLDOWN);
	} else {
		VolDownSw = 0;
	}

	if (!(inp(PIND) & (1<<SW_PORT_VOLUP))){
		if (++VolUpSw == 0)	VolUpSw = 255;
		if (VolUpSw >= 20){
			Volume -= 8;
			if (Volume < 0x1F)	Volume = 0x1F;
			MP3_command(11, ((uint)Volume << 8)|((uint)Volume));	// 音量設定
			VolUpSw = 1;
		}
		SwitchFlag |= (1<<SW_VOLUP);
	} else {
		VolUpSw = 0;
	}
	
	// 次の A/D変換開始
	outp(0xC8 + 6, ADCSR);	// 変換開始 プリスケーラ 8MHz/64 = 125kHz
}


//*********************************
//	A/D変換の割り込みルーチン
//*********************************
SIGNAL(SIG_ADC) {
	uint volt;

	// A/D変換結果格納
	volt = BattVoltOld;
	BattVoltOld = (uint)inp(ADCL);
	BattVoltOld |= ((uint)inp(ADCH) << 8);

	BattVolt = (BattVoltOld + volt) / 2;	// ２回測定の平均値

	cbi(ADCSR, ADEN);	// A/D変換停止
}


//*********************************
//	INT0(EasyMP3 DREQ)割り込みルーチン
//*********************************
SIGNAL(SIG_INTERRUPT0) {
	// CPUを起こすだけ
}


//*********************************
//	メインルーチン
//*********************************
int main (void) {
	char	r;

	outp(0x03, PORTB);		// PB1〜0 pull up
	outp(0x00, DDRB);		// PB5〜0 in

	outp(0x07, PORTC);		// PC2〜1 pull up PC0=H
	outp(0x19, DDRC);		// PC5 in, PC4 out, PC3 out, PC2 in, PC1 in, PC0 out

	outp(0x61, PORTD);		// PD6,5 High, Vol+ pull up
	outp(0xF8, DDRD);		// PD7〜3 out, PD2 in, PD1 in, PD0 in

	if (inp(MCUCSR) & (1<<WDRF)){
		// ウォッチドッグリセットの場合は停止
		shutdown(1);
	}
	outp(0, MCUCSR);

	WDR;
	outp(0x18, WDTCR);	// WDCEとWDEを1にしてタイマー変更をする
	outp(0x1F, WDTCR);	// ウォッチドッグタイマーセット 約２秒/3V

	outp(0x05, ADMUX);		// A/D ch5
	outp(0xC8 + 6, ADCSR);	// 変換開始 プリスケーラ 8HMz/64 = 125kHz

	outp((uchar)(256-(78-1)), TCNT0);	// タイマー設定値 -78
	outp(0x05, TCCR0);		// タイマープリスケーラ 1/1024
	sbi(TIMSK, TOIE0);		// タイマ割り込み許可

	outp(0x83, MCUCR);		// INT0(EasyMP3 DREQ)立ち上がり割り込み,スリープ許可
	sbi(GICR, INT0);		// 許可

	SwitchFlag = 0;
	BattVolt = 0;
	BattVoltOld = 0;
	ChargeFlag = 0;

	sei();					// 割り込み許可
	while(BattVolt < BATT_START){
		SLEEP;				// 電圧が規定値に達するまで待つ
	}

	sbi(PORTC, POWER);		// 電源ロック & EasyMP3 リセット解除

	Volume = read_eeprom(EEPROM_VOLUME);
	if (Volume == 0xFF)	Volume = 0x4F;

	// EEPROMから前回再生していた曲情報を取得
	PlayMusic = read_eeprom(EEPROM_MUSIC);
	Cluster = (uint)read_eeprom(EEPROM_CLUSTER_H)<<8;
	Cluster |= (uint)read_eeprom(EEPROM_CLUSTER_L);
	RemainSec = (ulong)read_eeprom(EEPROM_REMAIN3)<<16;
	RemainSec |= (ulong)read_eeprom(EEPROM_REMAIN2)<<8;
	RemainSec |= (ulong)read_eeprom(EEPROM_REMAIN1);
	MusicSize = (ulong)read_eeprom(EEPROM_SIZE4)<<24;
	MusicSize |= (ulong)read_eeprom(EEPROM_SIZE3)<<16;
	MusicSize |= (ulong)read_eeprom(EEPROM_SIZE2)<<8;
	MusicSize |= (ulong)read_eeprom(EEPROM_SIZE1);


	for (;;){
		cbi(PORTC, CARD_POWER);	// MMC/SDカード電源 ON
		SLEEP;	// カード電源が安定するまで待つ
		SLEEP;
		SLEEP;
		SLEEP;

		// MMC/SD SPI初期化
		if (InitCard() == 0xFF){
			// MMC/SDカードが無い
			beep(3, BEEP_LOW);
			if (ChargeFlag){
				// 充電中なので待機状態へ
				sbi(PORTC, CARD_POWER);	// MMC/SDカード電源 OFF
				MP3_command(0, 0x0010);	// VS1001k powerdown
				switch_wait();		// スイッチが放されるまで待つ
				StopSw = 0;
				while (StopSw == 0){
					WDR;
					SLEEP;
					if (ChargeFlag == 0){
						shutdown(1); // 充電中断されたのでシャットダウン
					}
				}
				continue;	// 再起動
			} else {
				shutdown(1);	// シャットダウン
			}
		}
		WDR;
		beep(1, BEEP_HIGH);		// BEEP音

		// VFAT情報読み取り
		if (read_VFAT_info()){
			beep(2, BEEP_LOW);	// VFAT情報の異常
			shutdown(1);
		}

		// カード内の曲数確認
		MusicCount = search_MP3(0xFFFF);

		if (MusicCount == 0){
			// MP3ファイルが無い
			beep(1, BEEP_LOW);
			shutdown(1);	// シャットダウン
		}

		if (PlayMusic == 0)	PlayMusic = 1;

		// MMC/SDカードが交換されたかどうか調べる
		search_MP3(PlayMusic);
		if (MusicSize !=
			((ulong)Buff[28] + ((ulong)Buff[29] << 8)
			 + ((ulong)Buff[30] << 16) + ((ulong)Buff[31] << 24))){
			// 演奏する曲のサイズが異なっていれば交換されたとみなす
			PlayMusic = 1;
			Cluster = 0;
		}

		for(;;){

			if (PlayMusic > MusicCount)	PlayMusic = 1;

			switch_wait();		// スイッチが放されるまで待つ
			// 再生
			r = play_music(PlayMusic, Cluster, RemainSec);
			switch_wait();		// スイッチが放されるまで待つ
			if (r < 0){
				beep(-r, BEEP_LOW);		// エラー発生
				shutdown(0);
			} else if (r == 1){		// 途中でSTOPが押された
				if (StopSw > 100){	// 1秒以上の長押しはバッテリー電圧チェック
					if (BattVolt > BATT_40){
						beep(3, BEEP_HIGH);			// 4.0V以上 高音３回
					} else if (BattVolt > BATT_38){
						beep(2, BEEP_HIGH);			// 3.8V以上 高音２回
					} else if (BattVolt > BATT_36){
						beep(1, BEEP_HIGH);			// 3.6V以上 高音１回
					} else if (BattVolt > BATT_34){
						beep(1, BEEP_LOW);			// 3.4V以上 低音１回
					} else if (BattVolt > BATT_32){
						beep(2, BEEP_LOW);			// 3.2V以上 低音２回
					} else {
						beep(3, BEEP_LOW);			// それ以下 低音３回
					}
					continue;	// 続きから演奏
				} else {
					if (ChargeFlag == 0){
						shutdown(0);	// 電源を切る
					} else {
						// 充電中なので待機状態へ
						sbi(PORTC, CARD_POWER);	// MMC/SDカード電源 OFF
						MP3_command(0, 0x0010);	// VS1001k powerdown
						StopSw = 0;
						while (StopSw == 0){
							WDR;
							SLEEP;
							if (ChargeFlag == 0){
								shutdown(0); // 充電中断されたのでシャットダウン
							}
						}
						break;	// 再生再開
					}
				}
			} else if (r == 3){		// REW
				if (RewSw > 100){	// 1秒以上の長押しは最初の曲
					PlayMusic = 1;
				} else if (RewSw > 25){	// 250ms以上の長押しは前の曲
					if (--PlayMusic == 0){
						PlayMusic = MusicCount;
					}
				}
				Cluster = 0;	// 曲の最初から
			} else {	// FF or その曲の再生終了
				PlayMusic++;	// 次の曲
				Cluster = 0;
			}

			if (BattVolt < BATT_START){
				beep(1, BEEP_LOW);	// 起動電圧以下になったら曲間に警告音
			}
		}
	}

}


//*********************************************************
//	スイッチが確実に放されるまで待つ
//*********************************************************
void switch_wait(void){

	sei();
	for (;;) {
		WDR;
		SLEEP;
		SLEEP;
		if (!(SwitchFlag & ((1<<SW_FF)|(1<<SW_REW)|(1<<SW_STOP)))){
			SLEEP;
			SLEEP;
			if (!(SwitchFlag & ((1<<SW_FF)|(1<<SW_REW)|(1<<SW_STOP)))){
				break;
			}
		}
	}
}


//*********************************************************
//	充電処理
//*********************************************************
void charge_job(void){

	if (!(inp(PIND) & (1<<ACIN))){	// ACアダプター検出
		cbi(PORTC, CHARGE);			// OFFなら充電 OFF
		ChargeFlag = 0;
		return;
	}

	if (ChargeFlag == 0){			// 充電していない状態
		if (BattVolt < BATT_40){	// 4.0V以下なら充電開始
			sbi(PORTC, CHARGE);		// 充電 ON
			ChargeFlag = 1;
			ChargeTimer1 = 0;
			ChargeTimer2 = 0;
		}
	} else if (ChargeFlag == 1){	// 急速充電モード
		ChargeTimer1++;
		if (ChargeTimer1 == CHARGE_DUTY){
			cbi(PORTC, CHARGE);		// OFF
		} else if (ChargeTimer1 >= 100){
			ChargeTimer1 = 0;
			if (inp(PORTC) & (1<<CARD_POWER)){
				// 再生中は電流を食われるのでタイマを止める
				ChargeTimer2++;
			}
			if ((ChargeTimer2 >= (uint)CHARGE_TIMEOVER)||
				(BattVolt > BATT_HIGH)){
				ChargeFlag = 2;		// タイムアウトか高電圧ならトリクル充電
			} else {
				sbi(PORTC, CHARGE);		// ON
			}
		}
	} else if (ChargeFlag == 2){	// トリクル充電モード
		ChargeTimer1++;
		if (ChargeTimer1 >= 100){
			ChargeTimer1 = 0;
			if (BattVolt > BATT_OVER){
				cbi(PORTC, CHARGE);	// 電圧が上がりすぎたので止める
				ChargeFlag = 3;		// 強制停止モード
			} else {
				sbi(PORTC, CHARGE);		// ON
			}
		} else {
			if (inp(PORTC) & (1<<CARD_POWER)){
				// 再生中ではない
				if (ChargeTimer1 == TRICKLE_DUTY){
					cbi(PORTC, CHARGE);		// OFF
				}
			} else {
				// 再生中は電流を食われるのでデューティ比をあげる
				if (ChargeTimer1 == PLAY_TRICKLE_DUTY){
					cbi(PORTC, CHARGE);		// OFF
				}
			}
		}
	}
}


//*********************************************************
//	MMC/SDカードの初期化
//*********************************************************
uchar InitCard(void){
	uchar	c;

	outp(0x52, SPCR);	// SPIマスタ, CPOL=0, クロック 8MHz/64=125kHz
	sbi(PORTB, SPI_CS);	// CS=H
	outp(0x2C, DDRB);	// PB5,3,2 out  PB4,1,0 in

	// MMC/SD SPIモード移行
	for (c=0; c < 10; c++){
		SPI_out(0xFF);
	}

	// SPIモード移行コマンド
	cbi(PORTB, SPI_CS);	// CS=L
	SPI_command(0, 0);	// 念のため
	do {
		c = SPI_command(0, 0);
	} while((c != 1)&&(c != 0xFF));
	do {
		c = SPI_command(1, 0);
	} while(c == 1);
	SPI_CS_OFF();

	return c;
}


//*********************************************************
//	VFAT情報読み取り
//*********************************************************
uchar read_VFAT_info(void){
	ulong	sec;
	uint	bpb;
	uint	n;

	// VFAT情報読み取り。セクタ長は 512bytesで決め打ちしている
	read_32(446);								// MBR読み込み
	bpb = (uint)Buff[8] + ((uint)Buff[9]<<8);	// BPB先頭セクタ
	read_32((ulong)bpb * 512);					// 読み込み
	n = (uint)Buff[11] + ((uint)Buff[12] << 8);	// セクタ長
	if (n != 512){
		return 2;	// 1セクタが 512bytesでない
	}
	SectorsPerCluster = Buff[13];		// クラスタあたりのセクタ数
	FATstart = bpb + (uint)Buff[14] + ((uint)Buff[15] << 8);	// 予約セクタ数
	RootDirEntriesCount = (uint)Buff[17] + ((uint)Buff[18] << 8);	// ルートディレクトリエントリ数
	n = (uint)Buff[22] + ((uint)Buff[23] << 8);	// FATのセクタ数
	if (n == 0){
		return 1;	// FAT32らしい
	}
	DIRstart = (uint)FATstart + (uint)Buff[16] * n;	// FATの数×セクタ数
	n = RootDirEntriesCount / 16;	// ルートディレクトリに必要なセクタ数
	if (RootDirEntriesCount % 16){
		n++;	// 念のため、余りが出たら切り上げ。通常は不要だと思うが
	}
	DataStart = (ulong)DIRstart + (ulong)n;		// データ格納領域

	sec = (ulong)Buff[19] + ((ulong)Buff[20] << 8);	// 総セクタ数
	if (sec == 0){
		read_32((ulong)bpb * 512 + 32);		// 読み込み
		sec = (ulong)Buff[0] + ((ulong)Buff[1] << 8) + ((ulong)Buff[2] << 16) + ((ulong)Buff[3] << 24);
	}
	sec -= FATstart;
	sec /= SectorsPerCluster;
	if (sec >= 0x1000){
		FATtype = 1;	// FAT16
	} else {
		FATtype = 0;	// FAT12
	}

	return 0;
}


//*********************************************************
//	MP3ファイルを捜す
//	引数：
//		num	この数だけ見つけたら戻る
//		この数以下であってもディレクトリエントリを全て調べ終わったら戻る
//	戻り値：
//		見つけた数
//		Buff[]	最後に見つかった MP3のディレクトリ情報
//*********************************************************
uint search_MP3(uint num){
	uint	ent;
	ulong	sec;
	uchar	i, j;
	uint	n;

	n = 0;
	sec = (ulong)DIRstart * 512;
	for (ent=0; ent < RootDirEntriesCount; ){
		if (SPI_read_open(sec))	return n;
		for (i=0; i < 16; i++){
			for (j = 0; j < 32; j++){
				Buff[j] = SPI_in();
			}
			if (Buff[0] == 0)	break;
			if (((Buff[26] != 0)||(Buff[27] != 0))&&	// クラスタ番号
				(Buff[0] != 0xE5)&&						// 削除マーク
				(!(Buff[11] & 0x18))&&					// 通常ファイル
				(Buff[8]=='M')&&(Buff[9]=='P')&&(Buff[10]=='3')){ // 拡張子MP3
				n++;
				if (--num == 0)	break;
			}
			ent++;
		}
		SPI_read_close();
		if (Buff[0] == 0)	break;
		if (num == 0)	break;
		sec += 512;	// 次のセクタ
	}
	return n;
}


//****************************************
//	MP3ファイルを再生
//	fn:		曲番号
//	clst:	演奏開始クラスタ。==0 の場合は最初から
//	remainsec: 再生データ残りセクタ数
//****************************************
char play_music(uint fn, uint clst, ulong remainsec){
	uint	i, j;
	ulong	sec;
	uint	remain;
	uint	cn;

	cli();		// 割込み禁止
	if (fn != search_MP3(fn)){
		sei();	// 割り込み許可
		return -1;	// 曲が無い
	}

	MusicSize = (ulong)Buff[28] + ((ulong)Buff[29]<<8) + ((ulong)Buff[30]<<16) + ((ulong)Buff[31]<<24);

	if (clst){
		// 途中から再生
		Cluster = clst;
		RemainSec = remainsec;
		remain = MusicSize - (remainsec * 512);
	} else {
		// 最初から再生
		Cluster = (uint)Buff[26] + ((uint)Buff[27] << 8);
		RemainSec = MusicSize / 512;
		remain = MusicSize % 512;
	}

	if ((Cluster == 0xFFFF)||(Cluster < 2)){
		sei();	// 割り込み許可
		return -2;	// クラスタ異常
	}

	// 次のクラスタを調べておく
	NextCluster = next_cluster(Cluster);

	StopSw = 0;
	RewSw = 0;
	FfSw = 0;

	cn = SectorsPerCluster;
	sec = (((ulong)Cluster - 2) * (ulong)SectorsPerCluster + DataStart)	* 512;

	MP3_init();

	while(RemainSec > 0){
		uchar	data;
		char	bit;

		if (SPI_read_open(sec))	return -2;

		SPI_out(0xFF);		// 1byte目のクロック送出 & WAIT

		for (i=0; i < 512; i++){

			// 転送待ちチェック
			if (!(inp(PIND)&(1<<MP3_DREQ))){

				WDR;	// ウォッチドッグタイマーリセット

				// 待ち状態になった
				if (NextCluster == 0){
					// 次のクラスタを調べる
					for (j = i; j < 512; j++){
						// 読み捨て
						SPI_out(0xFF);		// クロック送出＆WAIT
					}
					SPI_read_close();
					NextCluster = next_cluster(Cluster);
					if (SPI_read_open(sec))	return -2;
					SPI_out(0xFF);		// 1byte目のクロック送出＆WAIT
					for (j=0; j < i; j++){
						// 前の位置に戻る
						SPI_out(0xFF);		// クロック送出＆WAIT
					}
				}

				sei();	// 割り込み許可
				if ((StopSw > 2)||(FfSw > 2)||(RewSw > 2)){
					// STOP or FF or REWボタンが押された
					for (; i < 512; i++){
						SPI_out(0xFF);		// クロック送出＆WAIT
					}
					break;
				}
				while (!(inp(PIND)&(1<<MP3_DREQ))){
					SLEEP;	// スリープ
					check_batt();	// バッテリーチェック
				}
				cli();	// 割込み禁止
			}

			data = inp(SPDR);
			outp(0xFF, SPDR);	// 次のデータリクエスト

			sbi(PORTD, MP3_BSYNC);	// BSYNC = H
			for (bit=0; bit<8; bit++){
				if (data & 0x80){
					sbi(PORTD, MP3_SI);
				} else {
					cbi(PORTD, MP3_SI);
				}
				sbi(PORTD, MP3_DCLK);
				data <<= 1;
				cbi(PORTD, MP3_DCLK);
				cbi(PORTD, MP3_BSYNC);	// BSYNC = L
			}

		}
		SPI_read_close();	// データが 1byte分ずれても大丈夫

		check_batt();	// バッテリーチェック

		// STOP, FFボタンチェック

		if (StopSw > 2){
			while (!(inp(PIND)&(1<<MP3_DREQ)));
			beep(1, BEEP_HIGH);	// 割り込み許可になる
			return 1;
		} else if (FfSw > 2){
			while (!(inp(PIND)&(1<<MP3_DREQ)));
			beep(1, BEEP_HIGH);	// 割り込み許可になる
			return 2;
		} else if (RewSw > 2){
			while (!(inp(PIND)&(1<<MP3_DREQ)));
			beep(1, BEEP_HIGH);	// 割り込み許可になる
			return 3;
		}

		if (--RemainSec == 0)	break;

		if (--cn > 0){
			sec += 512;	// 次のセクタ
		} else {
			// 次のクラスタ
			if (NextCluster == 0){
				Cluster = next_cluster(Cluster);
			} else {
				Cluster = NextCluster;
				NextCluster = 0;
			}

			if ((Cluster == 0xFFFF)||(Cluster < 2)){
				// 異常クラスタが検出されたので強制終了
				remain = 0;
				break;
			}

			sec = (((ulong)Cluster - 2) * (ulong)SectorsPerCluster
				   + DataStart) * 512;
			cn = SectorsPerCluster;

		}
	}

	// １セクタ(512bytes)未満の分を再生
	if (remain > 0){
		uchar	data;
		char	bit;

		if (SPI_read_open(sec))	return -2;
		SPI_out(0xFF);		// 1byte目のクロック送出＆WAIT
		for (i=0; i < remain; i++){

			while(!(inp(PIND)&(1<<MP3_DREQ))){
				sei();	// 割り込み許可
				SLEEP;	// スリープ
				check_batt();	// バッテリーチェック
			}
			cli();	// 割込み禁止

			data = inp(SPDR);
			outp(0xFF, SPDR);	// 次のクロックを送出しておく
			sbi(PORTD, MP3_BSYNC);
			for (bit=0; bit<8; bit++){
				if (data & 0x80){
					sbi(PORTD, MP3_SI);
				} else {
					cbi(PORTD, MP3_SI);
				}
				sbi(PORTD, MP3_DCLK);
				data <<= 1;
				cbi(PORTD, MP3_DCLK);
				cbi(PORTD, MP3_BSYNC);
			}
		}
		for (; i < 512; i++){
			SPI_in();
		}
		SPI_read_close();
	}

	sei();	// 割り込み許可

	return 0;
}


//****************************************
//	次のクラスタを求める
//****************************************
uint next_cluster(uint c){
	ulong	sec;
	uint	data;

	if (FATtype == 0){
		// FAT12
		sec = (ulong)FATstart * 512 + (ulong)c + (c >> 1);
		if ((sec & 511) == 511){
			// セクタをまたぐ
			data = read_word(sec) & 0x00FF;
			data += ((read_word(sec+1) & 0x00FF) << 8);
		} else {
			data = read_word(sec);
		}
		if (c & 1){
			c = data >> 4;
		} else {
			c = data & 0x0fff;
		}
		if (c >= 0x0ff8)	c = 0xFFFF;
	} else {
		// FAT16
		sec = (ulong)FATstart * 512 + (ulong)c * 2;
		c = read_word(sec);
		if (c >= 0xfff8)	c = 0xFFFF;
	}

	return c;
}


//*******************************************************
//	バッテリー電圧を調べ、低すぎればシャットダウンする
//*******************************************************
uint check_batt(void){

	if (BattVolt < BATT_SHUTDOWN){
		SPI_CS_OFF();
		sbi(PORTC, CARD_POWER);	// MMC/SDカード電源 OFF
		beep(4, BEEP_LOW);
		shutdown(0);	// シャットダウン
	}

	return BattVolt;
}


//*********************************************************
//	シャットダウン
//	flag != 0 の場合は EEPROM書き込みを行わずに電源を切る
//*********************************************************
void shutdown(char flag){

	SPI_CS_OFF();
	sbi(PORTC, CARD_POWER);	// MMC/SDカード電源 OFF
	MP3_command(0, 0x0010);	// VS1001k powerdown
	if (!flag){
		write_eeprom(EEPROM_VOLUME, Volume);
		write_eeprom(EEPROM_MUSIC, PlayMusic);
		write_eeprom(EEPROM_CLUSTER_L, Cluster);
		write_eeprom(EEPROM_CLUSTER_H, Cluster>>8);
		write_eeprom(EEPROM_REMAIN1, RemainSec);
		write_eeprom(EEPROM_REMAIN2, RemainSec>>8);
		write_eeprom(EEPROM_REMAIN3, RemainSec>>16);
		write_eeprom(EEPROM_SIZE1, MusicSize);
		write_eeprom(EEPROM_SIZE2, MusicSize>>8);
		write_eeprom(EEPROM_SIZE3, MusicSize>>16);
		write_eeprom(EEPROM_SIZE4, MusicSize>>24);
	}
	for(;;){				// 無限ループ
		cbi(PORTC, POWER);	// Power down
		SLEEP;
	}
}


//*******************************************************
//	EEPROM 書き込み
//*******************************************************
void write_eeprom(uchar adrs, uchar data){

	// 同じ内容なら書き込み動作を行わない
	if (read_eeprom(adrs) != data){
		while(inp(EECR) & (1<<EEWE));
		outp(adrs >> 8, EEARH);
		outp(adrs, EEARL);
		outp(data, EEDR);
		sbi(EECR, EEMWE);
		sbi(EECR, EEWE);
	}
}


//*******************************************************
//	EEPROM 読み込み
//*******************************************************
uchar read_eeprom(uchar adrs){

	while(inp(EECR) & (1<<EEWE));
	outp(adrs >> 8, EEARH);
	outp(adrs, EEARL);
	sbi(EECR, EERE);
	return inp(EEDR);
}


//****************************************
//	BEEP
//	引数：	n	鳴動回数
//			err	!= 0 ならエラー音(低い音)
//	割り込み許可にすることに注意
//****************************************
void beep(uchar n, char err){
	char	i;

	cli();	// MP3_init()処理中に音量調節されたら困るので割込み禁止
	MP3_init();
	sei();	// 割り込み許可
	for (; n > 0; --n){
		if (err){
			MP3_sin(ErrorBeep);
		} else {
			MP3_sin(BeepData);
		}

		// 時間待ち。この間が BEEPの音の長さになる
		for (i=0; i < 10*2; i++){	// 約100ms
			SLEEP;
		}

		MP3_sin(BeepStop);
	
		// BEEPの音間
		for (i=0; i < 3*2; i++){	// 約30ms
			SLEEP;
		}
	}

	MP3_sin(BeepStop);	// 時々止まらないことがあるのでもう一回
	
}


//****************************************
//	EasyMP3 初期化
//****************************************
void MP3_init(void){

	MP3_command(0, 0x0004);			// Soft Reset
	InitWait();
	MP3_command(0, 0x0000);
	while(!(inp(PIND)&(1<<MP3_DREQ)));

	MP3_command(3, 0x8000 + (uint)((14318180)/2000));		// Clock
	MP3_command(11, ((uint)Volume << 8)|((uint)Volume));	// 音量設定
}


//****************************************
//	EasyMP3 テスト用正弦波出力
//****************************************
void MP3_sin(PGM_VOID_P data){
	uchar	i;
	uchar	bit;
	uchar	c;

	for (i=0; i < 8; i++){
		c = (uchar)PRG_RDB(data++);
		sbi(PORTD, MP3_BSYNC);
		for (bit=0; bit<8; bit++){
			if (c & 0x80){
				sbi(PORTD, MP3_SI);
			} else {
				cbi(PORTD, MP3_SI);
			}
			sbi(PORTD, MP3_DCLK);
			c <<= 1;
			cbi(PORTD, MP3_DCLK);
			cbi(PORTD, MP3_BSYNC);
		}
		sbi(PORTD, MP3_SI);
	}
}


//****************************************
//	EasyMP3 コマンド出力
//****************************************
void MP3_command(uchar addr, uint arg){

	cbi(PORTD, MP3_CS);
	MP3_com_write(2);
	MP3_com_write(addr);
	MP3_com_write(arg >> 8);
	MP3_com_write(arg);
	sbi(PORTD, MP3_CS);
}


//****************************************
//	EasyMP3 コマンド入力	未使用
//****************************************
/*
uint MP3_command_read(uchar addr){
	char	i;
	uint	r = 0;

	cbi(PORTD, MP3_CS);
	MP3_com_write(3);
	MP3_com_write(addr);
	for(i=0; i<16; i++){
		sbi(PORTD, MP3_SCLK);
		r <<= 1;
		if (inp(PINC) & (1<<MP3_SO)){
			r |= 1;
		}
		cbi(PORTD, MP3_SCLK);
	}
	sbi(PORTD, MP3_CS);
	return r;
}
*/


//****************************************
//	EasyMP3 コマンド 1byte出力
//****************************************
void MP3_com_write(uchar data){
	char	i;

	for (i=0; i<8; i++){
		if (data & 0x80){
			sbi(PORTD, MP3_SI);
		} else {
			cbi(PORTD, MP3_SI);
		}
		sbi(PORTD, MP3_SCLK);
		data <<= 1;
		cbi(PORTD, MP3_SCLK);
	}
	sbi(PORTD, MP3_SI);
}


//****************************************
//	MMC/SDカードから 32byteを読んで Buffに格納
//****************************************
void read_32(ulong addr){
	uint		i, b;

	if (SPI_read_open(addr & 0xFFFFFE00))	return;
	b = (uint)addr & 0x01FF;
	for (i=0; i < 512; i++){
		if (i == b){
			int	n;
			for (n = 0; n < 32; n++){
				Buff[n] = SPI_in();
				i++;
			}
		} else {
			SPI_in();
		}
	}
	SPI_read_close();
}


//****************************************
//	MMC/SDカードから 2byteを読む
//	FAT読み出しに頻繁に使うので
//	FATCache[512] と FATsec を使う
//	セクタ境界のアクセスはできないので
//	上位工程で考慮すること
//****************************************
uint read_word(ulong addr){
	uint	i;
	uint	b;
	uchar	*p;

	b = addr & 511;
	addr &= 0xFFFFFE00;

	if (addr != FATsec){
		if (SPI_read_open(addr))	return 0;
		p = FATCache;
		for (i=0; i < 512; i++){
			*p++ = SPI_in();
		}
		SPI_read_close();
		FATsec = addr;
	}

	i = (uint)FATCache[b++];
	i |= ((uint)FATCache[b] << 8);
	return i;
}


//****************************************
//	初期化時のクロックウエイト
//****************************************
void InitWait(void){
	uchar	i;

	for(i=0; i< 32; i++){
		NOP;
	}
}


//****************************************
//	MMC/SDカード読み込みオープン
//****************************************
uchar SPI_read_open(ulong adrs){
	uint	i;
	uchar	r;
	uchar	retry;

	SPI_CS_ON();
	// 某メーカーのカードはリトライが必要…？
	for (retry = 0; retry < 100; retry++){
		cbi(PORTB, SPI_CS);		// CS=L
		r = SPI_command(17, adrs);
		if (r == 0){
			for(i=0; i < 5000; i++){	// ものすごく待つ場合がある
				r = SPI_in();
				if (r == 0xFE){
					return 0;	// 転送開始マーク
				}
			}
		} else if (r == 0xFE){
			return 0;	// 正常にオープンできた
		}
		sbi(PORTB, SPI_CS);		// CS=H
		InitWait();
	}
	SPI_CS_OFF();

	return 1;	// オープンできなかった
}


//****************************************
//	MMC/SDカード読み込みクローズ
//	1byteのずれがあっても気にしない
//****************************************
void SPI_read_close(void){
	uint	i;

	SPI_in();	// CRC
	SPI_in();	// CRC
	// BUSYチェック
	for (i=0; i < 2048; i++){
		if (SPI_in() == 0xFF)	break;
	}
	SPI_CS_OFF();
}


//****************************************
//	MMC/SD SPIコマンド出力
//****************************************
uchar SPI_command(uchar com, ulong arg){
	uint	i;
	uchar	r;

	// BUSYチェック
	for (i=0; i < 2048; i++){
		r = SPI_in();
		if (r == 0xFF)	break;
	}
	if (r != 0xFF)	return 1;

	SPI_out(com|0x40);
	SPI_out(arg >> 24);
	SPI_out(arg >> 16);
	SPI_out(arg >> 8);
	SPI_out(arg);
	SPI_out(0x95);		// 初期化コマンドのCRC

	for(i = 0; i < 2048; i++){
		r = SPI_in();
		if (r == 0xFE)		break;
		if (!(r & 0x80))	break;
	}
	return r;
}


//****************************************
//	MMC/SD SPIデータ出力
//****************************************
void SPI_out(uchar data){

	outp(data, SPDR);
	while(!(inp(SPSR) & 0x80));
}


//****************************************
//	MMC/SD SPIデータ入力
//****************************************
uchar SPI_in(void){

	outp(0xFF, SPDR);
	while(!(inp(SPSR) & 0x80));
	return inp(SPDR);
}


//****************************************
//	MMC/SD SPIクロック終了待ち
//	SPDRをアクセスしてない場合は
//	SPIF=0になって無限ループする場合があることに注意
//****************************************
void SPI_wait(void){
	while(!(inp(SPSR) & 0x80));
}	


//****************************************
//	MMC/SD SPI CS = ON
//****************************************
void SPI_CS_ON(void){

	outp(0x50, SPCR);	// SPIマスタ, CPOL=0, クロック 8MHz/4=2MHz
	sbi(SPSR, SPI2X);	// クロックを２倍 4MHz
	cbi(PORTB, SPI_CS);
	outp(0x2C, DDRB);	// PB5,3,2 out  PB4,1,0 in
}


//************************************************************
//	MMC/SD SPI CS = OFF
//	カード未使用時はポートをハイインピーダンスにしておく
//************************************************************
void SPI_CS_OFF(void){
	sbi(PORTB, SPI_CS);
	outp(0x00, DDRB);		// PB5〜0 in
	outp(0x00, SPCR);		// SPI禁止
	cbi(PORTB, SPI_CS);
}