void main(void)
{
#if defined(MAX_UART_RX_BUF_CNT) || defined(MAX_UART_TX_BUF_CNT)
#error "Comment out MAX_UART_RX_BUF_CNT and MAX_UART_TX_BUF_CNT in config.h for this example"
#endif
WD_STOP();
ClockConfig(16);
HardwareInit();
// init uart at 115k
UartInit(115200);
_EINT();
printf("\n\nEnter your name: ");
static uint8_t buf[20];
uint8_t* cur_char = &buf[0];
while(1)
{
// The code will stop here and wait for a character to be received
while((*cur_char++ = getchar()) == '\r')
{
printf("\nHello %s",buf);
}
}
}
void main(void)
{
#if !defined(MAX_UART_RX_BUF_CNT)
#error "Define MAX_UART_RX_BUF_CNT > 0 in config.h for this example"
#endif
WD_STOP();
ClockConfig(16);
HardwareInit();
// init uart at 115k
UartInit(115200);
_EINT();
printf("\n\nEnter your name: ");
static uint8_t buf[30];
uint8_t* cur_char = &buf[0];
while(1)
{
// poll the rx buffer for new data
if (!UartBufEmpty())
{
// pull the data out one byte at a time
*cur_char = getchar();
// was the last character a carriage return?
if (*(cur_char - 1) == '\r')
{
printf("\nHello %s",buf);
}
}
}
}
void
CmtSdCard::InitSetup( OMAP_MMCHS_REGS *mmc ) {
uint32 reg_val;
cmtDebug1( 4, 1, "InitSetup SoftReset", 0 );
BoardInit( mmc );
mmc->MMCHS_SYSCONFIG |= MMC_SOFTRESET;
while( (__raw_readl( &(mmc->MMCHS_SYSSTATUS) ) & RESETDONE) == 0 );
cmtDebug1( 4, 2, "...done. InitSetup AllReset", 0 );
mmc->MMCHS_SYSCTL |= SOFTRESETALL;
while( (__raw_readl( &(mmc->MMCHS_SYSCTL) ) & SOFTRESETALL) != 0x0 );
cmtDebug1( 4, 3, "...done. InitSetup Clock Config", 0 );
mmc->MMCHS_HCTL = DTW_1_BITMODE | SDBP_PWROFF | SDVS_3V0;
mmc->MMCHS_CAPA |= VS30_3V0SUP | VS18_1V8SUP;
reg_val = mmc->MMCHS_CON & RESERVED_MASK;
mmc->MMCHS_CON = CTPL_MMC_SD | reg_val | WPP_ACTIVEHIGH |
CDP_ACTIVEHIGH | MIT_CTO | DW8_1_4BITMODE | MODE_FUNC |
STR_BLOCK | HR_NOHOSTRESP | INIT_NOINIT | NOOPENDRAIN;
ClockConfig( mmc, CLK_INITSEQ, 0 );
mmc->MMCHS_HCTL |= SDBP_PWRON;
mmc->MMCHS_IE = 0x307f0033;
cmtDebug1( 4, 4, "...done.", 0 );
InitStream( mmc );
}
void main(void)
{
WD_STOP();
ClockConfig(1);
HardwareInit();
ScheduleTimerInit();
BlinkLed1();
_EINT();
LPM0;
}
void main(void)
{
WD_STOP();
ClockConfig(16);
ScheduleTimerInit();
HardwareInit();
// call ToggleLed2 and it will continue to reschedule itself forever
ToggleLed2();
_EINT();
LPM0;
}
void main(void)
{
WD_STOP();
ClockConfig(16);
ScheduleTimerInit();
HardwareInit();
// attach function to SW1 falling edge interrupt
InterruptAttach(GPIO(SW1), QueueButton, FALLING);
_EINT();
LPM0;
}
void BlinkLed1(void)
{
static int i = 0;
switch (i++)
{
case 1:
ClockConfig(1);
break;
case 10:
ClockConfig(8);
break;
case 20:
ClockConfig(12);
break;
case 30:
ClockConfig(16);
break;
case 40:
i = 0;
break;
}
LED1_TOGGLE();
CalloutRegister(BlinkLed1, 1000);
}
void main(void)
{
WD_STOP();
ClockConfig(16);
HardwareInit();
// Init the timer
ScheduleTimerInit();
// register a function and define its period
CallbackRegister(BlinkLed1, 100ul * _MILLISECOND);
// attach function to SW1 falling edge interrupt
InterruptAttach(GPIO(SW1),ToggleEnable,FALLING);
_EINT();
LPM0;
}
void main(void)
{
WD_STOP();
ClockConfig(16);
HardwareInit();
// Init the timer
ScheduleTimerInit();
// register functions and define their period
CallbackRegister(BlinkLed1, 100ul * _MILLISECOND);
CallbackRegister(BlinkLed2, 101ul * _MILLISECOND);
// callbacks are disabled by default, so enable them
CallbackMode(BlinkLed1, ENABLED);
CallbackMode(BlinkLed2, ENABLED);
_EINT();
LPM0;
}
void main(void)
{
#if !defined(MAX_UART_TX_BUF_CNT)
#error "Define MAX_UART_TX_BUF_CNT > 0 in config.h for this example"
#endif
WD_STOP();
ClockConfig(16);
HardwareInit();
// init uart at 115k
UartInit(115200);
_EINT();
printf("\n\nThis is %s\n", "a string");
printf("Hex number(16): 0x%x\n", 60);
printf("Hex number(32): 0x%lx\n", 100000);
printf("Char: %c\n", 'x');
printf("Unsigned short: %u\n", 100);
printf("Signed short: %i\n", -100);
printf("Unsigned long: %lu\n", 250000);
printf("Signed long: %li\n", -250000);
LPM0;
}
void main() {
WDTStop();
ClockConfig(); // Config System as 16MHz
P1Init();
}
CmtSdCard*
CmtSdCard::CreateCard( OMAP_MMCHS_REGS *mmc, CmtSdIsConnect isConnect ) {
#endif
uint8 MMCCmd[16];
if( isConnect() != CMTE_OK ) return 0; //Карта не подключена
bool ret_val;
bool sdCardType;
uint32 factor;
uint32 RCA = 1;
uint32 argument;
uint32 resp[4];
unsigned int trans_fact, trans_unit, retries = 2;
unsigned int max_dtr;
int dsor;
volatile mmc_csd_reg_t Card_CSD;
unsigned char trans_speed;
cmtDebug1( 10, 1, "CreateCard init setup", 0 );
InitSetup( mmc );
do {
cmtDebug1( 10, 2, "CreateCard detect card", 0 );
ret_val = DetectCard( mmc, &sdCardType, &factor, &RCA );
retries--;
}
while( (retries > 0) && !ret_val );
cmtDebug1( 10, 3, "CreateCard CMD9 RCA=%1", RCA );
argument = RCA << 16;
if( !SendCommand( mmc, MMC_CMD9, argument, resp ) ) {
cmtDebug1( 10, 3, "CreateCard CMD9 fail", 0 );
return 0;
}
memcpy( MMCCmd, resp, 16 );
((unsigned int *)&Card_CSD)[3] = resp[3];
((unsigned int *)&Card_CSD)[2] = resp[2];
((unsigned int *)&Card_CSD)[1] = resp[1];
((unsigned int *)&Card_CSD)[0] = resp[0];
// if (mmc_card_cur->card_type == MMC_CARD)
// mmc_card_cur->version = Card_CSD.spec_vers;
trans_speed = Card_CSD.tran_speed;
cmtDebug1( 10, 5, "CreateCard trans_speed %1", trans_speed );
cmtDebug1( 10, 5, "CreateCard CMD4", 0 );
if( !SendCommand( mmc, MMC_CMD4, MMC_DSR_DEFAULT << 16, resp ) ) {
cmtDebug1( 10, 6, "CreateCard CMD4 fail", 0 );
return 0;
}
#if 1
trans_unit = trans_speed & MMC_CSD_TRAN_SPEED_UNIT_MASK;
trans_fact = trans_speed & MMC_CSD_TRAN_SPEED_FACTOR_MASK;
if( trans_unit > MMC_CSD_TRAN_SPEED_UNIT_100MHZ )
return 0;
if( (trans_fact < MMC_CSD_TRAN_SPEED_FACTOR_1_0) ||
(trans_fact > MMC_CSD_TRAN_SPEED_FACTOR_8_0) )
return 0;
trans_unit >>= 0;
trans_fact >>= 3;
max_dtr = tran_exp[trans_unit] * tran_mant[trans_fact];
dsor = 96000000 / max_dtr;
if( dsor == 4 )
dsor = 5;
if( dsor == 3 )
dsor = 4;
cmtDebug1( 10, 10, "CreateCard config dsor = %1", dsor );
ClockConfig( mmc, CLK_MISC, 7 ); //dsor );
#endif
cmtDebug1( 10, 11, "CreateCard CMD7", 0 );
argument = RCA << 16;
if( !SendCommand( mmc, MMC_CMD7_SELECT, argument, resp ) ) {
cmtDebug1( 10, 12, "CreateCard CMD7 fail", 0 );
return 0;
}
/* Configure the block length to 512 bytes */
cmtDebug1( 10, 14, "CreateCard CMD16", 0 );
if( !SendCommand( mmc, MMC_CMD16, 512, resp ) ) {
cmtDebug1( 10, 15, "CreateCard CMD16 fail", 0 );
return 0;
}
//Анализ размера карты (определение количества блоков)
uint32 blockCount; //Количество блоков по 512 байт
if( factor == 0 ) { //mmc_dev_data->mode == SECTOR_MODE
if( sdCardType ) { //mmc_dev_data->card_type == SD_CARD
blockCount = (((mmc_sd2_csd_reg_t *) &Card_CSD)->c_size_lsb & MMC_SD2_CSD_C_SIZE_LSB_MASK) |
((((mmc_sd2_csd_reg_t *) &Card_CSD)->c_size_msb & MMC_SD2_CSD_C_SIZE_MSB_MASK) << MMC_SD2_CSD_C_SIZE_MSB_OFFSET);
blockCount *= 1024;
}
else {
mmc_extended_csd_reg_t ext_csd;
argument = 0x00000000;
cmtDebug1( 10, 16, "CreateCard CMD8", 0 );
if( !SendCommand( mmc, MMC_CMD8, argument, resp ) ) {
cmtDebug1( 10, 15, "CreateCard CMD8 fail", 0 );
return 0;
}
if( !GetData( mmc, (uint32*)(&ext_csd) ) ) {
cmtDebug1( 10, 16, "CreateCard CMD8 GetData fail", 0 );
return 0;
}
blockCount = ext_csd.sectorcount;
if( blockCount == 0 ) blockCount = 8388608;
}
}
else {
if( Card_CSD.c_size_mult >= 8 )
return 0;
if( Card_CSD.read_bl_len >= 12 )
return 0;
/* Compute size */
uint32 count = 1 << (Card_CSD.c_size_mult + 2);
uint32 card_size = (Card_CSD.c_size_lsb & MMC_CSD_C_SIZE_LSB_MASK) |
((Card_CSD.c_size_msb & MMC_CSD_C_SIZE_MSB_MASK) << MMC_CSD_C_SIZE_MSB_OFFSET);
uint32 blk_no = (card_size + 1) * count;
uint32 blk_len = 1 << Card_CSD.read_bl_len;
uint32 size = blk_no * blk_len;
blockCount = size >> 9;
}
cmtDebug1( 10, 21, "card blocks %1", blockCount );
cmtDebug1( 10, 22, "card factor %1", factor );
//Построить объект карты
#ifdef CMT_DMA
return new CmtSdCard( mmc, isConnect, factor, 512, blockCount, dmaRx, dmaTx );
#else
return new CmtSdCard( mmc, isConnect, factor, 512, blockCount );
#endif
}
bool
CmtSdCard::DetectCard( OMAP_MMCHS_REGS *mmc, bool *sdCardType, uint32 *factor, uint32 *RCA ) {
uint32 argument = 0;
uint32 ocr_value, ocr_recvd, ret_cmd41, hcs_val;
uint32 resp[4];
uint32 retry_cnt = 2000;
/* Set to Initialization Clock */
ClockConfig( mmc, CLK_400KHZ, 0 );
argument = 0x00000000;
ocr_value = (0x1FF << 15);
cmtDebug1( 8, 1, "DetectCard CMD0", 0 );
if( !SendCommand( mmc, MMC_CMD0, argument, resp ) ) {
cmtDebug1( 8, 2, "DetectCard CMD0 fail", 0 );
return false;
}
cmtDebug1( 8, 3, "DetectCard CMD8", 0 );
argument = SD_CMD8_CHECK_PATTERN | SD_CMD8_2_7_3_6_V_RANGE;
if( SendCommand( mmc,MMC_SDCMD8, argument, resp) ) {
cmtDebug1( 8, 4, "DetectCard CMD8 success", 0 );
*factor = 0;
hcs_val = MMC_OCR_REG_HOST_CAPACITY_SUPPORT_SECTOR;
}
else {
cmtDebug1( 8, 5, "DetectCard CMD8 fail", 0 );
*factor = 9;
hcs_val = MMC_OCR_REG_HOST_CAPACITY_SUPPORT_BYTE;
}
argument = 0x0000 << 16;
cmtDebug1( 8, 7, "DetectCard CMD55", 0 );
if( SendCommand( mmc, MMC_CMD55, argument, resp) ) {
cmtDebug1( 8, 8, "DetectCard CMD55 success (SD)", 0 );
*sdCardType = true; //mmc_card_cur->card_type = SD_CARD;
ocr_value |= hcs_val;
ret_cmd41 = MMC_ACMD41;
}
else {
cmtDebug1( 8, 9, "DetectCard CMD55 fail (MMC)", 0 );
*sdCardType = false; //mmc_card_cur->card_type = MMC_CARD;
ocr_value |= MMC_OCR_REG_ACCESS_MODE_SECTOR;
ret_cmd41 = MMC_CMD1;
mmc->MMCHS_CON &= ~OD;
mmc->MMCHS_CON |= OPENDRAIN;
}
argument = ocr_value;
cmtDebug1( 8, 11, "DetectCard cmd41 (ACMD41 for SD, CMD1 for MMC)", 0 );
if( !SendCommand( mmc, ret_cmd41, argument, resp ) ) {
cmtDebug1( 8, 12, "DetectCard cmd41 fail", 0 );
return false;
}
cmtDebug1( 8, 11, "DetectCard cmd41 success", 0 );
ocr_recvd = ((mmc_resp_r3 *) resp)->ocr;
while( !(ocr_recvd & MBIT31) && (retry_cnt > 0) ) {
retry_cnt--;
if( *sdCardType ) {
argument = 0x0000 << 16;
SendCommand( mmc, MMC_CMD55, argument, resp );
}
argument = ocr_value;
if( !SendCommand( mmc, ret_cmd41, argument, resp ) ) {
cmtDebug1( 8, 12, "DetectCard Loop cmd41 fail", 0 );
return false;
}
ocr_recvd = ((mmc_resp_r3 *) resp)->ocr;
}
if( !(ocr_recvd & MBIT31) ) {
cmtDebug1( 8, 14, "DetectCard ocr_recvd bit 31", 0 );
return false;
}
if( !*sdCardType ) { //MMC_CARD
if( (ocr_recvd & MMC_OCR_REG_ACCESS_MODE_MASK) == MMC_OCR_REG_ACCESS_MODE_SECTOR) {
*factor = 0; //mmc_card_cur->mode = SECTOR_MODE;
}
else {
*factor = 9; //mmc_card_cur->mode = BYTE_MODE;
}
ocr_recvd &= ~MMC_OCR_REG_ACCESS_MODE_MASK;
}
else {
if( (ocr_recvd & MMC_OCR_REG_HOST_CAPACITY_SUPPORT_MASK) == MMC_OCR_REG_HOST_CAPACITY_SUPPORT_SECTOR ) {
*factor = 0; //mmc_card_cur->mode = SECTOR_MODE;
}
else {
*factor = 9; //mmc_card_cur->mode = BYTE_MODE;
}
ocr_recvd &= ~MMC_OCR_REG_HOST_CAPACITY_SUPPORT_MASK;
}
ocr_recvd &= ~(0x1 << 31);
if( !(ocr_recvd & ocr_value) ) {
cmtDebug1( 8, 15, "DetectCard ocr_recvd bit ocr_value", 0 );
return false;
}
cmtDebug1( 8, 16, "DetectCard CMD2", 0 );
if( !SendCommand( mmc, MMC_CMD2, argument, resp ) ) {
cmtDebug1( 8, 17, "DetectCard CMD2 fail", 0 );
return false;
}
if( !*sdCardType ) { //mmc_card_cur->card_type == MMC_CARD
argument = *RCA << 16;
cmtDebug1( 8, 20, "DetectCard CMD3", 0 );
if( !SendCommand( mmc, MMC_CMD3, argument, resp ) ) {
cmtDebug1( 8, 21, "DetectCard CMD3 fail", 0 );
return false;
}
}
else {
argument = 0x00000000;
cmtDebug1( 8, 22, "DetectCard SDCMD3", 0 );
if( !SendCommand( mmc, MMC_SDCMD3, argument, resp ) ) {
cmtDebug1( 8, 23, "DetectCard SDCMD3 fail", 0 );
return false;
}
*RCA = ((mmc_resp_r6 *) resp)->newpublishedrca;
}
mmc->MMCHS_CON &= ~OD;
mmc->MMCHS_CON |= NOOPENDRAIN;
return true;
}
