main
Default mainpagebasic-sdcard-projectmain
Description Source Call Graph
Start Line: 264
int main(void)
{
    unsigned char pBuffer[SD_BLOCK_SIZE * NB_MULTI_BLOCKS];
    unsigned int block;
    unsigned int i;
    unsigned short multiBlock;
    unsigned char error;

    TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
    printf("-- Basic SD-Card MCI Mode Project %s --\n\r", SOFTPACK_VERSION);
    printf("-- %s\n\r", BOARD_NAME);
    printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);

    // Configure SDcard pins
    PIO_Configure(pinsSd, PIO_LISTSIZE(pinsSd));

    // Wait for SD card connection (if supported)
    WaitSdConn();

    // Check if card is write-protected (if supported)
    CheckProtection();

    // Initialize the MCI driver
    AIC_ConfigureIT(BOARD_SD_MCI_ID,  AT91C_AIC_PRIOR_LOWEST, ISR_Mci0);
    MCI_Init(&mciDrv, BOARD_SD_MCI_BASE, BOARD_SD_MCI_ID, BOARD_SD_SLOT);
    AIC_EnableIT(BOARD_SD_MCI_ID);

    // Initialize the SD card driver
    if (SD_Init(&sdDrv, (SdDriver *)&mciDrv)) {

        printf("-E- SD/MMC card initialization failed\n\r");
    }
    else {

        printf("-I- SD/MMC card initialization successful\n\r");
        printf("-I- Card size: %u MB\n\r", SD_TOTAL_SIZE(&sdDrv)/(1024*1024));
        printf("-I- Block size: %d Bytes\n\r", (SD_TOTAL_SIZE(&sdDrv) / SD_TOTAL_BLOCK(&sdDrv)) );
    }
    MCI_SetSpeed(&mciDrv, 10000000);

    // Perform tests on each block
    multiBlock = 1;
    for (block=0; block < (SD_TOTAL_BLOCK(&sdDrv)-multiBlock); ) {
        // Perform single block or multi block transfer
        printf("\r-I- Testing block [%6u - %6u] ...", block, (block + multiBlock -1));

        // Clear the block
        memset(pBuffer, 0, SD_BLOCK_SIZE * multiBlock);
        for (i=0; i < SD_BLOCK_SIZE * multiBlock; i++) {

            ASSERT(pBuffer[i] == 0,
                   "\n\r-F- Invalid data at pBuffer[%u] before write ! (expected 0x00, read 0x%02X)\n\r",
                   i, pBuffer[i]);
        }
        error = SD_WriteBlock(&sdDrv, block, multiBlock, pBuffer);
        ASSERT(!error, "\n\r-F- Failed to write block (%d) #%u\n\r", error, block);

        // Read back the data to check the write operation
        memset(pBuffer, 0xFF, SD_BLOCK_SIZE * multiBlock);
        error = SD_ReadBlock(&sdDrv, block, multiBlock, pBuffer);
        ASSERT(!error, "\n\r-F- Failed to read block (%d) #%u\n\r", error, block);
        for (i=0; i < SD_BLOCK_SIZE * multiBlock; i++) {

            ASSERT(pBuffer[i] == 0,
                   "\n\r-F- Invalid data at pBuffer[%u] (expected 0x00, read 0x%02X)\n\r",
                   i, pBuffer[i]);
        }

        // Write a checkerboard pattern on the block
        for (i=0; i < SD_BLOCK_SIZE * multiBlock; i++) {

            if ((i & 1) == 0) {

                pBuffer[i] = (i & 0x55);
            }
            else {

                pBuffer[i] = (i & 0xAA);
            }
        }
        error = SD_WriteBlock(&sdDrv, block, multiBlock, pBuffer);
        ASSERT(!error, "\n\r-F- Failed to write block #%u\n\r", block);

        // Read back the data to check the write operation
        memset(pBuffer, 0, SD_BLOCK_SIZE * multiBlock);
        error = SD_ReadBlock(&sdDrv, block, multiBlock, pBuffer);
        ASSERT(!error, "\n\r-F- Failed to read block #%u\n\r", block);
        for (i=0; i < SD_BLOCK_SIZE * multiBlock; i++) {

            ASSERT((((i & 1) == 0) && (pBuffer[i] == (i & 0x55)))
                   || (pBuffer[i] == (i & 0xAA)),
                   "\n\r-F- Invalid data at pBuffer[%u] (expected 0x%02X, read 0x%02X)\n\r",
                   i, ((i & 1) == 0) ? (i & 0x55) : (i & 0xAA), pBuffer[i]);
        }

        block += multiBlock;

        // Perform different single or multiple bloc operations
        if (++multiBlock > NB_MULTI_BLOCKS)
            multiBlock = 1;
    }

    #ifdef MULTIPLE_TEST
    MCI_SetSpeed(&mciDrv, 1000000);
    block=0;
    for (; block < SD_TOTAL_BLOCK(&sdDrv)-NB_MULTI_BLOCKS; ) {

        for (multiBlock = 0; multiBlock < NB_MULTI_BLOCKS; multiBlock++) {
            for (i=0; i < SD_BLOCK_SIZE; i++) {
                    pBuffer[i] = ((block + multiBlock) & 0xFF);
            }
            printf("\r-I- Writing block [%6u] ...             ", (block + multiBlock));
            error = SD_WriteBlock(&sdDrv, (block + multiBlock), 1, pBuffer);
            ASSERT(!error, "\n\r-F- Failed to write block #%u\n\r", (block + multiBlock));
        }

        printf("\n\r");

        for (multiBlock = 0; multiBlock < NB_MULTI_BLOCKS; multiBlock++) {
            printf("\r-I- Reading block [%6u] ... ", (block + multiBlock));
            error = SD_ReadBlock(&sdDrv, (block + multiBlock), 1, pBuffer);
            // Dump(pBuffer, SD_BLOCK_SIZE);
            ASSERT(!error, "\n\r-F- Failed to read block #%u\n\r", (block + multiBlock));
            for (i=0; i < SD_BLOCK_SIZE; i++) {

                ASSERT(pBuffer[i] == ((block + multiBlock) & 0xFF),
                       "\n\r-F- Invalid data at pBuffer[%u] (expected 0x%02X, read 0x%02X)\n\r",
                       i, ((block + multiBlock) & 0xFF), pBuffer[i]);
            }
        }
        printf("\n\r");

        block+= NB_MULTI_BLOCKS;
    }
    #endif

    error = SD_Stop(&sdDrv, (SdDriver *)&mciDrv);
    ASSERT(!error, "\n\r-F- Failed to stop SD card!\n\r");

    return 0;
}