/*---------------------------------------------------------------------------*
  Project:  CTR - rtfs interface for SD Memory Card
  File:     drnand.h

  Copyright 2006,2007 Nintendo.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.
 *---------------------------------------------------------------------------*/

#include <twl/rtfs.h>
#include <portconf.h>
//#if (INCLUDE_SD)

#include "sdmc_config.h"
#include <twl/sdmc.h>
#include "sdif_ip.h"
#include "sdif_reg.h"

#if (SD_DEBUG_PRINT_ON == 1)
    #if (CTR_DEF_ENVIRONMENT_DSEMU == 1)
        #define PRINTDEBUG    osTPrintf
    #else
        #include <ctr/vlink.h>
        #define PRINTDEBUG    vlink_dos_printf
    #endif
#else
    #define PRINTDEBUG( ...) ((void)0)
#endif


#define NUM_SD_PAGES
#define SD_PAGE_SIZE


/*---------------------------------------------------------------------------*
  extern変数
 *---------------------------------------------------------------------------*/
extern int  rtfs_first_stat_flag[26];

/*SDメモリカードのスペック構造体*/
extern SdmcSpec    sdmc_current_spec;


/*---------------------------------------------------------------------------*
  extern関数
 *---------------------------------------------------------------------------*/
extern SDMC_ERR_CODE sdmcGoIdle(void (*func1)(),void (*func2)());
extern void i_sdmcCalcSize( void); //TODO:sdmc_current_specを構造体に入れること


/*---------------------------------------------------------------------------*
  static変数
 *---------------------------------------------------------------------------*/
static int  nand_drive_no;


/*---------------------------------------------------------------------------*
  static関数
 *---------------------------------------------------------------------------*/
static void sdi_get_CHS_params( void);
static u32  sdi_get_ceil( u32 cval, u32 mval);
static void sdi_get_nom( void);
static void sdi_get_fatparams( void);
static void sdi_build_partition_table( void);



/*---------------------------------------------------------------------------*
  Name:         nandCheckMedia

  Description:  MBRのシグネチャおよび
                パーティションのフォーマット種別をチェックする

  Arguments:    

  Returns:      TRUE/FALSE
                （FALSEなら pc_format_media が必要）
 *---------------------------------------------------------------------------*/
BOOL nandCheckMedia( void)
{
    u16             i;
    SdmcResultInfo  SdResult;
    u8*             bufp;
    u32             buffer[512/4];
    u8              systemid;

    /**/
    sdmcSelect( (u16)SDMC_PORT_NAND);
  
    /**/
    if( sdmcReadFifo( buffer, 1, 0, NULL, &SdResult)) {
        return( FALSE);
    }

    bufp = (u8*)buffer;

    /* Check the Signature Word. */
    if( (bufp[510]!=0x55) || (bufp[511]!=0xAA)) {
        return( FALSE);
    }
    /* Check the System ID of partition. */
    systemid = bufp[450];
    if( (systemid!=0x01) && (systemid!=0x04) && (systemid!=0x06) &&
        (systemid!=0x0B) && (systemid!=0x0C)) {
        return( FALSE);
    }
    /* Check the System ID of unuse partitions. */
    for( i=1; i<4; i++) {
        systemid = bufp[450+(16*i)];
        if( systemid != 0x00) {
            return( FALSE);
        }
    }
    /**/
    /*もっと厳密にチェックするならパーティション0開始位置の
        正当性も調べる*/
    return( TRUE);
}


/*---------------------------------------------------------------------------*
  Name:         nandRtfsIo

  Description:  上位層からのセクタリード／ライト要求を受ける

  Arguments:    driveno : ドライブ番号
                block : 開始ブロック番号
                buffer : 
                count : ブロック数
                reading : リード要求時にTRUE

  Returns:      TRUE/FALSE
 *---------------------------------------------------------------------------*/
BOOL nandRtfsIo( int driveno, dword block, void* buffer, word count, BOOLEAN reading)
{
    u16               result;
    SdmcResultInfo    SdResult;
    
    /**/
    sdmcSelect( (u16)SDMC_PORT_NAND);
  
    if( reading) {
        PRINTDEBUG( "DEVCTL_IO_READ ... block:%x, count:%x -> buf:%x\n", block, count, buffer);
        result = sdmcReadFifo( buffer, count, block, NULL, &SdResult);
//        result = sdmcRead( buffer, count, block, NULL, &SdResult);
    }else{
        PRINTDEBUG( "DEVCTL_IO_WRITE ... block:%x, count:%x <- buf:%x\n", block, count, buffer);
        result = sdmcWriteFifo( buffer, count, block, NULL, &SdResult);
//        result = sdmcWrite( buffer, count, block, NULL, &SdResult);
    }
    if( result) {
        return FALSE;
    }

    return TRUE;
}

