コード例 #1
0
ファイル: sdtest.c プロジェクト: FreeRTOSHAL/testsystem
static void testReadWrite() {
	int32_t ret;
	{
		ret = sd_setBlockSize(sd, SD_BLOCK_SIZE_512B);
		CONFIG_ASSERT(ret == 0);
#if 1
		memset(data, 0x42, ARRAY_SIZE(data));
		/* read 4K from card */
		ret = sd_read(sd, CMD(18), 0, ARRAY_SIZE(data), (uint32_t *) data, 1000 / portTICK_PERIOD_MS);
		CONFIG_ASSERT(ret == 0);
		/* stop transver */
		ret = sd_sendCommand(sd, CMD(12), 0, NULL, 100 / portTICK_PERIOD_MS);
		CONFIG_ASSERT(ret == 0);
#else
		memset(data, 0x00, ARRAY_SIZE(data));
#endif
		/* Write Back test */
		ret = sd_write(sd, CMD(25), 0, ARRAY_SIZE(data), (uint32_t *) data, 1000 / portTICK_PERIOD_MS);
		CONFIG_ASSERT(ret == 0);
		/* stop transver */
		ret = sd_sendCommand(sd, CMD(12), 0, NULL, 100 / portTICK_PERIOD_MS);
		CONFIG_ASSERT(ret == 0);
		vTaskDelay(500 / portTICK_PERIOD_MS);
		/* read 4K from card */
		ret = sd_read(sd, CMD(18), 0, ARRAY_SIZE(data2), (uint32_t *) data2, 1000 / portTICK_PERIOD_MS);
		CONFIG_ASSERT(ret == 0);
		/* stop transver */
		ret = sd_sendCommand(sd, CMD(12), 0, NULL, 100 / portTICK_PERIOD_MS);
		CONFIG_ASSERT(ret == 0);
		ret = memcmp(data, data2, ARRAY_SIZE(data));
		CONFIG_ASSERT(ret == 0);
	}

}
コード例 #2
0
ファイル: sdcard.c プロジェクト: sannyas/avrlib
uint8_t sd_read( uint8_t card_type, uint32_t addr, uint8_t *buff, uint16_t size ){
	uint32_t block_addr;
	uint16_t offset;
	uint8_t resp;
	uint8_t retry;
	uint16_t idx;

	if( card_type == SDCARD_TYPR_SDSC || card_type == SDCARD_TYPR_1 ){
		block_addr = addr &(~0x1ff);
		offset = addr & 0x1ff;
	}
	else{
		block_addr = addr>>5;
		offset = ( addr - (block_addr<<5) ) * 16;
	}
	PDEBUG( "read block addr %u\n", block_addr );
	PDEBUG( "offset %u\n", offset );

	resp = sd_sendCommand( READ_SINGLE_BLOCK, block_addr );
	if( resp != 0x00 ){
		PDEBUG( "CMD READ_SINGLE_BLOCK failure: %d\n", resp );
		return SDCARD_FAILURE;
	}

	/* Wait for token 0xfe */
	sd_pin_CS_setValue( 0 );
	retry = RETRY_CMD_COUNT;
	do{
		resp = sd_spi_rw( 0xff );
		if( retry-- == 0 ){
			sd_pin_CS_setValue( 1 );
			PDEBUG( "wait for token: timeout\n" );
			return SDCARD_FAILURE;
		}
	}while( resp != 0xfe );


	sd_readBuffer( 0, offset );	
	sd_readBuffer( buff, size );
	sd_readBuffer( 0, 514-size-offset );
	sd_pin_CS_setValue( 1 );
	sd_clockDelay( 10 );
	

	/*
	retry = 0;
	for( idx=0; idx<512; ++idx ){
		printf( "%x ", sd_spi_rw( 0xff ) );
		++retry;
		if( retry == 32 ){
			retry = 0;
			printf( "\n" );
		}
	}
	sd_spi_rw( 0xff );
	sd_spi_rw( 0xff );
	sd_spi_rw( 0xff );
	sd_pin_CS_setValue( 1 );
	*/

	//_delay_ms( 1000 );
	PDEBUG( "Read OK\n" );
}
コード例 #3
0
ファイル: sdcard.c プロジェクト: sannyas/avrlib
uint8_t __sd_init( void ){
	uint16_t retry;
	uint8_t resp;

	sd_pin_setup();
	sd_clockDelay( 10 ); // 80 clock
	//sd_pin_CS_setValue( 0 );

	/* 发送CMD0, 进入SPI模式 */
	retry = RETRY_CMD_COUNT;
	do{
		resp = sd_sendCommand( CMD0, 0 );
		if( --retry == 0 ) break;
	}while( resp != IN_IDLE_STATE );
	sd_clockDelay( 2 );
	PDEBUG( "CMD0 response 0x%x\n", resp );
	if( resp != IN_IDLE_STATE ){
		PDEBUG( "CMD0 failure\n" );
		return SDCARD_FAILURE;
	}

	/* 
	 * 发送CMD8命令, 1.x的卡不支持CMD8命令, 对于2.0卡
	 * 该命令是必要的, 可用于判断卡的版本
	 */ 
	retry = RETRY_CMD_COUNT;
	do{
		resp = sd_sendCommand( CMD8, 0x1aa );
		if( --retry == 0 ) break;
	}while( resp == 0xff );
	sd_clockDelay( 2 );
	PDEBUG( "CMD8 response: 0x%x\n", resp );
	if( resp == 0xff ){
		PDEBUG( "CMD8 failure\n" );
		return SDCARD_FAILURE;
	}

	/*
	 * 如果响应CMD8, 则为2.00卡
	 */
	if( resp == IN_IDLE_STATE ){ 
		PDEBUG( "This is V2.00 Card\n" );
		//sd_readBuffer( resp_data, 4 );
		PDEBUG( "resp data = 0x%x, 0x%x, 0x%x, 0x%x\n", resp_data[0], resp_data[1],resp_data[2],resp_data[3] );
		if( resp_data[2] == 0x01 && resp_data[3] == 0xaa ){
		//if( 1 ){ /* TODO */
			/*
			 * 发送ACMD41
			 */
			retry = RETRY_CMD_COUNT;
			do{
				resp = sd_sendCommand( CMD55, 0 );
				sd_clockDelay( 2 );
				resp = sd_sendCommand( ACMD41, 0x40000000 );
				if( --retry == 0 ) break;
			}while( resp != 0x00 );
			sd_clockDelay( 2 );
			PDEBUG( "ACMD41 response : 0x%x\n", resp );
			if( resp != 0x00 ){
				PDEBUG( "ACMD41 failure\n" );
				return SDCARD_FAILURE;
			}
			PDEBUG( "ACMD41 OK\n" );

			/*
			 * 发送CMD58, read ocr
			 */
			retry = RETRY_CMD_COUNT;
			do{
				resp = sd_sendCommand( CMD58, 0 ); // 返回R3
				if( --retry == 0 ) break;
			}while( resp != 0x00 );
			PDEBUG( "CMD58 response : 0x%x\n", resp );
			PDEBUG( "resp data = 0x%x\n", resp_data[0] );
			if( resp_data[0]&OCR_CCS_BYTE ){
				PDEBUG( "SDHC or SDXC\n" );
				return SDCARD_TYPR_SDHC;
			}
			else{
				PDEBUG( "SDSC\n" );
				return SDCARD_TYPR_SDSC;
			}



		}else{
			PDEBUG( "CMD8 response error\n" );
			return SDCARD_FAILURE;
		}
	}

	/*
	 * 如果不能正确响应CMD8, 则为1.x卡
	 */
	//else if( resp == (IN_IDLE_STATE|ILLEGAL_COMMAND) ){ // V 1.x
	else{
		PDEBUG( "This is V1.x Card\n" );
		/*
		 * 发送ACMD41
		 */
		retry = RETRY_CMD_COUNT;
		do{
			resp = sd_sendCommand( CMD55, 0 );
			resp = sd_sendCommand( ACMD41, 0 );
			if( --retry == 0 ) break;
		}while( resp != 0x00 );
		PDEBUG( "ACMD41 response : 0x%x\n", resp );
		if( resp != 0x00 ){
			PDEBUG( "ACMD41 failure\n" );
			return SDCARD_FAILURE;
		}
		PDEBUG( "ACMD41 OK\n" );

		return SDCARD_TYPR_1;
	}


	PDEBUG( "init OK\n" );
	return SDCARD_SUCCESS;
}
コード例 #4
0
ファイル: sdtest.c プロジェクト: FreeRTOSHAL/testsystem
void sdtest_task(void *d) {
	struct sd_response res;
	int32_t ret;
	uint32_t arg;
	uint32_t rca;
	(void) data;
	ret = sd_sendCommand(sd, CMD(0), 0, NULL, 100 / portTICK_PERIOD_MS);
	CONFIG_ASSERT(ret == 0);
	{
		arg = 0;
		arg |= (0x1 << 8); /* Select 2.7 - 3.3 V */
		arg |= (0x42 << 0); /* 8 Bit Check Pattern */
		ret = sd_sendCommand(sd, CMD(8), arg, &res, 100 / portTICK_PERIOD_MS);
		/* Only Version >= 2.0 is suppored in this test */
		CONFIG_ASSERT(ret == 0);
		/* Voltage shall acceped and check pattern is 0x42 */
		CONFIG_ASSERT((res.data[3] & 0xFFF) == ((1 << 8) | (0x42 << 0)));
	}
	{
		arg = 0;
		arg |= BIT(19) | BIT(20) | BIT(31); /* aprox 3.3 is used */;
		arg |= BIT(28); /* Switch from Power Save to max perf */
		arg |= BIT(30); /* Acrivate SDHC or SDXC Support */
		do {
			/* Send ACMD41 -> CMD55 + ACMD41 */
			ret = sd_sendCommand(sd, CMD(55), 0, &res, 100 / portTICK_PERIOD_MS);
			CONFIG_ASSERT(ret == 0);
			ret = sd_sendCommand(sd, ACMD(41), arg, &res, 100 / portTICK_PERIOD_MS);
			CONFIG_ASSERT(ret == 0);
			
		} while (((res.data[3] >> 31) & 0x1) != 0x1);
	}
	{
		/* Ask for CID */
		ret = sd_sendCommand(sd, CMD(2), 0, &res, 100 / portTICK_PERIOD_MS);
		CONFIG_ASSERT(ret == 0);
		/* Set Card to ready mode and get RCA*/
		ret = sd_sendCommand(sd, CMD(3), 0, &res, 100 / portTICK_PERIOD_MS);
		CONFIG_ASSERT(ret == 0);
		rca = res.data[3] & 0xFFFF0000;
		/* Set Card is transver mode */
		ret = sd_sendCommand(sd, CMD(7), rca, 0, 100 / portTICK_PERIOD_MS);
		CONFIG_ASSERT(ret == 0);
	}
	testReadWrite();
	{
		arg = 0;
		arg |= 2;
		ret = sd_sendCommand(sd, CMD(55), rca, NULL, 100 / portTICK_PERIOD_MS);
		CONFIG_ASSERT(ret == 0);
		ret = sd_sendCommand(sd, ACMD(6), arg, NULL, 100 / portTICK_PERIOD_MS);
		CONFIG_ASSERT(ret == 0);
		ret = sd_setBusWide(sd, SD_BusWide_4b);
		CONFIG_ASSERT(ret == 0);
	}
	testReadWrite();
	{
		ret = sd_setClock(sd, 48000000);
		CONFIG_ASSERT(ret == 0);
	}
	testReadWrite();
	vTaskSuspend(NULL);
}