// Прочитать содержимое буфера в переменную Sector из MMC карты
// N-номер сектора
//-----------------------------------------------------------------------------
void SDReadSector(unsigned long int N)
{
char rsp,rsp1;
short int crc;
SPCR = 0x50; //0x50 fclk/4; 0x51 fclk/16; 0x52 fclk/64
SPSR = 0x00; //
//for(i=0; i<512; i++) Sector[i]=0xEE;
if(!BlockAdressMode) Adr = N*512; //Адрес начала сектора, побайтная адресация
else Adr=N; //Блочная адресация
rsp = MMC_cmd(CMD17, (unsigned int)(Adr>>16),(unsigned int)(Adr&0x0000ffff), 0xFF); //CMD17 Read a block from specify addr
if(rsp){ SD_init(); //Если rsp!=0x00 будим карту снова
rsp = MMC_cmd(CMD17, (unsigned int)(Adr>>16),(unsigned int)(Adr&0x0000ffff), 0xFF); }
if(!rsp) rsp1 = MMC_read(512); //Заполним массив Sector[]
if(!rsp1){ StringPrepare("Block read Err."); Scroll(); ScrollUpdate(); }
PORTB |= MMC_CE_PIN; //MMC-disable
//StringPrepare("CMD17 "); HexToStr(rsp, 7); Scroll();
crc = MMC_crc16(&Sector[0], 512);
if(crc1!=(unsigned char)(crc >> 8) || crc2!=(unsigned char)(crc & 0xff) ){
StringPrepare("CRC Err ");
HexToStr(crc1, 5); HexToStr(crc2, 8); Scroll();
ScrollUpdate(); }
}

unsigned char SD_readSingleBlock(unsigned long startBlock)
{
unsigned char response;
unsigned int i, retry=0;

//передаём в карту байты 0xFF до тех пор , пока карта не начнёт
//отвечать 0xFF, т.е. будет свободна
while(1)
{
if(SPI_transmit(0xFF)==0xff)
break;
}

// эта команда выполнятеся корректно - ответ 0x00
response = SD_sendCommand(READ_SINGLE_BLOCK, startBlock<<9); //read a Block command
//block address converted to starting address of 512 byte Block
if(response != 0x00) //check for SD status: 0x00 - OK (No flags set)
return response;

SD_CS_ASSERT; // CS опускаем в ноль

// а вот тут маркера так и не поступает
while(SPI_receive() != 0xfe) //wait for start block token 0xfe (0x11111110)
if(retry++ > 0xfffe){SD_CS_DEASSERT;
return 1;} //return if time-out

for(i=0; i<512; i++) //read 512 bytes
buffer[i] = SPI_receive();

SPI_receive(); //receive incoming CRC (16-bit), CRC is ignored here
SPI_receive();

SPI_receive(); //extra 8 clock pulses

SD_CS_DEASSERT;

return 0;
}

