#if (defined(STM32F4XX) || defined(STM32F2XX))
  /* Wait until DMA channel enabled to be sure that all data transferred.*/

/***********************************************/  
while (sdcp->dma->stream->CR & STM32_DMA_CR_EN);
/***********************************************/

  /* DMA event flags must be manually cleared.*/
  dmaStreamClearInterrupt(sdcp->dma);

  SDIO->ICR = STM32_SDIO_ICR_ALL_FLAGS;
  SDIO->DCTRL = 0;
  osalSysUnlock();

  /* Wait until interrupt flags to be cleared.*/
  /*while (((DMA2->LISR) >> (sdcp->dma->ishift)) & STM32_DMA_ISR_TCIF)
    dmaStreamClearInterrupt(sdcp->dma);*/
#else

//Переходит сюда после успешного обнаружения и идентификации SD-карты.
//Здесь обрабатываются запросы операций от пользователей SD-сервиса
//прикладного уровня.
static FFaza FazaIdle()
{
SDact act;
u32 i, j, n;
u8 typ;
do {
ILivePing(ILIVE_SD);
act.op = act.OP_NONE;
if (!sdReq) {
IdleBegin(IDLE_READY_SD);
MboxPend(sdMbox, ms2tkt(300));
if (!Pdat(PIN_SD_INSERT)) return (FFaza)FazaIdle;
LogsCR(COL_BLACK "Card removed");
return (FFaza)FazaRestart;
}
} while (!(n = Prepare(&act)));
IdleEnd(IDLE_READY_SD);
MboxAccept(sdMbox);
while (1) {
if (act.op == act.OP_WAIT_READY) StartAct();
else if (act.op == act.OP_TRIM) {
if (cardType <= CARD_MMC) {
sdCompletes[act.user](NULL);
return (FFaza)FazaIdle;
}
#ifdef SD_ARG_CHK
SDassert(act.trim.start <= act.trim.end, REGION_SDREQ_TRIM);
#endif
StartAct();
if ((j = act.trim.start) < sdCapacity) {
j -= j % sdEraseSize;
if (cardType != CARD_SD2_BLOCK) j <<= SD_SECTOR_LEN;
if (SendCmd(CM_SET_ERASE_START, j)) FazaIdleRestart(&act);
if ((j = act.trim.end) >= sdCapacity) j = sdCapacity - 1;
j = j - j % sdEraseSize + sdEraseSize - 1;
if (cardType != CARD_SD2_BLOCK) j <<= SD_SECTOR_LEN;
if (SendCmd(CM_SET_ERASE_END, j)) FazaIdleRestart(&act);
if (SendCmd(CM_ERASE)) FazaIdleRestart(&act);
}
} else if (act.op != act.OP_NONE) break;
sdCompletes[act.user](&act.rw.buf);
SDsselOff();
OffSpi();
return (FFaza)FazaIdle;
}
#ifdef SD_ARG_CHK
SDassert(act.rw.buf && act.rw.sector < sdCapacity &&
act.rw.secOfs < SD_SECTOR_LEN, REGION_SDREQ_RW);
#endif
for (typ = 0; ; ) {
ILivePing(ILIVE_SD);
if ((uint)(act.op - act.OP_READ_1) <= act.OP_READ_N - act.OP_READ_1) {
if (sector != act.rw.sector || !sectorValid) {
while (1) {
if (!typ) if (StartAct()) break;
i = CM_READ_MULTIPLE_BLOCK;
if (n == 1 << SD_SECTOR_LEN && act.op == act.OP_READ_1)
i = CM_READ_SINGLE_BLOCK;
typ = i - CM_READ_MULTIPLE_BLOCK;
u32 jj = act.rw.sector;
if (cardType != CARD_SD2_BLOCK) jj <<= SD_SECTOR_LEN;
if (SendCmd(i, jj)) FazaIdleRestart(&act);
break;
}
if (RcvDataPacket(sh.sectorBuf, 1 << SD_SECTOR_LEN,
ms2tkt(100)) >= 0) break;
sector = act.rw.sector;
sectorValid = 1;
}
i = act.rw.secOfs;
if ((j = (1 << SD_SECTOR_LEN) - i) > n) j = n;
memcpy(act.rw.buf, &sh.sectorBuf[i], j);
if ((i = act.rw.secOfs + j) >> SD_SECTOR_LEN) {
act.rw.sector++;
i = 0;
}
act.rw.secOfs = i;
} else {
i = DataCRC(act.rw.buf, j = 1 << SD_SECTOR_LEN);
while (1) {
if (typ) WaitR1b();
else if (StartAct()) {
WaitR1b();
break;
}
typ = sectorValid = 0;
int ii = CM_WRITE_MULTIPLE_BLOCK;
if (n == 1 << SD_SECTOR_LEN && act.op == act.OP_WRITE_1) {
typ = TOKEN_DATA - TOKEN_DATA_WMB;
ii = CM_WRITE_BLOCK;
}
u32 jj = act.rw.sector;
if (cardType != CARD_SD2_BLOCK) jj <<= SD_SECTOR_LEN;
if (SendCmd(ii, jj)) FazaIdleRestart(&act);
break;
}
if (SndDataPacket(act.rw.buf, j, i, typ + TOKEN_DATA_WMB) !=
SND_PACKET_OK) break;
act.rw.sector++;
}
act.rw.buf += j;
if (n -= j) continue;
while (!(n = sdCompletes[act.user](&act.rw.buf))) {
if (!act.rw.buf) {
if (!PeripheralPowerState(concatAB(PERIPH_PCSSP, nSSP_sd)))
return (FFaza)FazaIdle;
if (!typ) {
if ((uint)(act.op - act.OP_READ_1) > 1) {
WaitR1b();
SndStopTran();
} else if (SendCmd(CM_STOP_TRANSMISSION)) FazaIdleRestart(&act);
}
#ifdef SD_SAFE_WRITE
if ((uint)(act.op - act.OP_WRITE_1) <=
act.OP_WRITE_N - act.OP_WRITE_1) {
WaitR1b();
if (SendCmd(CM_SEND_STATUS)) FazaIdleRestart(&act);
}
#endif //SD_SAFE_WRITE
SDsselOff();
OffSpi();
return (FFaza)FazaIdle;
}
if (!(AtomicSwap(&sdReq, 0) & 1 << SDREQ_START)) do {
MboxPend(sdMbox, ms2tkt(300));
ILivePing(ILIVE_SD);
} while (!sdReq);
sdReq = 1 << SDREQ_BUSY;
MboxAccept(sdMbox);
}
#ifdef SD_ARG_CHK
SDassert(act.rw.buf, REGION_SDREQ_RW);
#endif
}
FazaIdleRestart(&act);
}