/*---------------------------------------------------------------------------*
  Name:         nandRtfsCtrl

  Description:  上位層からのコントロール要求を受ける

  Arguments:    driveno : ドライブ番号
                opcode : 要求の種類
                pargs : 

  Returns:
  Memo :        DRIVE_FLAGS_REMOVABLEの場合、ドライバのIO関数を呼ぶ前に
                CTRL関数のDEVCTL_CHECK_STATUSが呼ばれる。
                DEVTEST_CHANGED→DEVTEST_NOCHANGEが確認されるとRTFSはセクタ0を
                読みに行き、FATパラメータを取得した上で目的のセクタを読みに行く。
                CTRL関数の前にはDEVCTL_CHECK_STATUSが呼ばれないので、DEVCTL_
                GET_GEOMETRYでは自前で再挿入をチェックする必要がある。
 *---------------------------------------------------------------------------*/
int nandRtfsCtrl( int driveno, int opcode, void* pargs)
{
    DDRIVE       *pdr;
    DEV_GEOMETRY gc;
    int          heads, secptrack;

    /**/
    sdmcSelect( (u16)SDMC_PORT_NAND);

    pdr = pc_drno_to_drive_struct( driveno);
    
    switch( opcode) {
      case DEVCTL_GET_GEOMETRY:    //formatまたはpartirionするときにRTFSが使うパラメータ
        PRINTDEBUG( "DEVCTL_GET_GEOMETRY\n");
      
        rtfs_memset( &gc, (byte)0, sizeof(gc));

        i_sdmcCalcSize();        //TODO:sdmc_current_specを構造体に入れること
        sdi_get_CHS_params();    //最初に呼ぶこと
        sdi_get_fatparams();
        sdi_get_nom();

        PRINTDEBUG( "heads     : 0x%x\n", sdmc_current_spec.heads);
        PRINTDEBUG( "secptrack : 0x%x\n", sdmc_current_spec.secptrack);
        PRINTDEBUG( "cylinders : 0x%x\n", sdmc_current_spec.cylinders);
        PRINTDEBUG( "SC        : 0x%x\n", sdmc_current_spec.SC);
        PRINTDEBUG( "BU        : 0x%x\n", sdmc_current_spec.BU);
        PRINTDEBUG( "RDE       : 0x%x\n", sdmc_current_spec.RDE);
        PRINTDEBUG( "SS        : 0x%x\n", sdmc_current_spec.SS);
        PRINTDEBUG( "RSC       : 0x%x\n", sdmc_current_spec.RSC);
        PRINTDEBUG( "FATBITS   : 0x%x\n", sdmc_current_spec.FATBITS);
        PRINTDEBUG( "SF        : 0x%x\n", sdmc_current_spec.SF);
        PRINTDEBUG( "SSA       : 0x%x\n", sdmc_current_spec.SSA);
        PRINTDEBUG( "NOM       : 0x%x\n", sdmc_current_spec.NOM);
        
        gc.dev_geometry_lbas = (sdmc_current_spec.adjusted_memory_capacity);// - sdmc_current_spec.NOM);
        gc.dev_geometry_heads         = sdmc_current_spec.heads;
        gc.dev_geometry_cylinders     = sdmc_current_spec.cylinders;
        gc.dev_geometry_secptrack     = sdmc_current_spec.secptrack;
        /**/
        gc.fmt_parms_valid     = TRUE;
        gc.fmt.oemname[0]     = 'T';
        gc.fmt.oemname[1]     = 'W';
        gc.fmt.oemname[2]     = 'L';
        gc.fmt.oemname[3]     = '\0';
        gc.fmt.secpalloc     = sdmc_current_spec.SC;    /*sectors per cluster(FIX by capacity)*/
        gc.fmt.secreserved     = sdmc_current_spec.RSC;//sdmc_current_spec.RSC;/*reserved sectors(FIX 1 at FAT12,16)*/
        gc.fmt.numfats         = 2;
        gc.fmt.secpfat        = sdmc_current_spec.SF;
        gc.fmt.numhide         = sdmc_current_spec.NOM;    /**/
        gc.fmt.numroot         = sdmc_current_spec.RDE;    /*FIX*/
        gc.fmt.mediadesc     = 0xF8;
        gc.fmt.secptrk         = sdmc_current_spec.secptrack;    //CHS Recommendation
        gc.fmt.numhead         = sdmc_current_spec.heads;
        gc.fmt.numcyl         = sdmc_current_spec.cylinders;
        gc.fmt.physical_drive_no = driveno;
        gc.fmt.binary_volume_label = BIN_VOL_LABEL;
        gc.fmt.text_volume_label[0] = '\0';
        //TODO:dev_geometry_lbasもセットする必要あるか調べること
        PRINTDEBUG( "heads : 0x%x, secptrack : 0x%x, cylinders : 0x%x\n", gc.dev_geometry_heads, gc.dev_geometry_secptrack, gc.dev_geometry_cylinders);

#if (TARGET_OS_CTR == 1)
        miCpuCopy8( &gc, pargs, sizeof(gc));
//        copybuff( pargs, &gc, sizeof(gc));
#else
        MI_CpuCopy8( &gc, pargs, sizeof(gc));
#endif
        return( 0);
        
      case DEVCTL_FORMAT:
        PRINTDEBUG( "DEVCTL_FORMAT\n");
        sdi_build_partition_table();    //MBRセクタ(パーティションテーブル含む)書き込み
        return( 0);

      case DEVCTL_REPORT_REMOVE:        //抜かれたとき
        PRINTDEBUG( "DEVCTL_REPORT_REMOVE\n");
        pdr->drive_flags &= ~DRIVE_FLAGS_INSERTED;
        return( 0);
        
      case DEVCTL_CHECKSTATUS:    //REMOVABLEの場合、毎回R/W前に呼ばれる
        PRINTDEBUG( "DEVCTL_CHECKSTATUS\n");
        if (!(pdr->drive_flags & DRIVE_FLAGS_REMOVABLE)) {    //リムーバブルでない場合
            return(DEVTEST_NOCHANGE);
        }
        if( rtfs_first_stat_flag[driveno]) {    //初回のCHECKSTATUS時
            rtfs_first_stat_flag[driveno] = 0;
            PRINTDEBUG( "CHANGED!\n");
            return(DEVTEST_CHANGED);
        }else{
            PRINTDEBUG( "DEVTEST_NOCHANGE\n");
            return( DEVTEST_NOCHANGE);
        }
        
      case DEVCTL_WARMSTART:    //attachのときしか呼ばれない
        PRINTDEBUG( "DEVCTL_WARMSTART\n");
        /*-- GoIdleセット --*/
        sdmcGoIdle( NULL, NULL);    //カード初期化シーケンス TODO:1ポートだけにする
        /*------------------*/
        pdr->drive_flags |= (DRIVE_FLAGS_VALID | DRIVE_FLAGS_REMOVABLE | DRIVE_FLAGS_PARTITIONED);
        pdr->partition_number = 0;
        
        pdr->drive_flags |= DRIVE_FLAGS_INSERTED;
        return( 0);
        
      case DEVCTL_POWER_RESTORE:
        PRINTDEBUG( "DEVCTL_POWER_RESTORE\n");
        break;
        
      case DEVCTL_POWER_LOSS:
        PRINTDEBUG( "DEVCTL_POWER_LOSS\n");
        break;
        
      default:
        PRINTDEBUG( "DEVCTL_unknown\n");
        break;
    }
    return( 0);
}

