Ама той трешолда е един за ФИФО-то.

Тогава излиза, че в режим на приемане на данни от периферия към памет, FIFO-то е неизползваемо ако искам да ползвам TCIF за край на трансфер! Защото аз не мога всеки път да му сетвам трешолда кратен на количеството данни които очаквам.... Да кажем че имам да трансферирам 13 байта. Как ще го сетна тоя трешолд на фифото, та да се изпразни баш на последния байт?

Нещо не е така както аз го разбирам.

Аз слагам фифо без бърст и на тресхолд фул, ей ти ги двата регистъра:

Въпроса е кой ти сигнализира края на трансфера? Приемния канал или предавателния.

Ако всичко изприказвано до тук е вярно, приемния канал (RX) НЕ може да сигнализира за край на трансфера.

Може би въпроса ми е тъп, но на малките контролери FIFO няма. Там си навивах двата канала (RX и TX) с еднакъв брой байтове за трансфер, пусках си прекъсване по TCIF на приемния и пусках двата канала. Като приемния си прехвърли байтовете сигнализира и знам, че всичко е предадено/прието.

На 2-ката и 4-ката ако не пусна фифото, няма проблем да работя както по-горе. Ама ако пусна фифото, според изчетеното и изписаното излиза, че TCIF флага на приемния канал няма да се вдигне в края на трансфера в общия случай, защото част от данните си лежат във фифото. И напрактика не може да се ползва приемния канал за сигнализиране за край на трансфера при разрешено FIFO.

Нямам готова платка да го пробвам за да видя дали е така...

е що не погледнеш SPI драйвера ми... да не мислиш, че помня кви съм ги дробил

Бърз поглед - имам SPI_START_TRANSACTION() дето пуска ДМА ако е ДМА, или разрешава прекъсвания... на края винаги минава SPI_END_TRANSACTION(), което се вика от прекъсването (случая без SPI без DMA) или от DCR_SIGNAL (който се праща за сигнализиране на хендъл отворен от драйвер).

Демек за край на SPI операцията чакам DMA драйвера да ми каже че е свършил, по-точно RX-a щото са отделни...
а в ДМА-драйвера за край се счита трансфер комплийт (каквото и да значи) или грешки разни...

Ами тогава излиза, че работи някак си... въпреки, че според написаното в дейта шита не би трябвало да работи. Луда работа. Ще го проверя и ще кажа утре, че днес вече ми ПИСНА.

Две други неща, не ги бях мернал до сега, налетях им и се стреснах. Пускам ги в случай, че не си ги видял:

1. The burst configuration has to be selected in order to respect the AHB protocol, where
bursts must not cross the 1 KB address boundary because the minimum address space that
can be allocated to a single slave is 1 KB. This means that the 1 KB address boundary
should not be crossed by a burst block transfer, otherwise an AHB error would be
generated, that is not reported by the DMA registers.

Това в общия случай обезмисля използването на burst трансфери за повечето интерфейси. Драйвера ми няма как да знае, клиента къде точно си е ситуирал буферите и дали не кросват граница от 1К.

2. From performing some experiments I discovered, and ST subsequently confirmed, that the DMA stream will NOT start up if its interrupt status bits are set. This is not described in the current documentation. Even if you’re not using interrupts, you MUST clear the appropriate bits in the DMA Interrupt Flag Clear register. I don’t know which bit in particular the hardware cares about, so I just clear them all for that stream.

Това е от един блог. Преди месец колегата Fitila ми го каза това, аз не му повярвах, защото знам, че на F1 такъв филм няма. И е тъпо да има, от какъв зор да чистя прекъсванията на даден канал ако не ги ползвам? Обаче явно на F2/F4 се налага.

уж ги знам тия неща... но за 1К-то почти го бях забравил, но тъкмо почвам тестове на SDIO-то та ще го проверя. На другите дма канали по принцип не пускам глупавите бърстове. Не знам ти от какъв зор си тръгнал да ги бориш. Само си усложняваш живота, файда от тях няма. При AHB шината арбитрацията и адресацията не краде цикли и не знам що са ги сложили изобщо. Всъщност знам... IP-кода за ДМА-тата са го взели от някой друг проект с друга шина и са го преписали без да мислят.
А интеръптите аз винаги си ги чистя на всички периферии (уж)...

