#define itm_port8(n) (*((volatile uint8_t *)(0xE0000000+4*(n))))
#define itm_port16(n) (*((volatile uint16_t*)(0xE0000000+4*(n))))
#define itm_port32(n) (*((volatile uint32_t*)(0xE0000000+4*(n))))
#define DEMCR (*((volatile uint32_t*)(0xE000EDFC)))
#define TRCENA 0x01000000
//=========================================================================
#define dputchar(x) \
do \
{ \
if (DEMCR & TRCENA) \
{ \
while (itm_port32(0) == 0) \
{ \
; \
} \
\
itm_port8(0) = (x); \
} \
} \
while (0)

    // Скорость 115.2 kbps. USARTDIV=FSYS(не частота процессора а частота порта)/(16*baud) = 42e6/(16*115200) = 22,75.
    USART2->BRR=(22<<4); // Целая часть коэффициента деления USART1.
    USART2->BRR|=12; // Дробная часть*16 = 0,75*16 = 12 (окр).

    USART_Cmd( USART2, ENABLE );

#define F_SYS          42000000UL
#define BAUDRATE   115200

    // USARTDIV=FSYS(не частота процессора а частота порта)/(16*baud)
    // USART_BRR = USARTDIV * 16
    USART2->BRR = F_SYS / BAUDRATE;

    USART_Cmd( USART2, ENABLE );

  /* Determine the integer part */
  if ((USARTx->CR1 & CR1_OVER8_Set) != 0)
  {
    /* Integer part computing in case Oversampling mode is 8 Samples */
    integerdivider = ((25 * apbclock) / (2 * (USART_InitStruct->USART_BaudRate)));    
  }
  else /* if ((USARTx->CR1 & CR1_OVER8_Set) == 0) */
  {
    /* Integer part computing in case Oversampling mode is 16 Samples */
    integerdivider = ((25 * apbclock) / (4 * (USART_InitStruct->USART_BaudRate)));    
  }
  tmpreg = (integerdivider / 100) << 4;

  /* Determine the fractional part */
  fractionaldivider = integerdivider - (100 * (tmpreg >> 4));

  /* Implement the fractional part in the register */
  if ((USARTx->CR1 & CR1_OVER8_Set) != 0)
  {
    tmpreg |= ((((fractionaldivider * 8) + 50) / 100)) & ((uint8_t)0x07);
  }
  else /* if ((USARTx->CR1 & CR1_OVER8_Set) == 0) */
  {
    tmpreg |= ((((fractionaldivider * 16) + 50) / 100)) & ((uint8_t)0x0F);
  }
  
  /* Write to USART BRR */
  USARTx->BRR = (uint16_t)tmpreg;

#include "stm32f4xx.h"
#include "stm32f4xx_sdio.h"

uint32_t PowerState;
uint32_t DataCounter;

void vSDIO_Init ( void ) {
GPIO_InitTypeDef GPIO_InitStructure;
SDIO_InitTypeDef SDIO_InitStructure;

/* GPIOC and GPIOD Periph clock enable */
RCC_AHB1PeriphClockCmd( RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD, ENABLE );
/* Enable the SDIO APB2 Clock */
RCC_APB2PeriphClockCmd( RCC_APB2Periph_SDIO, ENABLE );



/* Configure PC.12 pin: CLK pin */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_25MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOC, &GPIO_InitStructure);

GPIOC->BSRRL = GPIO_Pin_12;
GPIOC->BSRRH = GPIO_Pin_12;
GPIOC->BSRRL = GPIO_Pin_12;
GPIOC->BSRRH = GPIO_Pin_12;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_Init(GPIOC, &GPIO_InitStructure);


/* Configure PD.02 CMD line */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(GPIOD, &GPIO_InitStructure);

/* Configure PC.08, PC.09, PC.10, PC.11 pins: D0, D1, D2, D3 pins */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11;
GPIO_Init(GPIOC, &GPIO_InitStructure);


GPIO_PinAFConfig(GPIOC, GPIO_PinSource8, GPIO_AF_SDIO);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource9, GPIO_AF_SDIO);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_SDIO);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_SDIO);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource12, GPIO_AF_SDIO);
GPIO_PinAFConfig(GPIOD, GPIO_PinSource2, GPIO_AF_SDIO);


RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, ENABLE);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, DISABLE);

SDIO_InitStructure.SDIO_ClockDiv = 0x00;
SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Enable;
SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;
SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;
SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;
SDIO_Init(&SDIO_InitStructure);

/*!< Set Power State to ON */
SDIO_SetPowerState(SDIO_PowerState_ON);

/*!< Enable SDIO Clock */
SDIO_ClockCmd(ENABLE);
}

int main(void)
{
vSDIO_Init();


while (1) {
PowerState = SDIO_GetPowerState();
DataCounter = SDIO_GetDataCounter();
}
}

*=============================================================================
* Supported STM32F4xx device revision | Rev A
*-----------------------------------------------------------------------------
* System Clock source | PLL (HSE)
*-----------------------------------------------------------------------------
* SYSCLK(Hz) | 168000000
*-----------------------------------------------------------------------------
* HCLK(Hz) | 168000000
*-----------------------------------------------------------------------------
* AHB Prescaler | 1
*-----------------------------------------------------------------------------
* APB1 Prescaler | 4
*-----------------------------------------------------------------------------
* APB2 Prescaler | 2
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
* PLL_N | 336
*-----------------------------------------------------------------------------
* PLL_P | 2
*-----------------------------------------------------------------------------
* PLL_Q | 7
*-----------------------------------------------------------------------------
* PLLI2S_N | 258
*-----------------------------------------------------------------------------
* PLLI2S_R | 3
*-----------------------------------------------------------------------------
* I2S input clock(Hz) | 86000000
* |
* To achieve the following I2S config: |
* - Master clock output (MCKO): ON |
* - Frame wide : 16bit |
* - Audio sampling freq (KHz) : 48 |
* - Error % : 0.0186 |
* - Prescaler Odd factor (ODD): 0 |
* - Linear prescaler (DIV) : 2 |
*-----------------------------------------------------------------------------
* VDD(V) | 3.3
*-----------------------------------------------------------------------------
* Main regulator output voltage | Scale1 mode
*-----------------------------------------------------------------------------
* Flash Latency(WS) | 5
*-----------------------------------------------------------------------------
* Prefetch Buffer | OFF
*-----------------------------------------------------------------------------
* Instruction cache | ON
*-----------------------------------------------------------------------------
* Data cache | ON
*-----------------------------------------------------------------------------
* Require 48MHz for USB OTG FS, | Enabled
* SDIO and RNG clock |
*-----------------------------------------------------------------------------
*=============================================================================

#include "stm32_eval_sdio_sd.h"
/**************************/
/*-----------------------------------------------------------------------*/
/* Read Sector(s) */
DRESULT disk_read (
BYTE drv, /* Physical drive nmuber (0..) */
BYTE *buff, /* Data buffer to store read data */
DWORD sector, /* Sector address (LBA) */
BYTE count /* Number of sectors to read (1..255) */
)
{
switch (drv)
{
case SDIO_DRIVE:
{
Status = SD_OK;

#if defined SD_DMA_MODE /* DMA Transfer */
/* Read Multiple Blocks */
Status = SD_ReadMultiBlocks((uint8_t*)(buff),(sector)*SECTOR_SIZE,SECTOR_SIZE,count);

/* Check if the Transfer is finished */
Status = SD_WaitReadOperation();

/* Wait until end of DMA transfer */
while(SD_GetStatus() != SD_TRANSFER_OK);
#else /* Polling Transfer */
for (int secNum = 0; (secNum < count) && (Status == SD_OK); secNum++)
{
Status = SD_ReadBlock((buff+SECTOR_SIZE*secNum),
(sector+secNum)*SECTOR_SIZE,
SECTOR_SIZE);

while(SD_GetStatus() != SD_TRANSFER_OK);
}
#endif

if (Status == SD_OK) return RES_OK;
else return RES_ERROR;
}

}
return RES_PARERR;
}

#ifdef SD_DMA_MODE
//или
#if defined(SD_DMA_MODE)

#if defined SD_DMA_MODE

//*********************Конфигурация SPI в мастер - режиме**********************************************
  