/*---------------------------------------------------------------------------*
  Name:         nandRtfsAttach

  Description:  sdmcドライバをドライブに割り当てる

  Arguments:    driveno : ドライブ番号

  Returns:      
 *---------------------------------------------------------------------------*/
BOOL nandRtfsAttach( int driveno)
{
    BOOLEAN   result;
    DDRIVE    pdr;

    pdr.dev_table_drive_io     = nandRtfsIo;
    pdr.dev_table_perform_device_ioctl = nandRtfsCtrl;
    pdr.register_file_address  = (dword) 0; /* Not used  */
    pdr.interrupt_number       = 0;            /* Not used */
    pdr.drive_flags            = 0;//DRIVE_FLAGS_FAILSAFE;
    pdr.partition_number       = 0;            /* Not used */
    pdr.pcmcia_slot_number     = 0;            /* Not used */
    pdr.controller_number      = 0;
    pdr.logical_unit_number    = 0;

    result = rtfs_attach( driveno, &pdr, "SD1");    //構造体がFSライブラリ側にコピーされる
    
    /*drivenoをグローバル変数に記憶*/
    nand_drive_no = driveno;

    return( result);
}



/*SD File System Specification(仕様書)に基づいた値を出す*/
static void sdi_get_CHS_params( void)
{
    int mbytes;

//    mbytes = (sdmc_current_spec.card_capacity / (1024 * 1024)) * 512;
    mbytes = (sdmc_current_spec.card_capacity >> 11);

    while( 1) {
        if( mbytes <= 2) {
            sdmc_current_spec.heads     = 2;
            sdmc_current_spec.secptrack = 16;
            break;
        }
        if( mbytes <= 16) {
            sdmc_current_spec.heads     = 2;
            sdmc_current_spec.secptrack = 32;
            break;
        }
        if( mbytes <= 32) {
            sdmc_current_spec.heads     = 4;
            sdmc_current_spec.secptrack = 32;
            break;
        }
        if( mbytes <= 128) {
            sdmc_current_spec.heads     = 8;
            sdmc_current_spec.secptrack = 32;
            break;
        }
        if( mbytes <= 256) {
            sdmc_current_spec.heads     = 16;
            sdmc_current_spec.secptrack = 32;
            break;
        }
        if( mbytes <= 504) {
            sdmc_current_spec.heads     = 16;
            sdmc_current_spec.secptrack = 63;
            break;
        }
        if( mbytes <= 1008) {
            sdmc_current_spec.heads     = 32;
            sdmc_current_spec.secptrack = 63;
            break;
        }
        if( mbytes <= 2016) {
            sdmc_current_spec.heads     = 64;
            sdmc_current_spec.secptrack = 63;
            break;
        }
        if( mbytes <= 2048) {
            sdmc_current_spec.heads     = 128;
            sdmc_current_spec.secptrack = 63;
            break;
        }
        if( mbytes <= 4032) {
            sdmc_current_spec.heads     = 128;
            sdmc_current_spec.secptrack = 63;
            break;
        }
        if( mbytes <= 32768) {
            sdmc_current_spec.heads     = 255;
            sdmc_current_spec.secptrack = 63;
            break;
        }
    }

    /*シリンダ数を計算*/
    sdmc_current_spec.cylinders = (sdmc_current_spec.memory_capacity /
                    (sdmc_current_spec.heads * sdmc_current_spec.secptrack));
    
    /*memory_capacityを再計算してadjusted_memory_capacityに格納*/
    sdmc_current_spec.adjusted_memory_capacity = sdmc_current_spec.cylinders *
                    (sdmc_current_spec.heads * sdmc_current_spec.secptrack);
}