Принципно не съм заритал за бърстовете. На мен зора ми е във Фифото, просто искам да си изясня как работи точно. Просто както е описано, не би трябвало да работи. Или аз не го разбирам точно или това което е написано не е баш така. А не обичам да имам неща които просто работят... някак си.

Относно бърстовете - защо да нямат смисъл? AHB шината нали се арбитрира между ЦПУ-то и ДМА контролера. Бърста би трябвало да дава непрекъснатост на трансфера, който иначе не е гарантиран. На теория като бързодействие не би трябвало да е нещо съществено. Но не действа ли като защита, че процесора няма да захапе наполовина прехвърлени данни?

Значи при по-старите шини ти трябва 1 клок за да пуснеш адреса по шината и един или повече клокове за данните. Ако трансфера ти е дума по дума ти трябва по 2 клока за всяка дума. Ако е на бърст губиш един клок адресация на N думи.

При AHB пак имаш адресация и пак е един клок само че е на фона на предишния даннов трансфер. Демек самата шина може да прави трансфер на всеки клок и бърстовете не вдигат кпд-то. Освен ако не си единствен мастер, ама тя тогава шината ти е свободна така или иначе.

Освен това бърстовете при AHB-то не ти са гарантирани. Може да влезеш в бърст и контролера на шината да те изрита по всяко време. Демек ако те прекъсне някой с по-висок приоритет гориш. Файдата е, че няма да те прекъсва някой с по-нисък приоритет.
Та цялото това усложняване с бърстовете си струва само ако имаш много и то спешни данни. В случая няма как да се получи, защото перифериите не могат да натоварят кой знае колко една AHB шина дето бачка на cpu клок. Един SPI е смешен, най-много 5MB/s да изкара, а шината ти е 100 пъти повече. Проца по дефиниция е с по-нисък приоритет, така че него не го мисли.

Това последното изречение ми беше убягнало, мерси. То ми отговаря на голяма част от въпроса за бърстовете

Дано днес да остане време да си направя малко експерименти с гърчавото ФИФО. Мъгла е там.

Аз ползвам ДМА с УАРТ-а в СПИ режим. Както и ДМА за СПИ. И в двата случая ползвам РХ и ТХ ДМА-то. За край на трансфера е по РХ канала флага трансфер камплийт. Ползвам единичен бърст.


// DMA Initialization
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);

DMA_InitTypeDef DMA_InitStructure;

// Init TX
DMA_DeInit(SPIDRV_DMA_TX);
DMA_InitStructure.DMA_Channel = SPIDRV_DMA_CH;
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; // Transmit
DMA_InitStructure.DMA_Memory0BaseAddr = 0; //(uint32_t) dma_buf;
DMA_InitStructure.DMA_BufferSize = 0;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&SPIDRV_SPI->DR;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable; //DMA_FIFOMode_Enable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;

DMA_Init(SPIDRV_DMA_TX, &DMA_InitStructure);

// Init RX
DMA_DeInit(SPIDRV_DMA_RX);
DMA_InitStructure.DMA_Channel = SPIDRV_DMA_CH;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory; // Receive
DMA_InitStructure.DMA_Memory0BaseAddr = 0; //(uint32_t) dma_buf;
DMA_InitStructure.DMA_BufferSize = 0;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&SPIDRV_SPI->DR;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable; //DMA_FIFOMode_Enable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;

DMA_Init(SPIDRV_DMA_RX, &DMA_InitStructure);


static void SendBuffer(void *buf, unsigned short len)
{
//WLN_UART->DR; // CLR Recv Flag
//WLN_UART->DR; // CLR Recv Flag
DMA_ClearFlag(SPIDRV_DMA_RX, DMA_IT_TCIF0);
DMA_ClearFlag(SPIDRV_DMA_TX, DMA_IT_TCIF5);

SPIDRV_DMA_RX->CR &= ~DMA_MemoryInc_Enable;
// SPIDRV_DMA_RX->CR |= DMA_MemoryInc_Enable;
SPIDRV_DMA_RX->M0AR = (uint32_t) dma_buf; // Dummy Dest Addr
SPIDRV_DMA_RX->NDTR = len;
SPIDRV_DMA_TX->CR |= DMA_MemoryInc_Enable;
SPIDRV_DMA_TX->M0AR = (uint32_t) buf; // Source Addr
SPIDRV_DMA_TX->NDTR = len;

SPIDRV_DMA_RX->CR |= (uint32_t)DMA_SxCR_EN;
SPIDRV_DMA_TX->CR |= (uint32_t)DMA_SxCR_EN;
SPIDRV_SPI->CR2 |= (SPI_DMAReq_Rx | SPI_DMAReq_Tx);
}