// SPI1->CR1 |= SPI_CR1_BR_0;        // Частота передачи Fclck/4
  SPI1->CR1 |= SPI_CR1_DFF;            // Размер кадра - 16 бит
  SPI1->CR1 |= SPI_CR1_MSTR;        // Установка мастер - режим
  SPI1->CR1 |= SPI_CR1_BIDIMODE;    // Тип коммуникации в 1 направлении                                    
  SPI1->CR1 |= SPI_CR1_BIDIOE;        // Только передача
  SPI1->CR1 |= SPI_CR1_SSI;            //    без этого
  SPI1->CR1 |= SPI_CR1_SSM;            //    и этого в мастер режимме не работает

  SPI1->CR1 |= SPI_CR1_SPE;          // Включение SPI


// Запись команды в дисплей
void Lcd_Write_Command(short Cmd){
  
  GPIOA->BSRR |= RS;                    //RS установлить в 1 (команда)
  GPIOA->BRR |= CS;                       //CS установить в 0 (активный дисплей)
  SPI1->DR = Cmd;                       // ПОСЛЕ ЗАПИСИ В SPI1->DR БИТ TXE НЕ СБРАСЫВАЕТСЯ
  while(!((SPI1->SR)&SPI_SR_TXE));       // ПОЭТОМУ ИДЕТ СРАЗУ ЖЕ ЗАПИСЬ СЛЕДУЮЩЕГО БИТА.
  GPIOA->BSRR |= CS;                     //CS установить в 1 (неактивный дисплей)
}

// Запись команды в дисплей
void Lcd_Write_Command(short Cmd){
  int nCount =  15;
  GPIOA->BSRR |= RS;                    //RS установлить в 1 (команда)
  GPIOA->BRR |= CS;                       //CS установить в 0 (активный дисплей)
  SPI1->DR = Cmd;                
  while(!((SPI1->SR)&SPI_SR_TXE));
  
  for (; nCount != 0; nCount--);
  GPIOA->BSRR |= CS;                     //CS установить в 1 (неактивный дисплей)
}

RCC->APB2ENR= .....

//**************************** Настройка POTA **********************************************************
  RCC->APB2ENR|= RCC_APB2ENR_IOPAEN; // Разрешить тактирование порта A.
//  RCC->APB2ENR|= RCC_APB2ENR_AFIOEN; // Тактирование альтернативных функций GPIO.
  RCC->APB2ENR|= RCC_APB2ENR_SPI1EN; // Включение тактирования SPI1.
  GPIOA->CRL |= GPIO_CRL_MODE2;         // Output MODE 50 MHz
  GPIOA->CRL &=~GPIO_CRL_CNF2;          // Вывод  PA.2 - на выход (RST).
  GPIOA->CRL |= GPIO_CRL_MODE3;         // Output MODE 50 MHz
  GPIOA->CRL &=~GPIO_CRL_CNF3;          // Вывод  PA.3 - на выход (RS).
  GPIOA->CRL |= GPIO_CRL_MODE4;         // Output MODE 50 MHz
  GPIOA->CRL &=~GPIO_CRL_CNF4;          // Вывод  PA.4 - на выход (NSS).
  GPIOA->CRL |= GPIO_CRL_MODE5;        // Output MODE 50 MHz
  GPIOA->CRL &=~GPIO_CRL_CNF5;
  GPIOA->CRL |= GPIO_CRL_CNF5_1;     // Вывод  PA.5 на выход как альтернативная функция (SCK).
  GPIOA->CRL |= GPIO_CRL_MODE6;        // Output MODE 50 MHz
  GPIOA->CRL &=~GPIO_CRL_CNF6;
  GPIOA->CRL |= GPIO_CRL_CNF6_1;     // Вывод  PA.5 на выход как альтернативная функция (SCK).
  GPIOA->CRL |= GPIO_CRL_MODE7;        // Output MODE 50 MHz
  GPIOA->CRL &=~GPIO_CRL_CNF7;
  GPIOA->CRL |= GPIO_CRL_CNF7_1;     // Вывод  PA.7 на выход как альтернативная функция (MOSI)

u8  spi_process_8(u8 data)
{
  SPI1->DR = data;
  while ( (SPI1->SR & SPI_I2S_FLAG_RXNE) == (uint16_t)RESET );

  return SPI1->DR;
}