/*引数を超える最も小さい整数を算出する*/
static u32 sdi_get_ceil( u32 cval, u32 mval)
{
   return( (cval / mval) + (1 * (cval % mval != 0)));
}


/*マスターブートセクタのセクタ数を返す*/
static void sdi_get_nom( void)
{
    u32 RSC = 1;      //FAT12,16では1
    u32 RDE = 512;    //ルートディレクトリエントリ。FIX
    u32 SS  = 512;    //セクタサイズ。FIX
    u32 TS, SC, n;
    u32 MAX, SFdash;

    TS = sdmc_current_spec.adjusted_memory_capacity;
    SC = sdmc_current_spec.SC;
    
    sdmc_current_spec.SF = sdi_get_ceil( TS/SC * sdmc_current_spec.FATBITS, SS*8);

    /*-----------------------SDHCのとき----------------------------*/
    if( sdmc_current_spec.csd_ver2_flag) {
        sdmc_current_spec.NOM = sdmc_current_spec.BU;
        do {
            n = sdi_get_ceil( 2*sdmc_current_spec.SF, sdmc_current_spec.BU);
            sdmc_current_spec.RSC = (sdmc_current_spec.BU * n) - ( 2 * sdmc_current_spec.SF);
            if( sdmc_current_spec.RSC < 9) {
                sdmc_current_spec.RSC += sdmc_current_spec.BU;
            }
            sdmc_current_spec.SSA = sdmc_current_spec.RSC + (2 * sdmc_current_spec.SF);
            do {
                MAX = ((TS - sdmc_current_spec.NOM - sdmc_current_spec.SSA) / SC) + 1;
                SFdash = sdi_get_ceil( (2+(MAX-1)) * sdmc_current_spec.FATBITS, SS*8);
                if( SFdash > sdmc_current_spec.SF) {
                    sdmc_current_spec.SSA += sdmc_current_spec.BU;
                    sdmc_current_spec.RSC += sdmc_current_spec.BU;
                }else{
                    break;
                }
            }while( 1);
            if( SFdash != sdmc_current_spec.SF) {
                sdmc_current_spec.SF -= 1;
            }else{
                break;
            }
        }while( 1);
    }else{    /*-------------------------SDのとき-------------------------------*/
        do {
            sdmc_current_spec.SSA = RSC + ( 2 * sdmc_current_spec.SF) + sdi_get_ceil( 32*RDE, SS);
            n = sdi_get_ceil( sdmc_current_spec.SSA, sdmc_current_spec.BU);
            sdmc_current_spec.NOM = (sdmc_current_spec.BU * n) - sdmc_current_spec.SSA;
            if( sdmc_current_spec.NOM != sdmc_current_spec.BU) {
                sdmc_current_spec.NOM += sdmc_current_spec.BU;
            }
            do {
                MAX = ((TS - sdmc_current_spec.NOM - sdmc_current_spec.SSA) / SC) + 1;
                SFdash = sdi_get_ceil( (2+(MAX-1)) * sdmc_current_spec.FATBITS, SS*8);
                if( SFdash > sdmc_current_spec.SF) {
                    sdmc_current_spec.NOM += sdmc_current_spec.BU;
                }else{
                    break;
                }
            }while( 1);
            if( SFdash != sdmc_current_spec.SF) {
                sdmc_current_spec.SF = SFdash;
            }else{
                break;    //complete
            }
        }while( 1);
    }

    return;
}

