andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Перенос кода для работы с W25Q отдельный модуль 

Исправления в SDIO
pull/3/head
Sergey 5 years ago
parent
427f6e6b60
commit
5ee88981a6
10 changed files with 396 additions and 259 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 235
      Marlin/src/HAL/STM32F1/eeprom_spi_w25q.cpp
  2. 14
      Marlin/src/HAL/STM32F1/sdio.cpp
  3. 51
      Marlin/src/HAL/STM32F1/small_spi.cpp
  4. 34
      Marlin/src/HAL/STM32F1/small_spi.h
  5. 167
      Marlin/src/HAL/STM32F1/w25q64.cpp
  6. 42
      Marlin/src/HAL/STM32F1/w25q64.h
  7. 49
      Marlin/src/libs/fatfs/diskio.cpp
  8. 39
      Marlin/src/libs/fatfs/sdio_driver.cpp
  9. 6
      Marlin/src/module/mks_wifi/debug_to_uart.cpp
  10. 18
      Marlin/src/module/mks_wifi/mks_wifi_sd.cpp

235
Marlin/src/HAL/STM32F1/eeprom_spi_w25q.cpp
View File

@ -8,140 +8,20 @@ U5 W25Q64BV, 16K SERIAL EEPROM:
#if ENABLED(SPI_EEPROM_W25Q) #if ENABLED(SPI_EEPROM_W25Q)
#include "../HAL.h" #include "w25q64.h"
#include "../../module/mks_wifi/small_cmsis.h"
#include "../../module/mks_wifi/dwt.h"
#define SPI_DIR_READ 0
#define SPI_DIR_WRITE 1
#define W25X_WriteEnable 0x06
#define W25X_WriteDisable 0x04
#define W25X_ReadStatusReg 0x05
#define W25X_WriteStatusReg 0x01
#define W25X_ReadData 0x03
#define W25X_FastReadData 0x0B
#define W25X_PageProgram 0x02
#define W25X_BlockErase 0xD8
#define W25X_SectorErase 0x20
#define W25X_ChipErase 0xC7
#define W25X_ReleasePowerDown 0xAB
#define W25X_DeviceID 0xAB
#define W25X_ManufactDeviceID 0x90
#define W25X_JedecDeviceID 0x9F
#define SPI_EEPROM_SIZE 2048
#define SPIFLASH_PAGESIZE 256
#define SPI_TIMEOUT 2000 //таймаут на ожидание опереций
#define CHECK_TIMEOUT do{if(dwt_get_timeout() == 0){ERROR("Timeout");return 0;}}while(0)
#define SPI2_START PORTB->BSRR=GPIO_BSRR_BR12
#define SPI2_STOP PORTB->BSRR=GPIO_BSRR_BS12
volatile uint8_t spi_eeprom[SPI_EEPROM_SIZE];
uint8_t spi_send(uint8_t data);
void spi_read(uint32_t addr, uint8_t *buf, uint32_t len);
void spi_write(uint32_t addr, uint8_t *buf, uint32_t len);
uint8_t spi_read_status(void);
void eeprom_hw_init(void){ void eeprom_hw_init(void){
uint32_t tmp; DEBUG("Start EEPROM");
uint8_t device_id, manuf_id; w25q_init();
uint16_t chip_id; w25q_read(SPI_EEPROM_OFFSET,(uint8_t *)spi_eeprom,SPI_EEPROM_SIZE);
/*
SPI2
MISO - PB14 Input floating / Input pull-up
MOSI - PB15 Alternate function push-pull
SCK - PB13 Alternate function push-pull
CS - PB12 Out push-pull
*/
DEBUG("Start SPI");
dwt_init();
RCC->APB2ENR |= RCC_APB2ENR_IOPBEN|RCC_APB2ENR_IOPAEN|RCC_APB2ENR_AFIOEN;
tmp = PORTB->CRH;
tmp &= ~(GPIO_CRH_MODE14|GPIO_CRH_CNF14|GPIO_CRH_CNF12|GPIO_CRH_CNF13|GPIO_CRH_CNF14|GPIO_CRH_CNF15);
tmp |= (GPIO_CRH_MODE12|GPIO_CRH_MODE13|GPIO_CRH_MODE15|GPIO_CRH_CNF13_1|GPIO_CRH_CNF15_1|GPIO_CRH_CNF14_0);
PORTB->CRH = tmp;
//CS PIN
tmp= PORTA->CRL;
tmp &= ~GPIO_CRL_CNF7;
tmp |= GPIO_CRL_MODE7;
PORTA->CRL = tmp;
PORTA->BSRR = GPIO_BSRR_BS7;
SPI2_STOP;
RCC->APB1ENR|= RCC_APB1ENR_SPI2EN;
SPI2->CR1 = SPI_CR1_SSM|\
SPI_CR1_SSI|\
(4 << SPI_CR1_BR_Pos)|\
SPI_CR1_MSTR;
SPI2->CR1 |= SPI_CR1_SPE;
//Wake up
SPI2_START;
spi_send(W25X_ReleasePowerDown);
SPI2_STOP;
for(uint32_t i=0; i<0x1000; i++){NOP;} //3us для выхода из power down
//Device ID
SPI2_START;
spi_send(W25X_DeviceID);
for(uint32_t i=0; i<3; i++){spi_send(0);}
device_id = spi_send(0);
SPI2_STOP;
//Jedec ID
SPI2_START;
spi_send(W25X_JedecDeviceID);
manuf_id = spi_send(0);
chip_id = spi_send(0) << 8;
chip_id |= spi_send(0);
DEBUG("W25Q Device ID %0X Manuf ID: %0X Chip ID %0X",device_id,manuf_id,chip_id);
SPI2_STOP;
spi_read(SPI_EEPROM_OFFSET,(uint8_t *)spi_eeprom,SPI_EEPROM_SIZE);
} }
void eeprom_hw_deinit(void){ void eeprom_hw_deinit(void){
DEBUG("Finish EEPROM");
DEBUG("Finish SPI"); w25q_write_enable();
//Write Enable w25q_sector_erase(SPI_EEPROM_OFFSET);
SPI2_START;
spi_send(W25X_WriteEnable);
SPI2_STOP;
while (spi_read_status() & 1){ //Busy
NOP;
}
//Erase 4K
SPI2_START;
spi_send(W25X_SectorErase);
spi_send((SPI_EEPROM_OFFSET >> 16) & 0xFF);
spi_send((SPI_EEPROM_OFFSET >> 8) & 0xFF);
spi_send(SPI_EEPROM_OFFSET & 0xFF);
SPI2_STOP;
while (spi_read_status() & 1){ //Busy
NOP;
}
//write //write
spi_write(SPI_EEPROM_OFFSET,(uint8_t *)spi_eeprom,SPI_EEPROM_SIZE); w25q_write(SPI_EEPROM_OFFSET,(uint8_t *)spi_eeprom,SPI_EEPROM_SIZE);
//deinit spi
} }
void eeprom_write_byte(uint8_t *pos, unsigned char value){ void eeprom_write_byte(uint8_t *pos, unsigned char value){
@ -173,103 +53,4 @@ void eeprom_update_block(const void *__src, void *__dst, size_t __n){
ERROR("Call to missing function"); ERROR("Call to missing function");
}; };
uint8_t spi_send(uint8_t data){
while((SPI2->SR & SPI_SR_TXE) == 0){NOP;};
SPI2->DR = data;
while((SPI2->SR & SPI_SR_RXNE) == 0){NOP;};
return SPI2->DR;
}
void spi_read(uint32_t addr, uint8_t *buf, uint32_t len){
if( (len == 0) || (len > SPI_EEPROM_SIZE) ){
ERROR("Len size error: %d",len);
return;
}
addr &= 0xFFFFFF; //24bit address
SPI2_START;
if(len == 1){
spi_send(W25X_ReadData);
spi_send((addr >> 16) & 0xFF);
spi_send((addr >> 8) & 0xFF);
spi_send(addr & 0xFF);
}else{
spi_send(W25X_FastReadData);
spi_send((addr >> 16) & 0xFF);
spi_send((addr >> 8) & 0xFF);
spi_send(addr & 0xFF);
spi_send(0);
}
while (len--){
*buf++ = spi_send(0);
}
SPI2_STOP;
}
void spi_write(uint32_t addr, uint8_t *buf, uint32_t len){
uint16_t bytes_in_page = SPIFLASH_PAGESIZE - (addr % SPIFLASH_PAGESIZE);
uint16_t offset = 0;
addr &= 0xFFFFFF; //24bit address
while (spi_read_status() & 1){ //Busy
NOP;
}
//Write Enable
while (len > 0){
uint16_t batch_size = (len <= bytes_in_page) ? len : bytes_in_page;
SPI2_START;
spi_send(W25X_WriteEnable);
SPI2_STOP;
while (spi_read_status() & 1){ //Busy
NOP;
}
SPI2_START;
spi_send(W25X_PageProgram);
spi_send((addr >> 16) & 0xFF);
spi_send((addr >> 8) & 0xFF);
spi_send(addr & 0xFF);
for (uint32_t i = 0; i < batch_size; i++){
spi_send(((uint8_t*)buf)[offset + i]);
}
SPI2_STOP;
//wait till it's programmed
while (spi_read_status() & 2){ //Busy
NOP;
}
addr += batch_size;
offset += batch_size;
len -= batch_size;
bytes_in_page = SPIFLASH_PAGESIZE;
}
}
uint8_t spi_read_status(void){
uint8_t data;
SPI2_START;
spi_send(W25X_ReadStatusReg);
data = spi_send(0);
SPI2_STOP;
return data;
}
#endif // SPI_EEPROM_W25Q #endif // SPI_EEPROM_W25Q

14
Marlin/src/HAL/STM32F1/sdio.cpp
View File

@ -95,7 +95,7 @@ uint32_t SDIO_ReadBlock_DMA(uint32_t blockAddress, uint8_t *data) {
dma_setup_transfer(SDIO_DMA_DEV, SDIO_DMA_CHANNEL, &SDIO->FIFO, DMA_SIZE_32BITS, data, DMA_SIZE_32BITS, DMA_MINC_MODE); dma_setup_transfer(SDIO_DMA_DEV, SDIO_DMA_CHANNEL, &SDIO->FIFO, DMA_SIZE_32BITS, data, DMA_SIZE_32BITS, DMA_MINC_MODE);
dma_set_num_transfers(SDIO_DMA_DEV, SDIO_DMA_CHANNEL, 128); dma_set_num_transfers(SDIO_DMA_DEV, SDIO_DMA_CHANNEL, 128);
dma_clear_isr_bits(SDIO_DMA_DEV, SDIO_DMA_CHANNEL); dma_clear_isr_bits(SDIO_DMA_DEV, SDIO_DMA_CHANNEL);
dma_set_priority(SDIO_DMA_DEV,SDIO_DMA_CHANNEL,DMA_PRIORITY_VERY_HIGH); //dma_set_priority(SDIO_DMA_DEV,SDIO_DMA_CHANNEL,DMA_PRIORITY_VERY_HIGH);
dma_enable(SDIO_DMA_DEV, SDIO_DMA_CHANNEL); dma_enable(SDIO_DMA_DEV, SDIO_DMA_CHANNEL);
sdio_setup_transfer(SDIO_DATA_TIMEOUT * (F_CPU / 1000U), 512, SDIO_BLOCKSIZE_512 | SDIO_DCTRL_DMAEN | SDIO_DCTRL_DTEN | SDIO_DIR_RX); sdio_setup_transfer(SDIO_DATA_TIMEOUT * (F_CPU / 1000U), 512, SDIO_BLOCKSIZE_512 | SDIO_DCTRL_DMAEN | SDIO_DCTRL_DTEN | SDIO_DIR_RX);
@ -107,8 +107,15 @@ uint32_t SDIO_ReadBlock_DMA(uint32_t blockAddress, uint8_t *data) {
} }
while (!SDIO_GET_FLAG(SDIO_STA_DATAEND | SDIO_STA_TRX_ERROR_FLAGS)) {} while (!SDIO_GET_FLAG(SDIO_STA_DATAEND | SDIO_STA_TRX_ERROR_FLAGS)) {}
while(SDIO_GET_FLAG(SDIO_STA_RXACT) || SDIO_GET_FLAG(SDIO_STA_RXDAVL)){};
if(SDIO->STA & SDIO_STA_TRX_ERROR_FLAGS){
ret_val = SDIO->STA;
dma_disable(SDIO_DMA_DEV, SDIO_DMA_CHANNEL);
return ret_val;
}
while( (DMA2_BASE->ISR & (DMA_ISR_TEIF4|DMA_ISR_TCIF4)) == 0 ){};
ret_val = SDIO->STA; ret_val = SDIO->STA;
dma_disable(SDIO_DMA_DEV, SDIO_DMA_CHANNEL); dma_disable(SDIO_DMA_DEV, SDIO_DMA_CHANNEL);
@ -116,6 +123,7 @@ uint32_t SDIO_ReadBlock_DMA(uint32_t blockAddress, uint8_t *data) {
if (SDIO->STA & SDIO_STA_RXDAVL) { if (SDIO->STA & SDIO_STA_RXDAVL) {
DEBUG("SDIO_STA_RXDAVL"); DEBUG("SDIO_STA_RXDAVL");
while (SDIO->STA & SDIO_STA_RXDAVL) (void)SDIO->FIFO; while (SDIO->STA & SDIO_STA_RXDAVL) (void)SDIO->FIFO;
ret_val = SDIO->STA;
SDIO_CLEAR_FLAG(SDIO_ICR_CMD_FLAGS | SDIO_ICR_DATA_FLAGS); SDIO_CLEAR_FLAG(SDIO_ICR_CMD_FLAGS | SDIO_ICR_DATA_FLAGS);
return ret_val; return ret_val;
} }

51
Marlin/src/HAL/STM32F1/small_spi.cpp
View File

@ -0,0 +1,51 @@
#include "small_spi.h"
#include "../../inc/MarlinConfig.h"
/*
SPI2
MISO - PB14 Input floating / Input pull-up
MOSI - PB15 Alternate function push-pull
SCK - PB13 Alternate function push-pull
W25Q CS - PB12 Out push-pull
TOUCH CS - PA7
*/
void spi2_init(uint8_t prescaler){
uint32_t tmp;
if(prescaler > SPI_FREQ_140Khz){
prescaler = SPI_FREQ_140Khz;
}
RCC->APB2ENR |= RCC_APB2ENR_IOPBEN|RCC_APB2ENR_IOPAEN|RCC_APB2ENR_AFIOEN;
tmp = PORTB->CRH;
tmp &= ~(GPIO_CRH_MODE14|GPIO_CRH_CNF14|GPIO_CRH_CNF12|GPIO_CRH_CNF13|GPIO_CRH_CNF14|GPIO_CRH_CNF15);
tmp |= (GPIO_CRH_MODE12|GPIO_CRH_MODE13|GPIO_CRH_MODE15|GPIO_CRH_CNF13_1|GPIO_CRH_CNF15_1|GPIO_CRH_CNF14_0);
PORTB->CRH = tmp;
//CS PIN
tmp= PORTA->CRL;
tmp &= ~GPIO_CRL_CNF7;
tmp |= GPIO_CRL_MODE7;
PORTA->CRL = tmp;
SPI2_STOP_ALL;
RCC->APB1ENR|= RCC_APB1ENR_SPI2EN;
SPI2->CR1 = SPI_CR1_SSM|\
SPI_CR1_SSI|\
(prescaler << SPI_CR1_BR_Pos)|\
SPI_CR1_MSTR;
SPI2->CR1 |= SPI_CR1_SPE;
}
uint8_t spi_send(uint8_t data){
while((SPI2->SR & SPI_SR_TXE) == 0){NOP;};
SPI2->DR = data;
while((SPI2->SR & SPI_SR_RXNE) == 0){NOP;};
return SPI2->DR;
}

34
Marlin/src/HAL/STM32F1/small_spi.h
View File

@ -0,0 +1,34 @@
#ifndef SMALL_SPI_H
#define SMALL_SPI_H
#include "../HAL.h"
#include "../../module/mks_wifi/small_cmsis.h"
#define SPI_FREQ_18Mhz (uint8_t)0
#define SPI_FREQ_9Mhz (uint8_t)1
#define SPI_FREQ_4_5Mhz (uint8_t)2
#define SPI_FREQ_2_25Mhz (uint8_t)3
#define SPI_FREQ_1_125Mhz (uint8_t)4
#define SPI_FREQ_560KHz (uint8_t)5
#define SPI_FREQ_280KHz (uint8_t)6
#define SPI_FREQ_140Khz (uint8_t)7
#define SPI_DIR_READ 0
#define SPI_DIR_WRITE 1
#define W25Q_START do{PORTB->BSRR=GPIO_BSRR_BR12;PORTA->BSRR=GPIO_BSRR_BS7;}while(0)
#define W25Q_STOP PORTB->BSRR=GPIO_BSRR_BS12
#define TOUCH_CS_START do{PORTB->BSRR=GPIO_BSRR_BS12;PORTA->BSRR=GPIO_BSRR_BR7;}while(0)
#define TOUCH_CS_STOP PORTA->BSRR=GPIO_BSRR_BS7
#define SPI2_STOP_ALL do{PORTB->BSRR=GPIO_BSRR_BS12;PORTA->BSRR=GPIO_BSRR_BS7;}while(0)
uint8_t spi_send(uint8_t data);
void spi_read(uint32_t addr, uint8_t *buf, uint32_t len);
void spi_write(uint32_t addr, uint8_t *buf, uint32_t len);
void spi2_init(uint8_t prescaler);
#endif

167
Marlin/src/HAL/STM32F1/w25q64.cpp
View File

@ -0,0 +1,167 @@
#include "w25q64.h"
volatile uint8_t spi_eeprom[SPI_EEPROM_SIZE];
volatile uint32_t spi_cr;
void w25q_set_spi_speed(void){
spi_cr = SPI2->CR1;
spi2_init(SPI_FREQ_18Mhz);
}
void w25q_restore_spi_speed(void){
spi2_init(SPI_FREQ_280KHz);
}
void w25q_init(void){
uint8_t device_id, manuf_id;
uint16_t chip_id;
dwt_init();
spi2_init(SPI_FREQ_4_5Mhz);
//Wake up
W25Q_START;
spi_send(W25X_ReleasePowerDown);
W25Q_STOP;
for(uint32_t i=0; i<0x1000; i++){NOP;} //3us для выхода из power down
//Device ID
W25Q_START;
spi_send(W25X_DeviceID);
for(uint32_t i=0; i<3; i++){spi_send(0);}
device_id = spi_send(0);
W25Q_STOP;
//Jedec ID
W25Q_START;
spi_send(W25X_JedecDeviceID);
manuf_id = spi_send(0);
chip_id = spi_send(0) << 8;
chip_id |= spi_send(0);
DEBUG("W25Q Device ID %0X Manuf ID: %0X Chip ID %0X",device_id,manuf_id,chip_id);
W25Q_STOP;
}
void w25q_read(uint32_t addr, uint8_t *buf, uint32_t len){
if( (len == 0) || (len > SPI_EEPROM_SIZE) ){
ERROR("Len size error: %d",len);
return;
}
addr &= 0xFFFFFF; //24bit address
W25Q_START;
if(len == 1){
spi_send(W25X_ReadData);
spi_send((addr >> 16) & 0xFF);
spi_send((addr >> 8) & 0xFF);
spi_send(addr & 0xFF);
}else{
spi_send(W25X_FastReadData);
spi_send((addr >> 16) & 0xFF);
spi_send((addr >> 8) & 0xFF);
spi_send(addr & 0xFF);
spi_send(0);
}
while (len--){
*buf++ = spi_send(0);
}
W25Q_STOP;
}
void w25q_write(uint32_t addr, uint8_t *buf, uint32_t len){
uint16_t bytes_in_page = SPIFLASH_PAGESIZE - (addr % SPIFLASH_PAGESIZE);
uint16_t offset = 0;
addr &= 0xFFFFFF; //24bit address
while (w25q_read_status() & 1){ //Busy
NOP;
}
//Write Enable
while (len > 0){
uint16_t batch_size = (len <= bytes_in_page) ? len : bytes_in_page;
W25Q_START;
spi_send(W25X_WriteEnable);
W25Q_STOP;
while (w25q_read_status() & 1){ //Busy
NOP;
}
W25Q_START;
spi_send(W25X_PageProgram);
spi_send((addr >> 16) & 0xFF);
spi_send((addr >> 8) & 0xFF);
spi_send(addr & 0xFF);
for (uint32_t i = 0; i < batch_size; i++){
spi_send(((uint8_t*)buf)[offset + i]);
}
W25Q_STOP;
//wait till it's programmed
while (w25q_read_status() & 2){ //Busy
NOP;
}
addr += batch_size;
offset += batch_size;
len -= batch_size;
bytes_in_page = SPIFLASH_PAGESIZE;
}
}
uint8_t w25q_read_status(void){
uint8_t data;
W25Q_START;
spi_send(W25X_ReadStatusReg);
data = spi_send(0);
W25Q_STOP;
return data;
}
void w25q_write_enable(void){
//Write Enable
W25Q_START;
spi_send(W25X_WriteEnable);
W25Q_STOP;
while (w25q_read_status() & 1){ //Busy
NOP;
}
}
void w25q_sector_erase(uint32_t addr){
//Erase 4K
W25Q_START;
spi_send(W25X_SectorErase);
spi_send((addr >> 16) & 0xFF);
spi_send((addr >> 8) & 0xFF);
spi_send(addr & 0xFF);
W25Q_STOP;
while (w25q_read_status() & 1){ //Busy
NOP;
}
}

42
Marlin/src/HAL/STM32F1/w25q64.h
View File

@ -0,0 +1,42 @@
#ifndef W25Q_HAL_H
#define W25Q_HAL_H
#include "../../inc/MarlinConfig.h"
#include "small_spi.h"
#include "../../module/mks_wifi/dwt.h"
#define SPI_HI_SPEED SPI_FREQ_18Mhz
#define SPI_LOW_SPEED SPI_FREQ_1_125Mhz
#define W25X_WriteEnable 0x06
#define W25X_WriteDisable 0x04
#define W25X_ReadStatusReg 0x05
#define W25X_WriteStatusReg 0x01
#define W25X_ReadData 0x03
#define W25X_FastReadData 0x0B
#define W25X_PageProgram 0x02
#define W25X_BlockErase 0xD8
#define W25X_SectorErase 0x20
#define W25X_ChipErase 0xC7
#define W25X_ReleasePowerDown 0xAB
#define W25X_DeviceID 0xAB
#define W25X_ManufactDeviceID 0x90
#define W25X_JedecDeviceID 0x9F
#define SPI_EEPROM_SIZE 1024
#define SPIFLASH_PAGESIZE 256
#define SPI_TIMEOUT 2000 //таймаут на ожидание опереций
#define CHECK_TIMEOUT do{if(dwt_get_timeout() == 0){ERROR("Timeout");return 0;}}while(0)
extern volatile uint8_t spi_eeprom[SPI_EEPROM_SIZE];
void w25q_init(void);
void w25q_read(uint32_t addr, uint8_t *buf, uint32_t len);
void w25q_write(uint32_t addr, uint8_t *buf, uint32_t len);
uint8_t w25q_read_status(void);
void w25q_write_enable(void);
void w25q_sector_erase(uint32_t addr);
void w25q_set_spi_speed(void);
void w25q_restore_spi_speed(void);
#endif

49
Marlin/src/libs/fatfs/diskio.cpp
View File

@ -10,6 +10,7 @@
#include "diskio.h" /* FatFs lower layer API */ #include "diskio.h" /* FatFs lower layer API */
volatile uint8_t __attribute__ ((aligned (4))) buf_copy[512];
/* Definitions of physical drive number for each drive */ /* Definitions of physical drive number for each drive */
#define DEV_SD 0 /* Example: Map MMC/SD card to physical drive 1 */ #define DEV_SD 0 /* Example: Map MMC/SD card to physical drive 1 */
@ -67,6 +68,24 @@ DRESULT disk_read (
uint8_t res=0; uint8_t res=0;
if(pdrv == DEV_SD){ if(pdrv == DEV_SD){
if(((uint32_t)buff % 4) != 0){
DEBUG("Buffer not aligned");
while (count--){
res=SD_transfer((uint8_t *)buf_copy, (uint32_t) sector, 1, SD2UM);
if(res != 0){
res=SD_transfer((uint8_t *)buf_copy, (uint32_t) sector, 1, SD2UM);
if(res != 0){
return RES_ERROR;
};
};
memcpy((uint8_t *)buff,(uint8_t *)buf_copy,512);
buff+=512; //uint
sector++;
}
}else{
//1st read //1st read
res=SD_transfer((uint8_t *)buff, (uint32_t) sector, count, SD2UM); res=SD_transfer((uint8_t *)buff, (uint32_t) sector, count, SD2UM);
if(res != 0){ if(res != 0){
@ -75,6 +94,7 @@ uint8_t res=0;
return RES_ERROR; return RES_ERROR;
}; };
}; };
};
return RES_OK; return RES_OK;
}; };
return RES_PARERR; return RES_PARERR;
@ -96,15 +116,38 @@ DRESULT disk_write (
uint8_t res; uint8_t res;
if(pdrv == DEV_SD){ if(pdrv == DEV_SD){
res=SD_transfer((uint8_t *)buff, (uint32_t) sector, count, UM2SD);
if(res != 0){ if(((uint32_t)buff % 4) != 0){
DEBUG("Buffer not aligned");
while (count--){
memcpy((uint8_t *)buf_copy,(uint8_t *)buff,512);
res=SD_transfer((uint8_t *)buf_copy, (uint32_t) sector, 1, UM2SD);
if(res != 0){
res=SD_transfer((uint8_t *)buf_copy, (uint32_t) sector, 1, UM2SD);
if(res != 0){
return RES_ERROR;
};
};
buff+=512;
sector++;
}
}else{
res=SD_transfer((uint8_t *)buff, (uint32_t) sector, count, UM2SD); res=SD_transfer((uint8_t *)buff, (uint32_t) sector, count, UM2SD);
if(res != 0){ if(res != 0){
return RES_ERROR; res=SD_transfer((uint8_t *)buff, (uint32_t) sector, count, UM2SD);
if(res != 0){
return RES_ERROR;
};
}; };
}; };
return RES_OK; return RES_OK;
}; };
return RES_PARERR; return RES_PARERR;
} }

