// Константы команд SD карты
#define CMD_LENGTH         ((uint32_t) 6 )               // Размер команды
#define CARD_DATA_TOKEN      ((uint8_t) 0xFE )            // Токен начала данных
#define CARD_CMD17         ((uint8_t) 0x51 )            // Команда чтения блока
#define CARD_CMD24         ((uint8_t) 0x58 )            // Команда записи блока

// CMD0: GO_IDLE_STATE
static const uint8_t CARD_CMD0[ CMD_LENGTH ]    = { 0x40, 0x00, 0x00, 0x00, 0x00, 0x95 };
// CMD8: SEND_IF_COND
static const uint8_t CARD_CMD8[ CMD_LENGTH ]    = { 0x48, 0x00, 0x00, 0x01, 0xAA, 0x87 };
// CMD16: SET_BLOCKLEN
static const uint8_t CARD_CMD16[ CMD_LENGTH ]    = { 0x50, 0x00, 0x00, 0x02, 0x00, 0xFF };
// ACMD55: APP_CMD
static const uint8_t CARD_CMD55[ CMD_LENGTH ]    = { 0x77, 0x00, 0x00, 0x00, 0x00, 0xFF };
// CMD58: READ_OCR
static const uint8_t CARD_CMD58[ CMD_LENGTH ]    = { 0x7A, 0x00, 0x00, 0x00, 0x00, 0xFF };
// ACMD41: APP_SEND_OP_COND
static const uint8_t CARD_ACMD41[ CMD_LENGTH ]    = { 0x69, 0x40, 0x00, 0x00, 0x00, 0xFF };

// Посылаем команду и ждём окончания передачи
void Card_SendCMD(const uint8_t *Buf, uint32_t Size )
{   // Локальная переменная
   uint16_t Data;
   // Если есть данные
   while ( Size > 0 )
   {   // Первым делом формируем данные, с учётом пакинга для оптимизации
      Data = *(Buf); Buf++; Size--;
      if ( Size > 0 )
      {   // Забираем второй байт тоже
         Data += (*(Buf) * 0x100); Buf++; Size--;
      }
      // Данные сформированы, ожидаем готовности буфера передачи
      while ( (SPI1->SR & SPI_SR_TXE) == 0 ) {}
      // Передаём данные
      SPI1->DR = Data;
   }
   // Ожидаем опустошения очереди передачи
   while ( (SPI1->SR & SPI_SR_FTLVL) != 0 ) { Data = SPI1->DR; }
   // Ждём завершения последней транзакции
   while ( (SPI1->SR & SPI_SR_BSY) != 0 ) { Data = SPI1->DR; }
   // Опусташаем буфер приёма
   while ( (SPI1->SR & SPI_SR_FRLVL) != 0 ) { Data = SPI1->DR; }
}

// Посылаем байт и ждём ответ
uint8_t Card_SPI( uint8_t Data )
{   // Локальная переменная
   uint8_t Res;
   // Ожидаем готовности передатчика
   while ( (SPI1->SR & SPI_SR_FTLVL) != 0 ) { }
   // Посылаем слово
   *((__IO uint8_t *)&SPI1->DR) = Data;
   // Ожидаем готовности приёмника
   while ( (SPI1->SR & SPI_SR_RXNE) == 0 ) { }
   // Вычитываем
   Res = *((__IO uint8_t *)&SPI1->DR);
   // Выход
   return Res;
}

// Ожидаем ответ
uint8_t Card_WaitResp( uint32_t *OCR, FunctionalState R7, uint8_t Count )
{   // Локальная переменная
   uint8_t Res,Cnt;
   // Инит переменной
   *(OCR) = 0xFFFFFFFF;
   // Поиск первого байта ответа
   do
   {   // Получаем данные
      Res = Card_SPI( 0xFF );
      // И уменьшаем счётчик
      Count--;
   }
   while ( ((Res & 0xC0) != 0) && (Count > 0) );
   // Проверяем, требуется ли догрузка ещё 4х байт?
   if ( R7 == ENABLE )
   {   // Догружаем ещё 4 байт (всего 40 бит вместе с Res)
      for (Cnt = 0; Cnt < 4;Cnt++)
      {   // Готовим место под байт
         *(OCR) <<= 8; *(OCR) &= 0xFFFFFF00;
         // Получаем данные
         *(OCR) += Card_SPI( 0xFF );
      }
   }
   // Ожидаем как минимум 1 байт с 0xFF
   while ( Card_SPI( 0xFF ) != 0xFF ) { }
   // Выход
   return Res;
}