/*FATのビット数を返す*/
static void sdi_get_fatparams( void)
{
    int mbytes;

//    mbytes = (sdmc_current_spec.card_capacity / (1024 * 1024)) * 512;
    mbytes = (sdmc_current_spec.card_capacity >> 11);

    if( mbytes <= 64) {
        sdmc_current_spec.FATBITS = 12;
        sdmc_current_spec.RDE = 512;
        sdmc_current_spec.RSC = 1;
    }else{
        if( mbytes <= 2048) {
            sdmc_current_spec.FATBITS = 16;
            sdmc_current_spec.RDE = 512;
            sdmc_current_spec.RSC = 1;
        }else{
            sdmc_current_spec.FATBITS = 32;
            sdmc_current_spec.RDE = 0;    //FAT32のときは未使用。0にしておかないとRTFSが BAD FORMAT を返す。 
            sdmc_current_spec.RSC = 1;
        }
    }
    
    if( mbytes <= 8) {
        sdmc_current_spec.SC = 16;
        sdmc_current_spec.BU = 16;
        return;
    }
    if( mbytes <= 64) {
        sdmc_current_spec.SC = 32;
        sdmc_current_spec.BU = 32;
        return;
    }
    if( mbytes <= 256) {
        sdmc_current_spec.SC = 32;
        sdmc_current_spec.BU = 64;
        return;
    }
    if( mbytes <= 1024) {
        sdmc_current_spec.SC = 32;
        sdmc_current_spec.BU = 128;
        return;
    }
    if( mbytes <= 2048) {
        sdmc_current_spec.SC = 64;
        sdmc_current_spec.BU = 128;
        return;
    }
    if( mbytes <= 32768) {
        sdmc_current_spec.SC = 64;
        sdmc_current_spec.BU = 8192;
        return;
    }
}