static void RecvBuffer(void *buf, unsigned short len)
{
//WLN_UART->DR; // CLR Recv Flag
//WLN_UART->DR; // CLR Recv Flag
DMA_ClearFlag(SPIDRV_DMA_RX, DMA_IT_TCIF0);
DMA_ClearFlag(SPIDRV_DMA_TX, DMA_IT_TCIF5);

dma_buf[0] = 0xff;

// SPIDRV_DMA_RX->CR &= ~DMA_MemoryInc_Enable;
SPIDRV_DMA_RX->CR |= DMA_MemoryInc_Enable;
SPIDRV_DMA_RX->M0AR = (uint32_t) buf; // Dummy Dest Addr
SPIDRV_DMA_RX->NDTR = len;

SPIDRV_DMA_TX->CR &= ~DMA_MemoryInc_Enable;
//SPIDRV_DMA_TX->CR |= DMA_MemoryInc_Enable;
SPIDRV_DMA_TX->M0AR = (uint32_t) dma_buf; // Source Addr
SPIDRV_DMA_TX->NDTR = len;

SPIDRV_DMA_RX->CR |= (uint32_t)DMA_SxCR_EN;
SPIDRV_DMA_TX->CR |= (uint32_t)DMA_SxCR_EN;
SPIDRV_SPI->CR2 |= (SPI_DMAReq_Rx | SPI_DMAReq_Tx);
}

uint8_t SPIDrv_recv(uint8_t *hdr, unsigned hsiz, uint8_t *dst, unsigned size)
{
SendBuffer(hdr, hsiz); // Send Buffer
while(!DMA_GetFlagStatus(SPIDRV_DMA_RX, DMA_IT_TCIF0));
if(dst)
{
RecvBuffer(dst, size); // Send Buffer
while(!DMA_GetFlagStatus(SPIDRV_DMA_RX, DMA_IT_TCIF0));
}
return 0;
}

uint8_t SPIDrv_send(uint8_t *hdr, unsigned hsiz, uint8_t *dst, unsigned size)
{
SendBuffer(hdr, hsiz); // Send Buffer
while(!DMA_GetFlagStatus(SPIDRV_DMA_RX, DMA_IT_TCIF0));
if(dst)
{
SendBuffer(dst, size); // Send Buffer
while(!DMA_GetFlagStatus(SPIDRV_DMA_RX, DMA_IT_TCIF0));
}
return 0;
}

int SPISF_GetJEDECid(unsigned char *dst)
{ uint8_t b[1];

memset(dst, 0xcd, 4);

b[0] = 0x9f; // Get JEDECID Command

SPISF_Select(); // Open a SPI Driver & Select Device
SPIDrv_recv(b, 1, dst, 4);
SPISF_DeSelect();

return 0;
}

Vesko, предупреждавай като ще постваш код на СТ... ще ми докараш някой инфаркт

Уникални са просто... 60 байтова структура, за да укажат как са се сетнат двата регистъра на ДМА-то

Ама и ти се излагаш значи... за къф ти е да пускаш ДМА като трепеш проца с while(); Но поне си сетил да махаш инкремента като не ти трябват данните

Аз DMA-то го използвам, за да прехвърлям 8 word-a от ацп-тата към паметта(след тригер от таймер), ама си спомням, че пишеше и това за непълните трансефри и фифото:

Incomplete Burst transfer at the end of a DMA transfer may happen if one of the following
conditions occurs:
● For the AHB peripheral port configuration: the total number of data items (set in the
DMA_SxNDTR register) is not a multiple of the burst size multiplied by the data size
● For the AHB memory port configuration: the number of remaining data items in the
FIFO to be transferred to the memory is not a multiple of the burst size multiplied by the
data size

In such cases, the remaining data to be transferred will be managed in single mode by the
DMA, even if a burst transaction was requested during the DMA stream configuration.

Това основно май е от мързел. Просто го пуснах да работи и така си и остана А причината да е през ДМА и полинг, а не полинг на всеки байт е тъпата оптимизация на ГЦЦ-то. Работи уникално бавно, ако полинга е байт бу байт А целта в края е след като нишката пусне байта, да не получи управлението до като не дойде ИРКУ-то, ама кой да го напише