// Инициализация карты памяти
TCardType Card_Init( void )
{   // Локальные переменные
   TCardType Res;
   uint32_t Cnt,OCR;
   uint8_t Dat, Resp;
   // Отключаем карту
   CARD_OFF; Res = ctNone;
   // Настраиваем SPI на медленную скорость PCLK/128: 48/128 = 0,375МГц
   SPI1->CR1 &= ~SPI_CR1_SPE;
   SPI1->CR1 = SPI_CR1_MSTR | SPI_LOW_SPEED;
   SPI1->CR1 |= SPI_CR1_SPE;
   // Топчемся на месте
   HAL_Delay( 1 );
   // Посылаем инит 256 байт
   for (Cnt = 0;Cnt < 256;Cnt++ )
   {   // Послыаем слово
      Card_SPI( 0xFF );
   }
   // Начинаем инициализацию карты
   CARD_ON;
   // Ожидаем готовности карты
   do
   {   // Посылаем 0xFF
      Dat = Card_SPI( 0xFF );
   } while ( Dat != 0xFF );
   // CMD0: GO_IDLE_STATE
   Card_SendCMD( &CARD_CMD0[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, DISABLE, 128 );
   // Какой ответ получен?
   if ( Resp == 0x01 )
   {   // Карта вошла в IDLE_STATE, посылаем CMD8: SEND_IF_COND
      Card_SendCMD( &CARD_CMD8[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, ENABLE, 128 );
      // Если был дан адекватный респонс
      if ( Resp != 0x01 )
      {   // Это ветка SDv1/MMC
         do
         {   // Посылаем ACMD41: APP_SEND_OP_COND
            Card_SendCMD( &CARD_ACMD41[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, ENABLE, 128 );
         } while ( Resp == 0x01 );
         // Каков был ответ?
         if ( Resp == 0x00 )
         {   // Обнаружена карта SD v1
            Res = ctSD1;
         }
         else
         {   // Это ветка MMC, нам её некуда втыкать
            Res = ctUnknown;
         }
      }
      else
      {   // Это ветка SDv2
         if ( (OCR & 0x0001FF) == 0x0001AA )
         {   // Это карта SDv2
            do
            {   // Посылаем ACMD55: APP_CMD
               Card_SendCMD( &CARD_CMD55[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, DISABLE, 128 );
               // Если ответ правильный
               if ( Resp == 0x01 )
               {   // Посылаем ACMD41: APP_SEND_OP_COND
                  Card_SendCMD( &CARD_ACMD41[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, ENABLE, 128 );
               }
            } while ( Resp == 0x01 );
            // Каков был ответ?
            if ( Resp == 0x00 )
            {   // Посылаем CMD58: READ_OCR
               Card_SendCMD( &CARD_CMD58[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, ENABLE, 128 );
               // Каков ответ?
               if ( Resp == 0x00 )
               {   // Анализируем OCR
                  if ( (OCR & 0x40000000) == 0x00000000 )
                  {   // Карта обычной ёмкости
                     Res = ctSD2;
                  }
                  else
                  {   // Карта повышенной ёмкости
                     Res = ctSD3;
                  }
               }
               else
               {   // Эта карта неисправна
                  Res = ctUnknown;
               }
            }
            else
            {   // Эта карта неисправна
               Res = ctUnknown;
            }
         }
         else
         {   // Эта карта неисправна
            Res = ctUnknown;
         }
      }
   }
   else
   {   // Карта ответила неправильно
      if ( Res != 0xFF ) { Res = ctUnknown; }
   }
   // Только для карт обычной ёмкости
   if ( (Res == ctSD1) || (Res == ctSD2) )
   {   // Устанавливаем размер блока 512 байт
      // CMD16: SET_BLOCKLEN
      Card_SendCMD( &CARD_CMD16[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, DISABLE, 128 );
      // Каков ответ?
      if ( Resp != 0x00 )
      {   // Эта карта неисправна
         Res = ctUnknown;
      }
   }
   // Выключаем карту
   while ( (SPI1->SR & SPI_SR_BSY) != 0x0000 ) { }
   CARD_OFF;
   // Если карта инициализирована
   if ( (Res != ctNone) && (Res != ctUnknown) )
   {   // Настраиваем SPI на быструю скорость PCLK/2: 48/2 = 24МГц
      SPI1->CR1 &= ~SPI_CR1_SPE;
      SPI1->CR1 = SPI_CR1_MSTR;
      SPI1->CR1 |= SPI_CR1_SPE;
   }
   // Выходим
   return Res;
}

// Чтение сектора карты памяти без DMA
FunctionalState Card_Read( TCardType CardType, uint8_t *Buf, uint32_t *Loaded, uint32_t Addr )
{   // Локальные переменные
   FunctionalState Res;
   uint8_t Cmd[ 6 ];
   uint8_t Dat,Resp;
   uint32_t Cnt;
   // Инит
   Res = DISABLE;
   // Посмотрим, у нас в буфере уже загружено?
   if ( *(Loaded) != Addr )
   {   // Сохраняем новый номер сектора
      *(Loaded) = Addr;
      // Корректируем адрес для старых карт
      if ( (CardType == ctSD1) || (CardType == ctSD2) )
      {   // У старых карт адрес вместо LBA
         Addr *= 0x00000200;
      }
      // Работаем
      while ( 1 )
      {   // Если тип карты неправильный - выходим
         if ( CardType == ctNone ) { break; }
         if ( CardType == ctUnknown ) { break; }
         // Готовим команду на чтение сектора
         Cmd[ 0 ] = CARD_CMD17;
         Cmd[ 1 ] = Addr >> 24;
         Cmd[ 2 ] = Addr >> 16;
         Cmd[ 3 ] = Addr >> 8;
         Cmd[ 4 ] = Addr;
         Cmd[ 5 ] = 0xFF;
         // Включаем карту
         CARD_ON;
         // Ожидаем готовности карты
         do
         {   // Посылаем 0xFF
            Dat = Card_SPI( 0xFF );
         } while ( Dat != 0xFF );
         // Посылаем команду чтения
         Card_SendCMD( &Cmd[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( (uint32_t *)&Cmd[ 0 ], DISABLE, 128 );
         // Анализируем ответ на команду
         if ( Resp != 0x00 ) { break; }
         // Ожидаем токен данных
         Cnt = 2048;
         do
         {   // Считываем данные
            Dat = Card_SPI( 0xFF );
            // Считаем
            Cnt--;
         } while ( (Dat == 0xFF) && (Cnt > 0) );
         // Таймаут?
         if ( Cnt == 0 ) { break; }
         // Ошибка в токене?
         if ( Dat != CARD_DATA_TOKEN ) { break; }
         // Начались данные, загружаем
         for (Cnt = 0;Cnt < 512;Cnt++)
         {   // Считываем данные
            *(Buf) = Card_SPI( 0xFF ); Buf++;
         }
         // Дочитываем CRC
         Cmd[ 0 ] = Card_SPI( 0xFF );
         Cmd[ 1 ] = Card_SPI( 0xFF );
         // Без ошибок
         Res = ENABLE;
         // Выход
         break;
      }
   }
   else
   {   // Без ошибок
      Res = ENABLE;
   }
   // Выключаем карту
   while ( (SPI1->SR & SPI_SR_BSY) != 0x0000 ) { }
   CARD_OFF;
   // Если была ошибка, обнулим номер
   if ( Res == DISABLE ) { *(Loaded) = 0xFFFFFFFF; }
   // Выход
   return Res;
}

// Запись сектора карты памяти без DMA
FunctionalState Card_Write( TCardType CardType, uint8_t *Buf, uint32_t *Loaded, uint32_t Addr )
{   // Локальные переменные
   FunctionalState Res;
   uint8_t Cmd[ 6 ];
   uint8_t Dat,Resp;
   uint32_t Cnt;
   // Инит
   Res = DISABLE;
   // Корректируем адрес для старых карт
   if ( (CardType == ctSD1) || (CardType == ctSD2) )
   {   // У старых карт адрес вместо LBA
      Addr *= 0x00000200;
   }
   // Работаем
   while ( 1 )
   {   // Если тип карты неправильный - выходим
      if ( CardType == ctNone ) { break; }
      if ( CardType == ctUnknown ) { break; }
      // Готовим команду на чтение сектора
      Cmd[ 0 ] = CARD_CMD24;
      Cmd[ 1 ] = Addr >> 24;
      Cmd[ 2 ] = Addr >> 16;
      Cmd[ 3 ] = Addr >> 8;
      Cmd[ 4 ] = Addr;
      Cmd[ 5 ] = 0xFF;
      // Включаем карту
      CARD_ON;
      // Ожидаем готовности карты
      do
      {   // Посылаем 0xFF
         Dat = Card_SPI( 0xFF );
      } while ( Dat != 0xFF );
      // Посылаем команду чтения
      Card_SendCMD( &Cmd[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( (uint32_t *)&Cmd[ 0 ], DISABLE, 128 );
      // Анализируем ответ на команду
      if ( Resp != 0x00 ) { break; }
      // Посылаем токен данных
      Card_SPI( CARD_DATA_TOKEN );
      // Посылаем данные в цикле
      // Начались данные, загружаем
      for (Cnt = 0;Cnt < 512;Cnt++)
      {   // Считываем данные
         Card_SPI( *(Buf) ); Buf++;
      }
      // Досылаем CRC
      Card_SPI( 0xFF );
      Card_SPI( 0xFF );
      // Без ошибок
      Res = ENABLE;
      // Выход
      break;
   }
   // Выключаем карту
   while ( (SPI1->SR & SPI_SR_BSY) != 0x0000 ) { }
   CARD_OFF;
   // Успешно?
   if ( Res == ENABLE )
   {   // Сохраняем новый номер сектора
      *(Loaded) = Addr;
   }
   else
   {   // Обнуляем
      *(Loaded) = 0xFFFFFFFF;
   }
   // Выход
   return Res;
}