main
Default mainpagebasic-sd-spi-projectmain
Description Source Call Graph
Start Line: 267
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 SPI 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 SPI driver
    AIC_ConfigureIT(BOARD_SD_SPI_ID,  AT91C_AIC_PRIOR_LOWEST, ISR_Spi0);
    SDSPI_Configure(&sdSpiDrv, BOARD_SD_SPI_BASE, BOARD_SD_SPI_ID);
    AIC_EnableIT(BOARD_SD_SPI_ID);

    //SDSPI_ConfigureCS(&sdSpiDrv, BOARD_SD_NPCS, SDSPI_CSR(BOARD_MCK / SPCK));
    SDSPI_ConfigureCS(&sdSpiDrv, BOARD_SD_NPCS, AT45_CSR(BOARD_MCK, SPCK));

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

        printf("-E- SD/MMC card initialization failed\n\r");
        return 0;
    }
    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_CSD_BLOCK_LEN(&sdDrv));
    }

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

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

            ASSERT(pBuffer[i] == 0,
                   "-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, "-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, "-F- Failed to read block (%d) #%u\n\r", error, block);
        for (i=0; i < SD_BLOCK_SIZE * multiBlock; i++) {

            ASSERT(pBuffer[i] == 0,
                   "-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);

        DumpMemorySDSPI(pBuffer, SD_BLOCK_SIZE * multiBlock);

        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]);
        }
        printf("***** Block OK *****\n\r");
        block += multiBlock;

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

    #ifdef MULTIPLE_TEST
    printf("MULTIPLE_TEST\n\r");
    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("-I- Writing block [%6u] ...\n\r", (block + multiBlock));
            error = SD_WriteBlock(&sdDrv, (block + multiBlock), 1, pBuffer);
            ASSERT(!error, "-F- 2 Failed to write block #%u\n\r", (block + multiBlock));
        }


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

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

        block+= NB_MULTI_BLOCKS;
    }
    #endif

    SDSPI_Close(&sdSpiDrv);
    // ASSERT(!error, "\n\r-F- Failed to stop SD card!\n\r");

    return 0;
}