// set MMC in Idle mode
// Вызывается, подразумевая что CS установлен
static char mmcGoIdle(void)
{
unsigned char response;
unsigned long cmd58answer, cmd8answer = 0;

SDCARD_CS_HIGH();
nvram_read_byte(targetsdcard);
SDCARD_CS_LOW();

nvram_read_byte(targetsdcard);
//Send Command 0 to put MMC in SPI mode
mmcSendCmdCRC7(MMC_GO_IDLE_STATE, 0); // CMD0 - Обязательно с правильным CRC
//Now wait for READY RESPONSE
if ((response = mmcGetResponseR1()) != 0x01)
{
return MMC_INIT_ERROR;
}

nvram_read_byte(targetsdcard);

mmcSendCmdCRC7(MMC_SEND_IF_COND, 0x000001aa); // CMD8 - Обязательно с правильным CRC. 3.3 Volt VCC
response = mmcGetResponseR7(& cmd8answer);
if ((response & 0x04) != 0) // illegal command or pattern not match
{
mmcAddressMultiplier = MMC_SECTORSIZE;
mmcCardVersion2 = 0;

// if no responce
// Ver2.00 or later SD Memory Card(voltage mismatch)
// or Ver1.X SD Memory Card
// or not SD Memory Card
debug_printf_P("Ver1.X SD Memory Card or not SD Memory Card\n");

// check voltage range here
nvram_read_byte(targetsdcard);
mmcSendCmd(0x40 + 58, 0); // CMD58
response = mmcGetResponseR3(& cmd58answer);
//debug_printf_P("CMD58 has responce %02x, value = %08lx\n", response, cmd58answer);
if (response == 0x00 || response == 0x01)
{
if ((cmd58answer & (1UL << 21)) || (cmd58answer & (1UL << 20)))
{
debug_printf_P("3.3 volt VCC suitable.\n");
}
else
{
debug_printf_P("3.3 volt VCC NOT suitable.\n");
return MMC_INIT_ERROR;
}
}

for (;;)
{
nvram_read_byte(targetsdcard);
mmcSendCmd(MMC_APP_CMD, 0); // APP_CMD
//Now wait for READY RESPONSE
response = mmcGetResponseR1();
//debug_printf_P("APP_CMD responce R1 = %02x\n", response);
if (response != 0x01 && response != 0x00)
continue;

nvram_read_byte(targetsdcard);
mmcSendCmd(MMC_ACMD41, 0); // ACMD41(0)
//Now wait for READY RESPONSE
response = mmcGetResponseR1();
//debug_printf_P("ACMD41 responce R1 = %02x\n", response);
if (response == 0x00)
break;
}
//debug_printf_P("ACMD41 has responce %02x\n", response);

//return MMC_INIT_ERROR;
}
else if ((cmd8answer & 0xff) != 0xaa)
{
debug_printf_P("Bad CMD8 answer. SD CArd unuseable\n");
return MMC_INIT_ERROR;
}
else
{
mmcCardVersion2 = 1;

// Ver2.00 or later SD Memory Card
debug_printf_P("Ver2.00 or later SD Memory Card\n");

// check voltage range here
nvram_read_byte(targetsdcard);
mmcSendCmd(0x40 + 58, 0); // CMD58
response = mmcGetResponseR3(& cmd58answer);
//debug_printf_P("CMD58 has responce %02x, value = %08lx\n", response, cmd58answer);
if (response == 0x00 || response == 0x01)
{
if ((cmd58answer & (1UL << 21)) || (cmd58answer & (1UL << 20)))
{
debug_printf_P("3.3 volt VCC suitable.\n");
}
else
{
debug_printf_P("3.3 volt VCC NOT suitable.\n");
return MMC_INIT_ERROR;
}
}

nvram_read_byte(targetsdcard);
mmcSendCmd(0x40 + 59, 1); // shitch CRC check on - required before ACMD41
response = mmcGetResponseR1();
//debug_printf_P("CMD59 has responce %02x\n", response);

for (;;)
{
nvram_read_byte(targetsdcard);
mmcSendCmdCRC7(MMC_APP_CMD, 0); // APP_CMD
//Now wait for READY RESPONSE
response = mmcGetResponseR1();
//debug_printf_P("APP_CMD responce R1 = %02x\n", response);
if (response != 0x01 && response != 0x00)
continue;

nvram_read_byte(targetsdcard);

mmcSendCmdCRC7(MMC_ACMD41, 0x40000000); // HCS (High Capacity Support)
//Now wait for READY RESPONSE
response = mmcGetResponseR1();
//debug_printf_P("ACMD41 responce R1 = %02x\n", response);
if (response == 0x00)
break;
}

nvram_read_byte(targetsdcard);
mmcSendCmdCRC7(0x40 + 59, 0); // shitch CRC check off
response = mmcGetResponseR1();
//debug_printf_P("CMD59 has responce %02x\n", response);

// Check CCS bit (capacity) bit
nvram_read_byte(targetsdcard);
mmcSendCmd(0x40 + 58, 0); // CMD58
response = mmcGetResponseR3(& cmd58answer);
//debug_printf_P("CMD58 has responce %02x, value = %08lx\n", response, cmd58answer);
if ((cmd58answer & 0x40000000) != 0) //CCS (Card Capacity Status)
{
debug_printf_P("SDHC or SDXC (High Capacity)\n");
mmcAddressMultiplier = 1; // Для SDHC (адресация идёт в 512-ти байтовых блоках)
}
else
{
debug_printf_P("SDSD - up to 2GB\n");
mmcAddressMultiplier = MMC_SECTORSIZE; // Для обычных SD карт
}

}

//debug_printf_P("mmcGoIdle() done.\n");

nvram_read_byte(targetsdcard);
return (MMC_SUCCESS);
}

//function инициализация карты памяти
//return 0 - карта инициализирована
unsigned char SD_init(void)
{
unsigned char i, response, CRC1, CRC2;
unsigned char SD_version = 2; //по умолчанию версия SD = 2

int retry=0;

delay_ms(1); //задержка 1 мс, чтобы стабилизировалось напряжение

for(i=0;i<10;i++)
SPI_transmit(0xff); // 10*8 бит = 80 пустых циклов

SD_CS_ASSERT; //вывод CS опустить в ноль

do
{
//команда CMD0
response = SD_sendCommand(GO_IDLE_STATE, 0); //send 'reset & go idle' command
retry++;

if(retry>0xfe) {
return 1;
} //time out
} while(response != 0x01);

// Эти байты всегда равны 0xFF!!!!
CRC1 = SPI_transmit(0xff); //читаем первый байт CRC
CRC2 = SPI_transmit(0xff); //читаем второй байт CRC

SD_CS_DEASSERT;

retry = 0;

//команда CMD8 - приходят разные ответы
while((response = SD_sendCommand(SEND_IF_COND,0x000001AA)) != 0x01 )
{
if(retry++>0xfe)
{
SD_version = 1;
break;
}
}

retry = 0;

// а в этом цикле программа зацикливается и не выходит по команде return 1
do
{
response = SD_sendCommand(APP_CMD,0); //команда CMD55
response = SD_sendCommand(SD_SEND_OP_COND,0x40000000); //команда ACMD41

retry++;

if(retry>0xfffe)
return 1;

} while(response != 0x00);

//читаем регистр OCR, чтобы определить тип карты
retry = 0;
SDHC = 0;
if (SD_version == 2)
{
while((response = SD_sendCommand(READ_OCR,0))!=0x00)
if(retry++>0xfe) break;
}

putchar1('O');
putchar1('K');
putchar1('!');

return 0;
}