Ignore:
Timestamp:
Jan 30, 2025, 8:24:51 AM (3 months ago)
Author:
Zed
Message:

FatFs? is working, but without DMA.

Location:
ctrl/firmware/Main/CubeMX/FATFS
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • ctrl/firmware/Main/CubeMX/FATFS/App/fatfs.c

    r74 r75  
    3838}
    3939
     40/**
     41  * @brief  Gets Time from RTC
     42  * @param  None
     43  * @retval Time in DWORD
     44  */
     45DWORD get_fattime(void)
     46{
     47  /* USER CODE BEGIN get_fattime */
     48  return 0;
     49  /* USER CODE END get_fattime */
     50}
     51
    4052/* USER CODE BEGIN Application */
    4153

  • ctrl/firmware/Main/CubeMX/FATFS/Target/ffconf.h

    r74 r75  
    2626#include "stm32h7xx_hal.h"
    2727#include "bsp_driver_sd.h"
     28#include "cmsis_os.h" /* _FS_REENTRANT set to 1 and CMSIS API chosen */
    2829
    2930/*-----------------------------------------------------------------------------/
    … …  
    4647/   3: f_lseek() function is removed in addition to 2. */
    4748
    48 #define _USE_STRFUNC         2      /* 0:Disable or 1-2:Enable */
     49#define _USE_STRFUNC         0      /* 0:Disable or 1-2:Enable */
    4950/* This option switches string functions, f_gets(), f_putc(), f_puts() and
    5051/  f_printf().
    … …  
    127128/  ff_memfree(), must be added to the project. */
    128129
    129 #define _LFN_UNICODE    1 /* 0:ANSI/OEM or 1:Unicode */
     130#define _LFN_UNICODE    0 /* 0:ANSI/OEM or 1:Unicode */
    130131/* This option switches character encoding on the API. (0:ANSI/OEM or 1:UTF-16)
    131132/  To use Unicode string for the path name, enable LFN and set _LFN_UNICODE = 1.
    132133/  This option also affects behavior of string I/O functions. */
    133134
    134 #define _STRF_ENCODE    3
     135#define _STRF_ENCODE    0
    135136/* When _LFN_UNICODE == 1, this option selects the character encoding ON THE FILE to
    136137/  be read/written via string I/O functions, f_gets(), f_putc(), f_puts and f_printf().
    … …  
    210211/  buffer in the file system object (FATFS) is used for the file data transfer. */
    211212
    212 #define _FS_EXFAT       1
     213#define _FS_EXFAT       0
    213214/* This option switches support of exFAT file system. (0:Disable or 1:Enable)
    214215/  When enable exFAT, also LFN needs to be enabled. (_USE_LFN >= 1)
    215216/  Note that enabling exFAT discards C89 compatibility. */
    216217
    217 #define _FS_NORTC       1
     218#define _FS_NORTC       0
    218219#define _NORTC_MON      1
    219220#define _NORTC_MDAY     1
    … …  
    239240/      lock control is independent of re-entrancy. */
    240241
    241 #define _FS_REENTRANT    0  /* 0:Disable or 1:Enable */
     242#define _FS_REENTRANT    1  /* 0:Disable or 1:Enable */
     243
     244#define _USE_MUTEX       1 /* 0:Disable or 1:Enable */
    242245#define _FS_TIMEOUT      1000 /* Timeout period in unit of time ticks */
    243 #define _SYNC_t          NULL
     246#define _SYNC_t          osMutexId_t
    244247/* The option _FS_REENTRANT switches the re-entrancy (thread safe) of the FatFs
    245248/  module itself. Note that regardless of this option, file access to different
    … …  
    259262/  included somewhere in the scope of ff.h. */
    260263
    261 /* define the ff_malloc ff_free macros as standard malloc free */
     264/* define the ff_malloc ff_free macros as FreeRTOS pvPortMalloc and vPortFree macros */
    262265#if !defined(ff_malloc) && !defined(ff_free)
    263 #include <stdlib.h>
    264 #define ff_malloc  malloc
    265 #define ff_free  free
     266#define ff_malloc  pvPortMalloc
     267#define ff_free  vPortFree
    266268#endif
    267269

  • ctrl/firmware/Main/CubeMX/FATFS/Target/sd_diskio.c

    r74 r75  
    1818/* USER CODE END Header */
    1919
    20 /* Note: code generation based on sd_diskio_dma_template_bspv1.c v2.1.4
    21    as "Use dma template" is enabled. */
     20/* Note: code generation based on sd_diskio_dma_rtos_template_bspv1.c v2.1.4
     21   as FreeRTOS is enabled. */
    2222
    2323/* USER CODE BEGIN firstSection */
    … …  
    3030
    3131#include <string.h>
     32#include <stdio.h>
    3233
    3334/* Private typedef -----------------------------------------------------------*/
    3435/* Private define ------------------------------------------------------------*/
    3536
    36  /*
     37#define QUEUE_SIZE         (uint32_t) 10
     38#define READ_CPLT_MSG      (uint32_t) 1
     39#define WRITE_CPLT_MSG     (uint32_t) 2
     40/*
     41==================================================================
     42enable the defines below to send custom rtos messages
     43when an error or an abort occurs.
     44Notice: depending on the HAL/SD driver the HAL_SD_ErrorCallback()
     45may not be available.
     46See BSP_SD_ErrorCallback() and BSP_SD_AbortCallback() below
     47==================================================================
     48
     49#define RW_ERROR_MSG       (uint32_t) 3
     50#define RW_ABORT_MSG       (uint32_t) 4
     51*/
     52/*
    3753 * the following Timeout is useful to give the control back to the applications
    3854 * in case of errors in either BSP_SD_ReadCpltCallback() or BSP_SD_WriteCpltCallback()
    … …  
    6076 */
    6177/* USER CODE BEGIN enableSDDmaCacheMaintenance */
    62 #define ENABLE_SD_DMA_CACHE_MAINTENANCE  1
     78//#define ENABLE_SD_DMA_CACHE_MAINTENANCE  1
    6379/* USER CODE END enableSDDmaCacheMaintenance */
    6480
    … …  
    6985*/
    7086/* USER CODE BEGIN enableScratchBuffer */
    71 #define ENABLE_SCRATCH_BUFFER
     87//#define ENABLE_SCRATCH_BUFFER
    7288/* USER CODE END enableScratchBuffer */
    7389
    … …  
    8399static volatile DSTATUS Stat = STA_NOINIT;
    84100
    85 static volatile  UINT  WriteStatus = 0, ReadStatus = 0;
     101#if (osCMSIS <= 0x20000U)
     102static osMessageQId SDQueueID = NULL;
     103#else
     104static osMessageQueueId_t SDQueueID = NULL;
     105#endif
    86106/* Private function prototypes -----------------------------------------------*/
    87107static DSTATUS SD_CheckStatus(BYTE lun);
    … …  
    118138static int SD_CheckStatusWithTimeout(uint32_t timeout)
    119139{
    120   uint32_t timer = HAL_GetTick();
    121   /* block until SDIO IP is ready again or a timeout occur */
    122   while(HAL_GetTick() - timer < timeout)
     140  uint32_t timer;
     141  /* block until SDIO peripheral is ready again or a timeout occur */
     142#if (osCMSIS <= 0x20000U)
     143  timer = osKernelSysTick();
     144  while( osKernelSysTick() - timer < timeout)
     145#else
     146  timer = osKernelGetTickCount();
     147  while( osKernelGetTickCount() - timer < timeout)
     148#endif
    123149  {
    124150    if (BSP_SD_GetCardState() == SD_TRANSFER_OK)
    … …  
    135161  Stat = STA_NOINIT;
    136162
    137   if(BSP_SD_GetCardState() == MSD_OK)
     163  if(BSP_SD_GetCardState() == SD_TRANSFER_OK)
    138164  {
    139165    Stat &= ~STA_NOINIT;
    … …  
    150176DSTATUS SD_initialize(BYTE lun)
    151177{
    152 
     178Stat = STA_NOINIT;
     179
     180  /*
     181   * check that the kernel has been started before continuing
     182   * as the osMessage API will fail otherwise
     183   */
     184#if (osCMSIS <= 0x20000U)
     185  if(osKernelRunning())
     186#else
     187  if(osKernelGetState() == osKernelRunning)
     188#endif
     189  {
    153190#if !defined(DISABLE_SD_INIT)
    154191
    155   if(BSP_SD_Init() == MSD_OK)
    156   {
     192    if(BSP_SD_Init() == MSD_OK)
     193    {
     194      Stat = SD_CheckStatus(lun);
     195    }
     196
     197#else
    157198    Stat = SD_CheckStatus(lun);
    158   }
    159 
    160 #else
    161   Stat = SD_CheckStatus(lun);
    162 #endif
     199#endif
     200
     201    /*
     202    * if the SD is correctly initialized, create the operation queue
     203    * if not already created
     204    */
     205
     206    if (Stat != STA_NOINIT)
     207    {
     208      if (SDQueueID == NULL)
     209      {
     210 #if (osCMSIS <= 0x20000U)
     211      osMessageQDef(SD_Queue, QUEUE_SIZE, uint16_t);
     212      SDQueueID = osMessageCreate (osMessageQ(SD_Queue), NULL);
     213#else
     214      SDQueueID = osMessageQueueNew(QUEUE_SIZE, 2, NULL);
     215#endif
     216      }
     217
     218      if (SDQueueID == NULL)
     219      {
     220        Stat |= STA_NOINIT;
     221      }
     222    }
     223  }
    163224
    164225  return Stat;
    … …  
    189250DRESULT SD_read(BYTE lun, BYTE *buff, DWORD sector, UINT count)
    190251{
     252  uint8_t ret;
    191253  DRESULT res = RES_ERROR;
    192   uint32_t timeout;
    193 #if defined(ENABLE_SCRATCH_BUFFER)
    194   uint8_t ret;
     254  uint32_t timer;
     255#if (osCMSIS < 0x20000U)
     256  osEvent event;
     257#else
     258  uint16_t event;
     259  osStatus_t status;
    195260#endif
    196261#if (ENABLE_SD_DMA_CACHE_MAINTENANCE == 1)
    197262  uint32_t alignedAddr;
    198263#endif
    199 
    200264  /*
    201265  * ensure the SDCard is ready for a new operation
    … …  
    211275  {
    212276#endif
    213     if(BSP_SD_ReadBlocks_DMA((uint32_t*)buff,
    214                              (uint32_t) (sector),
    215                              count) == MSD_OK)
     277    /* Fast path cause destination buffer is correctly aligned */
     278    ret = BSP_SD_ReadBlocks_DMA((uint32_t*)buff, (uint32_t)(sector), count);
     279
     280    if (ret == MSD_OK) {
     281#if (osCMSIS < 0x20000U)
     282    /* wait for a message from the queue or a timeout */
     283    event = osMessageGet(SDQueueID, SD_TIMEOUT);
     284
     285    if (event.status == osEventMessage)
    216286    {
    217       ReadStatus = 0;
    218       /* Wait that the reading process is completed or a timeout occurs */
    219       timeout = HAL_GetTick();
    220       while((ReadStatus == 0) && ((HAL_GetTick() - timeout) < SD_TIMEOUT))
     287      if (event.value.v == READ_CPLT_MSG)
    221288      {
    222       }
    223       /* in case of a timeout return error */
    224       if (ReadStatus == 0)
    225       {
    226         res = RES_ERROR;
    227       }
    228       else
    229       {
    230         ReadStatus = 0;
    231         timeout = HAL_GetTick();
    232 
    233         while((HAL_GetTick() - timeout) < SD_TIMEOUT)
    234         {
    235           if (BSP_SD_GetCardState() == SD_TRANSFER_OK)
     289        timer = osKernelSysTick();
     290        /* block until SDIO IP is ready or a timeout occur */
     291        while(osKernelSysTick() - timer <SD_TIMEOUT)
     292#else
     293          status = osMessageQueueGet(SDQueueID, (void *)&event, NULL, SD_TIMEOUT);
     294          if ((status == osOK) && (event == READ_CPLT_MSG))
    236295          {
    237             res = RES_OK;
     296            timer = osKernelGetTickCount();
     297            /* block until SDIO IP is ready or a timeout occur */
     298            while(osKernelGetTickCount() - timer <SD_TIMEOUT)
     299#endif
     300            {
     301              if (BSP_SD_GetCardState() == SD_TRANSFER_OK)
     302              {
     303                res = RES_OK;
    238304#if (ENABLE_SD_DMA_CACHE_MAINTENANCE == 1)
    239             /*
    240             the SCB_InvalidateDCache_by_Addr() requires a 32-Byte aligned address,
    241             adjust the address and the D-Cache size to invalidate accordingly.
    242             */
    243             alignedAddr = (uint32_t)buff & ~0x1F;
    244             SCB_InvalidateDCache_by_Addr((uint32_t*)alignedAddr, count*BLOCKSIZE + ((uint32_t)buff - alignedAddr));
    245 #endif
    246             break;
     305                /*
     306                the SCB_InvalidateDCache_by_Addr() requires a 32-Byte aligned address,
     307                adjust the address and the D-Cache size to invalidate accordingly.
     308                */
     309                alignedAddr = (uint32_t)buff & ~0x1F;
     310                SCB_InvalidateDCache_by_Addr((uint32_t*)alignedAddr, count*BLOCKSIZE + ((uint32_t)buff - alignedAddr));
     311#endif
     312                break;
     313              }
     314            }
     315#if (osCMSIS < 0x20000U)
    247316          }
    248317        }
     318#else
    249319      }
    250     }
     320#endif
     321    }
     322
    251323#if defined(ENABLE_SCRATCH_BUFFER)
    252   }
     324    }
    253325    else
    254326    {
    … …  
    256328      int i;
    257329
    258       for (i = 0; i < count; i++) {
     330      for (i = 0; i < count; i++)
     331      {
    259332        ret = BSP_SD_ReadBlocks_DMA((uint32_t*)scratch, (uint32_t)sector++, 1);
    260         if (ret == MSD_OK) {
     333        if (ret == MSD_OK )
     334        {
    261335          /* wait until the read is successful or a timeout occurs */
    262 
    263           timeout = HAL_GetTick();
    264           while((ReadStatus == 0) && ((HAL_GetTick() - timeout) < SD_TIMEOUT))
     336#if (osCMSIS < 0x20000U)
     337          /* wait for a message from the queue or a timeout */
     338          event = osMessageGet(SDQueueID, SD_TIMEOUT);
     339
     340          if (event.status == osEventMessage)
    265341          {
     342            if (event.value.v == READ_CPLT_MSG)
     343            {
     344              timer = osKernelSysTick();
     345              /* block until SDIO IP is ready or a timeout occur */
     346              while(osKernelSysTick() - timer <SD_TIMEOUT)
     347#else
     348                status = osMessageQueueGet(SDQueueID, (void *)&event, NULL, SD_TIMEOUT);
     349              if ((status == osOK) && (event == READ_CPLT_MSG))
     350              {
     351                timer = osKernelGetTickCount();
     352                /* block until SDIO IP is ready or a timeout occur */
     353                ret = MSD_ERROR;
     354                while(osKernelGetTickCount() - timer < SD_TIMEOUT)
     355#endif
     356                {
     357                  ret = BSP_SD_GetCardState();
     358
     359                  if (ret == MSD_OK)
     360                  {
     361                    break;
     362                  }
     363                }
     364
     365                if (ret != MSD_OK)
     366                {
     367                  break;
     368                }
     369#if (osCMSIS < 0x20000U)
     370              }
     371            }
     372#else
    266373          }
    267           if (ReadStatus == 0)
    268           {
    269             res = RES_ERROR;
    270             break;
    271           }
    272           ReadStatus = 0;
    273 
     374#endif
    274375#if (ENABLE_SD_DMA_CACHE_MAINTENANCE == 1)
    275376          /*
    … …  
    288389      }
    289390
    290       if ((i == count) && (ret == MSD_OK))
     391      if ((i == count) && (ret == MSD_OK ))
    291392        res = RES_OK;
    292393    }
    293394#endif
    294 
    295395  return res;
    296396}
    … …  
    312412{
    313413  DRESULT res = RES_ERROR;
    314   uint32_t timeout;
     414  uint32_t timer;
     415
     416#if (osCMSIS < 0x20000U)
     417  osEvent event;
     418#else
     419  uint16_t event;
     420  osStatus_t status;
     421#endif
     422
    315423#if defined(ENABLE_SCRATCH_BUFFER)
    316   uint8_t ret;
    317   int i;
    318 #endif
    319 
    320    WriteStatus = 0;
     424  int32_t ret;
     425#endif
     426
     427  /*
     428  * ensure the SDCard is ready for a new operation
     429  */
     430
     431  if (SD_CheckStatusWithTimeout(SD_TIMEOUT) < 0)
     432  {
     433    return res;
     434  }
     435
     436#if defined(ENABLE_SCRATCH_BUFFER)
     437  if (!((uint32_t)buff & 0x3))
     438  {
     439#endif
    321440#if (ENABLE_SD_DMA_CACHE_MAINTENANCE == 1)
    322441  uint32_t alignedAddr;
    323 #endif
    324 
    325   if (SD_CheckStatusWithTimeout(SD_TIMEOUT) < 0)
    326   {
    327     return res;
    328   }
    329 
    330 #if defined(ENABLE_SCRATCH_BUFFER)
    331   if (!((uint32_t)buff & 0x3))
    332   {
    333 #endif
    334 #if (ENABLE_SD_DMA_CACHE_MAINTENANCE == 1)
    335 
    336     /*
     442  /*
    337443    the SCB_CleanDCache_by_Addr() requires a 32-Byte aligned address
    338444    adjust the address and the D-Cache size to clean accordingly.
    339     */
    340     alignedAddr = (uint32_t)buff &  ~0x1F;
    341     SCB_CleanDCache_by_Addr((uint32_t*)alignedAddr, count*BLOCKSIZE + ((uint32_t)buff - alignedAddr));
    342 #endif
    343 
    344     if(BSP_SD_WriteBlocks_DMA((uint32_t*)buff,
    345                               (uint32_t)(sector),
    346                               count) == MSD_OK)
     445  */
     446  alignedAddr = (uint32_t)buff & ~0x1F;
     447  SCB_CleanDCache_by_Addr((uint32_t*)alignedAddr, count*BLOCKSIZE + ((uint32_t)buff - alignedAddr));
     448#endif
     449
     450  if(BSP_SD_WriteBlocks_DMA((uint32_t*)buff,
     451                           (uint32_t) (sector),
     452                           count) == MSD_OK)
     453  {
     454#if (osCMSIS < 0x20000U)
     455    /* Get the message from the queue */
     456    event = osMessageGet(SDQueueID, SD_TIMEOUT);
     457
     458    if (event.status == osEventMessage)
    347459    {
    348       /* Wait that writing process is completed or a timeout occurs */
    349 
    350       timeout = HAL_GetTick();
    351       while((WriteStatus == 0) && ((HAL_GetTick() - timeout) < SD_TIMEOUT))
     460      if (event.value.v == WRITE_CPLT_MSG)
    352461      {
    353       }
    354       /* in case of a timeout return error */
    355       if (WriteStatus == 0)
    356       {
    357         res = RES_ERROR;
    358       }
    359       else
    360       {
    361         WriteStatus = 0;
    362         timeout = HAL_GetTick();
    363 
    364         while((HAL_GetTick() - timeout) < SD_TIMEOUT)
     462#else
     463    status = osMessageQueueGet(SDQueueID, (void *)&event, NULL, SD_TIMEOUT);
     464    if ((status == osOK) && (event == WRITE_CPLT_MSG))
     465    {
     466#endif
     467 #if (osCMSIS < 0x20000U)
     468        timer = osKernelSysTick();
     469        /* block until SDIO IP is ready or a timeout occur */
     470        while(osKernelSysTick() - timer  < SD_TIMEOUT)
     471#else
     472        timer = osKernelGetTickCount();
     473        /* block until SDIO IP is ready or a timeout occur */
     474        while(osKernelGetTickCount() - timer  < SD_TIMEOUT)
     475#endif
    365476        {
    366477          if (BSP_SD_GetCardState() == SD_TRANSFER_OK)
    … …  
    370481          }
    371482        }
     483#if (osCMSIS < 0x20000U)
    372484      }
    373485    }
     486#else
     487    }
     488#endif
     489  }
    374490#if defined(ENABLE_SCRATCH_BUFFER)
    375   }
    376     else
    377     {
    378       /* Slow path, fetch each sector a part and memcpy to destination buffer */
     491  else {
     492    /* Slow path, fetch each sector a part and memcpy to destination buffer */
     493    int i;
     494
    379495#if (ENABLE_SD_DMA_CACHE_MAINTENANCE == 1)
    380       /*
    381       * invalidate the scratch buffer before the next write to get the actual data instead of the cached one
    382       */
    383       SCB_InvalidateDCache_by_Addr((uint32_t*)scratch, BLOCKSIZE);
    384 #endif
    385 
     496    /*
     497     * invalidate the scratch buffer before the next write to get the actual data instead of the cached one
     498     */
     499     SCB_InvalidateDCache_by_Addr((uint32_t*)scratch, BLOCKSIZE);
     500#endif
    386501      for (i = 0; i < count; i++)
    387502      {
    388         WriteStatus = 0;
    389 
    390         memcpy((void *)scratch, (void *)buff, BLOCKSIZE);
     503        memcpy((void *)scratch, buff, BLOCKSIZE);
    391504        buff += BLOCKSIZE;
    392505
    393506        ret = BSP_SD_WriteBlocks_DMA((uint32_t*)scratch, (uint32_t)sector++, 1);
    394         if (ret == MSD_OK) {
     507        if (ret == MSD_OK )
     508        {
     509          /* wait until the read is successful or a timeout occurs */
     510#if (osCMSIS < 0x20000U)
    395511          /* wait for a message from the queue or a timeout */
    396           timeout = HAL_GetTick();
    397           while((WriteStatus == 0) && ((HAL_GetTick() - timeout) < SD_TIMEOUT))
     512          event = osMessageGet(SDQueueID, SD_TIMEOUT);
     513
     514          if (event.status == osEventMessage)
    398515          {
     516            if (event.value.v == READ_CPLT_MSG)
     517            {
     518              timer = osKernelSysTick();
     519              /* block until SDIO IP is ready or a timeout occur */
     520              while(osKernelSysTick() - timer <SD_TIMEOUT)
     521#else
     522                status = osMessageQueueGet(SDQueueID, (void *)&event, NULL, SD_TIMEOUT);
     523              if ((status == osOK) && (event == READ_CPLT_MSG))
     524              {
     525                timer = osKernelGetTickCount();
     526                /* block until SDIO IP is ready or a timeout occur */
     527                ret = MSD_ERROR;
     528                while(osKernelGetTickCount() - timer < SD_TIMEOUT)
     529#endif
     530                {
     531                  ret = BSP_SD_GetCardState();
     532
     533                  if (ret == MSD_OK)
     534                  {
     535                    break;
     536                  }
     537                }
     538
     539                if (ret != MSD_OK)
     540                {
     541                  break;
     542                }
     543#if (osCMSIS < 0x20000U)
     544              }
     545            }
     546#else
    399547          }
    400           if (WriteStatus == 0)
    401           {
    402             break;
    403           }
    404 
     548#endif
    405549        }
    406550        else
    … …  
    409553        }
    410554      }
    411       if ((i == count) && (ret == MSD_OK))
     555
     556      if ((i == count) && (ret == MSD_OK ))
    412557        res = RES_OK;
    413558    }
    414 #endif
     559
     560  }
     561#endif
     562
    415563  return res;
    416564}
    417 #endif /* _USE_WRITE == 1 */
     565 #endif /* _USE_WRITE == 1 */
    418566
    419567/* USER CODE BEGIN beforeIoctlSection */
    … …  
    486634{
    487635
    488   WriteStatus = 1;
     636  /*
     637   * No need to add an "osKernelRunning()" check here, as the SD_initialize()
     638   * is always called before any SD_Read()/SD_Write() call
     639   */
     640#if (osCMSIS < 0x20000U)
     641   osMessagePut(SDQueueID, WRITE_CPLT_MSG, 0);
     642#else
     643   const uint16_t msg = WRITE_CPLT_MSG;
     644   osMessageQueuePut(SDQueueID, (const void *)&msg, 0, 0);
     645#endif
    489646}
    490647
    … …  
    496653void BSP_SD_ReadCpltCallback(void)
    497654{
    498   ReadStatus = 1;
     655  /*
     656   * No need to add an "osKernelRunning()" check here, as the SD_initialize()
     657   * is always called before any SD_Read()/SD_Write() call
     658   */
     659#if (osCMSIS < 0x20000U)
     660   osMessagePut(SDQueueID, READ_CPLT_MSG, 0);
     661#else
     662   const uint16_t msg = READ_CPLT_MSG;
     663   osMessageQueuePut(SDQueueID, (const void *)&msg, 0, 0);
     664#endif
    499665}
    500666

  • ctrl/firmware/Main/CubeMX/FATFS/Target/sd_diskio.h

    r74 r75  
    1818/* USER CODE END Header */
    1919
    20 /* Note: code generation based on sd_diskio_dma_template.h */
     20/* Note: code generation based on sd_diskio_dma_rtos_template.h */
    2121
    2222/* Define to prevent recursive inclusion -------------------------------------*/
Note: See TracChangeset for help on using the changeset viewer.