39
Marlin/src/libs/fatfs/sdio_driver.cpp
View File

@ -8,9 +8,6 @@ volatile uint8_t state=0; //Для хранения состояния к
volatile uint8_t multiblock=0; //Используется в прерывании SDIO, чтоб слать команду STOP volatile uint8_t multiblock=0; //Используется в прерывании SDIO, чтоб слать команду STOP
volatile uint32_t error_flag=0; volatile uint32_t error_flag=0;
volatile uint8_t __attribute__ ((aligned (4))) buf_copy[8*1024];
void SD_check_status(SD_Status_TypeDef* SDStatus,uint32_t* reg){ void SD_check_status(SD_Status_TypeDef* SDStatus,uint32_t* reg){
SDStatus->ake_seq_error = (*reg & (1 << 3)) ? 1 : 0; SDStatus->ake_seq_error = (*reg & (1 << 3)) ? 1 : 0;
SDStatus->app_cmd = (*reg & (1 << 5)) ? 1 : 0; SDStatus->app_cmd = (*reg & (1 << 5)) ? 1 : 0;
@ -62,7 +59,6 @@ uint8_t SD_Cmd(uint8_t cmd, uint32_t arg, uint16_t response_type, uint32_t *resp
uint32_t SD_transfer(uint8_t *buf, uint32_t blk, uint32_t cnt, uint32_t dir){ uint32_t SD_transfer(uint8_t *buf, uint32_t blk, uint32_t cnt, uint32_t dir){
uint32_t trials; uint32_t trials;
uint8_t cmd=0; uint8_t cmd=0;
uint8_t *ptr = buf;
if (SDCard.Type != SDCT_SDHC) { if (SDCard.Type != SDCT_SDHC) {
blk = blk * 512; blk = blk * 512;
@ -92,22 +88,14 @@ uint32_t SD_transfer(uint8_t *buf, uint32_t blk, uint32_t cnt, uint32_t dir){
multiblock = (cnt == 1) ? 0 : 1; multiblock = (cnt == 1) ? 0 : 1;
if (dir==UM2SD){ //Запись if (dir==UM2SD){ //Запись
if(((uint32_t)buf % 4) != 0){
DEBUG("Buffer not aligned");
memcpy((uint8_t*)buf_copy,buf,cnt*512);
ptr=(uint8_t*)buf_copy;
};
DMA2_Channel4->CCR|=(0x01 << DMA_CCR_DIR_Pos); DMA2_Channel4->CCR|=(0x01 << DMA_CCR_DIR_Pos);
cmd=(cnt == 1)? SD_CMD24 : SD_CMD25; cmd=(cnt == 1)? SD_CMD24 : SD_CMD25;
} }
else if (dir==SD2UM){ //Чтение else if (dir==SD2UM){ //Чтение
cmd=(cnt == 1)? SD_CMD17 : SD_CMD18; cmd=(cnt == 1)? SD_CMD17 : SD_CMD18;
if(((uint32_t)buf % 4) != 0){
ptr=(uint8_t*)buf_copy;
};
}; };
DMA2_Channel4->CMAR=(uint32_t)ptr; //Memory address DMA2_Channel4->CMAR=(uint32_t)buf; //Memory address
DMA2_Channel4->CPAR=(uint32_t)&(SDIO->FIFO); //SDIO FIFO Address DMA2_Channel4->CPAR=(uint32_t)&(SDIO->FIFO); //SDIO FIFO Address
DMA2_Channel4->CNDTR=cnt*512/4; DMA2_Channel4->CNDTR=cnt*512/4;
@ -138,18 +126,25 @@ uint32_t SD_transfer(uint8_t *buf, uint32_t blk, uint32_t cnt, uint32_t dir){
} }
if(dir==SD2UM) { //Read if(dir==SD2UM) { //Read
while (DMA2_Channel4->CCR & DMA_CCR_EN) { while((DMA2->ISR & (DMA_ISR_TEIF4|DMA_ISR_TCIF4)) == 0 ){
if(SDIO->STA & SDIO_STA_ERRORS) { if(SDIO->STA & SDIO_STA_ERRORS) {
transmit=0;
DMA2_Channel4->CCR = 0;
DMA2->IFCR = DMA_S4_CLEAR;
return 99;
}
};
if(DMA2->ISR & DMA_ISR_TEIF4){
transmit=0; transmit=0;
return 99;
}
DMA2_Channel4->CCR = 0; DMA2_Channel4->CCR = 0;
DMA2->IFCR = DMA_S4_CLEAR; DMA2->IFCR = DMA_S4_CLEAR;
}; return 101;
}
if(((uint32_t)buf % 4) != 0){
memcpy(buf,(uint8_t*)buf_copy,cnt*512); DMA2_Channel4->CCR = 0;
} DMA2->IFCR = DMA_S4_CLEAR;
}; };

6
Marlin/src/module/mks_wifi/debug_to_uart.cpp
View File

@ -17,9 +17,9 @@ void debug_to_uart(char *fmt,...){
//SERIAL_ECHOLN((char *)&buffer); //SERIAL_ECHOLN((char *)&buffer);
while(*ptr){ while(*ptr){
while(MYSERIAL0.availableForWrite()==0){ while(MYSERIAL0.availableForWrite()==0){
safe_delay(10); safe_delay(10);
} }
MYSERIAL0.write(*ptr++); MYSERIAL0.write(*ptr++);
} }

18
Marlin/src/module/mks_wifi/mks_wifi_sd.cpp
View File

@ -19,7 +19,23 @@ volatile uint8_t *dma_buff[] = {dma_buff1,dma_buff2};
volatile uint8_t dma_buff_index=0; volatile uint8_t dma_buff_index=0;
volatile uint8_t *buff; volatile uint8_t *buff;
uint8_t __attribute__ ((aligned (4))) data[DATA_SIZE]; void mks_wifi_sd_ls(void){
FRESULT res;
DIR dir;
static FILINFO fno;
res = f_opendir(&dir, "0:"); /* Open the directory */
if (res == FR_OK) {
for (;;) {
res = f_readdir(&dir, &fno); /* Read a directory item */
if (res != FR_OK || fno.fname[0] == 0) break; /* Break on error or end of dir */
DEBUG("%s\n", fno.fname);
}
}else{
ERROR("Opendir error %d",res);
}
f_closedir(&dir);
}
void mks_wifi_sd_ls(void){ void mks_wifi_sd_ls(void){
FRESULT res; FRESULT res;

Write Preview
Loading…
Cancel
Save