/*MBRセクタ(パーティションセクタ含む)を生成して書き込む*/
static void sdi_build_partition_table( void)
{
    u16 MbrSectDat[512/2];
    u32 starting_head, starting_sect, starting_cyl;
    u32 ending_head, ending_sect, ending_cyl;
    u32 total_sect;
#if (SD_DEBUG_PRINT_ON == 1)    
    u32 starting_data, ending_data;
#endif
    u32 systemid;
    SdmcResultInfo    SdResult;

    /**/
    starting_head = sdmc_current_spec.NOM % (sdmc_current_spec.heads *
                                             sdmc_current_spec.secptrack);
    starting_head /= sdmc_current_spec.secptrack;

    /**/
    starting_sect = (sdmc_current_spec.NOM % sdmc_current_spec.secptrack) + 1;

    /**/
    starting_cyl = sdmc_current_spec.NOM / (sdmc_current_spec.heads *
                                             sdmc_current_spec.secptrack);

    /**/
    total_sect = (sdmc_current_spec.adjusted_memory_capacity - sdmc_current_spec.NOM);
    ending_head = (sdmc_current_spec.NOM + total_sect - 1) %
                    (sdmc_current_spec.heads * sdmc_current_spec.secptrack);
    ending_head /= sdmc_current_spec.secptrack;

    /**/
    ending_sect = ((sdmc_current_spec.NOM + total_sect - 1) %
                    sdmc_current_spec.secptrack) + 1;

    /**/
    ending_cyl = (sdmc_current_spec.NOM + total_sect - 1) /
                    (sdmc_current_spec.heads * sdmc_current_spec.secptrack);

    /**/
    if( sdmc_current_spec.FATBITS == 32) {    //FAT32のとき
        if( total_sect < 0xFB0400) {        //8032.5MBが閾値(SD FileSystemSpec2.00参照)
            systemid = 0x0B;        /* FAT32 */
        }else{
            systemid = 0x0C;        /* FAT32(拡張INT13対応) */
        }
    }else{                                    //FAT12,FAT16のとき
        if( total_sect < 32680) {
            systemid = 0x01;        /* FAT12 */
        }else if( total_sect < 65536) {
            systemid = 0x04;        /* FAT16(16MB〜32MB未満) */
        }else{
            systemid = 0x06;        /* FAT16(32MB〜4GB) */
        }
    }
        
    /*MBRセクタ(パーティションテーブル含む)作成*/
#if (TARGET_OS_CTR == 1)
    miCpuFill8( MbrSectDat, 0, 512);
#else
    MI_CpuFill8( MbrSectDat, 0, 512);
#endif
    MbrSectDat[446/2] = (starting_head<<8);
    //上位8bit:starting_cylの下位8bit, 下位8bit:starting_cylの上位2bit + starting_sect 6bit.
    MbrSectDat[448/2] = (starting_cyl<<8) + ((starting_cyl>>2) & 0xC0) + starting_sect;
    MbrSectDat[450/2] = (ending_head<<8) + systemid;
    //上位8bit:ending_cylの下位8bit, 下位8bit:ending_cylの上位2bit + ending_sect 6bit.
    MbrSectDat[452/2] = (ending_cyl<<8) + ((ending_cyl>>2) & 0xC0) + ending_sect;
    MbrSectDat[454/2] = sdmc_current_spec.NOM;
    MbrSectDat[456/2] = (sdmc_current_spec.NOM>>16);
    MbrSectDat[458/2] = total_sect;
    MbrSectDat[460/2] = (total_sect>>16);
    MbrSectDat[510/2] = 0xAA55;
    /*セクタ0に書き込み*/
    sdmcWriteFifo( MbrSectDat, 1, 0, NULL, &SdResult);
    
    /**/
    PRINTDEBUG( "total    sect : 0x%x\n", total_sect);
    PRINTDEBUG( "starting head : 0x%x\n", starting_head);
    PRINTDEBUG( "starting sect : 0x%x\n", starting_sect);
    PRINTDEBUG( "starting cyl  : 0x%x\n", starting_cyl);
    PRINTDEBUG( "ending   head : 0x%x\n", ending_head);
    PRINTDEBUG( "ending   sect : 0x%x\n", ending_sect);
    PRINTDEBUG( "ending   cyl  : 0x%x\n", ending_cyl);
    PRINTDEBUG( "\n");
#if (SD_DEBUG_PRINT_ON == 1)    
    starting_data = (starting_cyl<<8) + ((starting_cyl>>2) & 0xC0) + starting_sect;
    PRINTDEBUG( "starting data : 0x%x\n", starting_data);
    ending_data = (ending_cyl<<8) + ((ending_cyl>>2) & 0xC0) + ending_sect;
    PRINTDEBUG( "endign   data : 0x%x\n", ending_data);
#endif
}

//#endif /*(INCLUDE_SD)*/