union SDact {
enum {
OP_NONE, //нет операции
OP_READ_1, //выполнить чтение цепочки секторов без возможности продолжения
OP_READ_N, //выполнить чтение цепочки секторов с возможностью продолжения
OP_WRITE_1, //выполнить запись цепочки секторов без возможности продолжени
OP_WRITE_N, //выполнить запись цепочки секторов с возможностью продолжения
OP_TRIM, //выполнить стирание цепочки секторов
OP_WAIT_READY, //ожидание освобождения SD-карты (снятия сигнала BUSY)
OP_n};
enum {SD_USER_TERMINAL, SD_USER_FF, SD_USER_n};
struct { //для OP_READ_.., OP_WRITE_..
u8 *buf;
u32 sector;
u16 secOfs;
} rw;
struct { //для OP_TRIM
u32 start, end;
} trim;
struct { //для всех OP_..
u32 unuse0[2];
u16 unuse1;
u8 op, user;
};
};

  //Check if the DMA is disabled (SDIO disables the DMA after it is done with it)
  while (DMA2_Stream3->CR & DMA_SxCR_EN) {};

if (DMA2->LISR & (DMA_LISR_TCIF3 | DMA_LISR_TEIF3 | DMA_LISR_DMEIF3 | DMA_LISR_FEIF3)) {
      if (!(DMA2->LISR & DMA_LISR_TCIF3)) {//A DMA error has occured. Panic!

void DMA2_Stream3_IRQHandler (void) {
    event_dma = true;
    *(uint8_t *)&dma_isr = DMA2->LISR>>DMA_ISR_STREAM_3;
    if (_sdio->dma_isr != NULL) (*_sdio->dma_isr)(_sdio);
    DMA2->LIFCR &= (DMA_LIFCR_CTCIF3|DMA_LIFCR_CHTIF3|DMA_LIFCR_CTEIF3|DMA_LIFCR_CDMEIF3|DMA_LIF
CR_CFEIF3);
    DMA2_Stream3->CR  &= ~(DMA_SxCR_TCIE |DMA_SxCR_TEIE);
    DMA2_Stream3->FCR &= ~DMA_SxFCR_FEIE;
}

/* SDIO Interrupt Handler */
void SDIO_IRQHandler (void) {
  sdio_sta = SDIO->STA;
//  event_sdio = true;
event_sdio++;
//  if (_sdio->dma_isr != NULL) (*_sdio->sdio_isr)(_sdio);  // call back function
  SDIO->ICR = SDIO_ICR_CLEAR_ALL;
}

SDIO->ICR = SDIO_ICR_CLEAR_ALL;
__DSB();

/* SDIO Interrupt Handler */
void SDIO_IRQHandler (void) {
  sdio_sta = SDIO->STA;
  event_sdio = true;
  if (_sdio->dma_isr != NULL) (*_sdio->sdio_isr)(_sdio);
  SDIO->MASK &= ~SDIO_MASK_DATAENDIE;    // WTF???
  SDIO->ICR = SDIO_ICR_CLEAR_ALL;
}

/* DMA Interrupt Handler */
#if   defined  SDIO_DMA_STREAM3
void DMA2_Stream3_IRQHandler (void) {
//  if (DMA2_Stream3->CR & DMA_SxCR_EN) DMA2->LIFCR &= (DMA_LIFCR_CTCIF3|DMA_LIFCR_CHTIF3|DMA_LIFCR_CTEIF3|DMA_LIFCR_CDMEIF3|DMA_LIF
CR_CFEIF3);
//  else {
    event_dma = true;
    *(uint8_t *)&dma_isr = DMA2->LISR>>DMA_ISR_STREAM_3;
    if (_sdio->dma_isr != NULL) (*_sdio->dma_isr)(_sdio);
    DMA2->LIFCR &= (DMA_LIFCR_CTCIF3|DMA_LIFCR_CHTIF3|DMA_LIFCR_CTEIF3|DMA_LIFCR_CDMEIF3|DMA_LIF
CR_CFEIF3);
    DMA2_Stream3->CR  &= ~(DMA_SxCR_TCIE |DMA_SxCR_TEIE);
    DMA2_Stream3->FCR &= ~DMA_SxFCR_FEIE;
//  }
}