开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
fat_out.c
资源名称：STM32-uCOS-II_UAV.rar　[点击查看]
上传用户：yj_qqy
上传日期：2017-01-28
资源大小：2911k
文件大小：17k
源码类别：

uCOS

开发平台：

C/C++

fat_out.c：源码内容
  1. /*
  2. **********************************************************************
  3. *                          Micrium, Inc.
  4. *                      949 Crestview Circle
  5. *                     Weston,  FL 33327-1848
  6. *
  7. *                            uC/FS
  8. *
  9. *             (c) Copyright 2001 - 2003, Micrium, Inc.
  10. *                      All rights reserved.
  11. *
  12. ***********************************************************************
  14. ----------------------------------------------------------------------
  15. File        : fat_out.c
  16. Purpose     : FAT12/FAT16/FAT32 Filesystem file write routines
  17. ----------------------------------------------------------------------
  18. Known problems or limitations with current version
  19. ----------------------------------------------------------------------
  20. None.
  21. ---------------------------END-OF-HEADER------------------------------
  22. */
  24. /*********************************************************************
  25. *
  26. *             #include Section
  27. *
  28. **********************************************************************
  29. */
  31. #include "fs_conf.h"
  32. #include "fs_port.h"
  33. #ifndef FS_FARCHARPTR
  34.   #define FS_FARCHARPTR char *
  35. #endif
  36. #ifndef FS_FAT_FWRITE_UPDATE_DIR
  37.   #define FS_FAT_FWRITE_UPDATE_DIR 1
  38. #endif
  39. #include "fs_dev.h"
  40. #include "fs_api.h"
  41. #include "fs_fsl.h"
  42. #include "fs_int.h"
  43. #include "fs_os.h"
  44. #include "fs_lbl.h"
  45. #include "fs_fat.h"
  46. #include "fs_clib.h"
  49. /*********************************************************************
  50. *
  51. *             Local functions
  52. *
  53. **********************************************************************
  54. */
  56. /*********************************************************************
  57. *
  58. *             _FS_fat_write_dentry
  59. *
  60.   Description:
  61.   FS internal function. Write a directory entry.
  63.   Parameters:
  64.   Idx         - Index of device in the device information table 
  65.                 referred by FS__pDevInfo.
  66.   Unit        - Unit number.
  67.   FirstClust  - First cluster of the file, which's directory entry 
  68.                 will be written.
  69.   pDirEntry   - Pointer to an FS__fat_dentry_type structure, which 
  70.                 contains the new directory entry.
  71.   DirSec      - Sector, which contains the directory entry.
  72.   pBuffer     - Pointer to a buffer, which contains the sector with 
  73.                 the old directory entry.
  74.  
  75.   Return value:
  76.   ==1         - Directory entry has been written.
  77.   ==0         - An error has occured.
  78. */
  80. static int _FS_fat_write_dentry(int Idx, FS_u32 Unit, FS_u32 FirstClust, FS__fat_dentry_type *pDirEntry, 
  81.                                 FS_u32 DirSec, char *pBuffer) {
  82.   FS__fat_dentry_type *s;
  83.   FS_u32 value;
  84.   int err;
  86.   if (DirSec == 0) {
  87.     return 0;  /* Not a valid directory sector */
  88.   }
  89.   if (pBuffer == 0) {
  90.     return 0;  /* No buffer */
  91.   }
  92.   /* Scan for the directory entry with FirstClust in the directory sector */
  93.   s = (FS__fat_dentry_type*)pBuffer;
  94.   while (1) {
  95.     if (s >= (FS__fat_dentry_type*)(pBuffer + FS_FAT_SEC_SIZE)) {
  96.       break;  /* End of sector reached */
  97.     }
  98.     value = (FS_u32)s->data[26] + 0x100UL * s->data[27] + 0x10000UL * s->data[20] + 0x1000000UL * s->data[21];
  99.     if (value == FirstClust) {
  100.       break;  /* Entry found */
  101.     }
  102.     s++;
  103.   }
  104.   if (s < (FS__fat_dentry_type*)(pBuffer + FS_FAT_SEC_SIZE)) {
  105.     if (pDirEntry) {
  106.       FS__CLIB_memcpy(s, pDirEntry, sizeof(FS__fat_dentry_type));
  107.       err = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, DirSec, (void*)pBuffer);
  108.       if (err < 0) {
  109.         return 0;
  110.       }
  111.     }
  112.     return 1;
  113.   }
  114.   return 0;
  115. }
  118. /*********************************************************************
  119. *
  120. *             _FS_fat_read_dentry
  121. *
  122.   Description:
  123.   FS internal function. Read a directory entry.
  125.   Parameters:
  126.   Idx         - Index of device in the device information table 
  127.                 referred by FS__pDevInfo.
  128.   Unit        - Unit number.
  129.   FirstClust  - First cluster of the file, which's directory entry 
  130.                 will be read.
  131.   DirStart    - Start of directory, where to read the entry.
  132.   pDirEntry   - Pointer to an FS__fat_dentry_type structure, which is 
  133.                 used to read the directory entry.
  134.   pDirSec     - Pointer to an FS_u32, which is used to store the sector
  135.                 number, in which the directory entry has been read.
  136.   pBuffer     - Pointer to a buffer, which is used for reading the
  137.                 directory.
  138.  
  139.   Return value:
  140.   ==1         - Directory entry has been read.
  141.   ==0         - An error has occured.
  142. */
  144. static int _FS_fat_read_dentry(int Idx, FS_u32 Unit, FS_u32 FirstClust, 
  145.                               FS_u32 DirStart, FS__fat_dentry_type *pDirEntry, FS_u32 *pDirSec, char *pBuffer) {
  146.   FS_u32 i;
  147.   FS_u32 dsize;
  148.   FS_u32 value;
  149.   FS__fat_dentry_type *s;
  150.   int err;
  152.   if (pBuffer == 0) {
  153.     return 0;
  154.   }
  155.   dsize  =  FS__fat_dir_size(Idx, Unit, DirStart);
  156.   /* Read the directory */
  157.   for (i = 0; i < dsize; i++) {
  158.     *pDirSec = FS__fat_dir_realsec(Idx, Unit, DirStart, i);
  159.     if (*pDirSec == 0) {
  160.       return 0;  /* Unable to translate relative directory sector to absolute setor */
  161.     }
  162.     err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, *pDirSec, (void*)pBuffer);
  163.     if (err < 0) {
  164.       return 0;
  165.     }
  166.     /* Scan for entry with FirstClus in the sector */
  167.     s = (FS__fat_dentry_type*)pBuffer;
  168.     while (1) {
  169.       if (s >= (FS__fat_dentry_type*)(pBuffer + FS_FAT_SEC_SIZE)) {
  170.         break;  /* End of sector reached */
  171.       }
  172.       value = (FS_u32)s->data[26] + 0x100UL * s->data[27] + 0x10000UL * s->data[20] + 0x1000000UL * s->data[21];
  173.       if (value == FirstClust) {
  174.         break;  /* Entry found */
  175.       }
  176.       s++;
  177.     }
  178.     if (s < (FS__fat_dentry_type*)(pBuffer + FS_FAT_SEC_SIZE)) {
  179.       if (pDirEntry) {
  180.         /* Read the complete directory entry from the buffer */
  181.         FS__CLIB_memcpy(pDirEntry, s, sizeof(FS__fat_dentry_type));
  182.       }
  183.       return 1;
  184.     }
  185.   }
  186.   return 0;
  187. }
  190. /*********************************************************************
  191. *
  192. *             Global functions
  193. *
  194. **********************************************************************
  195. */
  197. /*********************************************************************
  198. *
  199. *             FS__fat_fwrite
  200. *
  201.   Description:
  202.   FS internal function. Write data to a file.
  204.   Parameters:
  205.   pData       - Pointer to data, which will be written to the file. 
  206.   Size        - Size of an element to be transferred to a file.
  207.   N           - Number of elements to be transferred to the file.
  208.   pFile       - Pointer to a FS_FILE data structure.
  209.   
  210.   Return value:
  211.   Number of elements written.
  212. */
  214. FS_size_t FS__fat_fwrite(const void *pData, FS_size_t Size, FS_size_t N, FS_FILE *pFile) {
  215.   FS_size_t todo;
  216.   FS_u32 dstart;
  217.   FS_u32 dsize;
  218.   FS_u32 bytesperclus;
  219.   FS_u32 datastart;
  220.   FS_u32 fatsize;
  221.   FS_u32 fileclustnum;
  222.   FS_u32 diskclustnum;
  223.   FS_u32 prevclust;
  224.   FS_i32 last;
  225.   FS_i32 i;
  226.   FS_i32 j;
  227. #if (FS_FAT_FWRITE_UPDATE_DIR)
  228.   FS__fat_dentry_type s;
  229.   FS_u32 dsec = 0;
  230.   FS_u16 val;
  231. #endif /* FS_FAT_FWRITE_UPDATE_DIR */
  232.   int err;
  233.   int lexp;
  234.   char *buffer;
  236.   if (!pFile) {
  237.       return 0;
  238.   }
  239.   /* Check if media is OK */
  240.   err = FS__lb_status(FS__pDevInfo[pFile->dev_index].devdriver, pFile->fileid_lo);
  241.   if (err == FS_LBL_MEDIACHANGED) {
  242.     pFile->error = FS_ERR_DISKCHANGED;
  243.     return 0;
  244.   }
  245.   else if (err < 0) {
  246.     pFile->error = FS_ERR_WRITEERROR;
  247.     return 0;
  248.   }
  249.   buffer = FS__fat_malloc(FS_FAT_SEC_SIZE);
  250.   if (!buffer) {
  251.     return 0;
  252.   }
  253.   fatsize = FS__FAT_aBPBUnit[pFile->dev_index][pFile->fileid_lo].FATSz16;
  254.   if (fatsize == 0) {
  255.     /* FAT32 */
  256.     fatsize = FS__FAT_aBPBUnit[pFile->dev_index][pFile->fileid_lo].FATSz32;
  257.   }
  258.   todo = N * Size;  /* Number of bytes to be written */
  259.   if (!todo) {
  260.     FS__fat_free(buffer);
  261.     return 0;
  262.   }
  263.   /* Alloc new clusters if required */
  264.   bytesperclus = (FS_u32)FS__FAT_aBPBUnit[pFile->dev_index][pFile->fileid_lo].SecPerClus *
  265.                  ((FS_u32)FS__FAT_aBPBUnit[pFile->dev_index][pFile->fileid_lo].BytesPerSec);
  266.   /* Calculate number of clusters required */
  267.   i = (pFile->filepos + todo) / bytesperclus;
  268.   if ((pFile->filepos + todo) % bytesperclus) {
  269.     i++;
  270.   }
  271.   /* Calculate clusters already allocated */
  272.   j = pFile->size / bytesperclus;
  273.   lexp = (pFile->size % bytesperclus);
  274.   lexp = lexp || (pFile->size == 0);
  275.   if (lexp) {
  276.     j++;
  277.   }
  278.   i -= j;
  279.   if (i > 0) {
  280.     /* Alloc new clusters */
  281.     last = pFile->EOFClust;
  282.     if (last < 0) {
  283.       /* Position of EOF is unknown, so we scan the whole file to find it */
  284.       last = FS__fat_FAT_find_eof(pFile->dev_index, pFile->fileid_lo, pFile->fileid_hi, 0);
  285.     }
  286.     if (last < 0) {
  287.       /* No EOF found */
  288.       FS__fat_free(buffer);
  289.       return 0;
  290.     }
  291.     while (i) {
  292.       last = FS__fat_FAT_alloc(pFile->dev_index, pFile->fileid_lo, last);  /* Allocate new cluster */
  293.       pFile->EOFClust = last;
  294.       if (last < 0) {
  295.         /* Cluster allocation failed */
  296.         pFile->size += (N * Size - todo);
  297.         pFile->error = FS_ERR_DISKFULL;
  298.         FS__fat_free(buffer);
  299.         return ((N * Size - todo) / Size);
  300.       }
  301.       i--;
  302.     }
  303.   }
  304.   /* Get absolute postion of data area on the media */
  305.   dstart    = (FS_u32)FS__FAT_aBPBUnit[pFile->dev_index][pFile->fileid_lo].RsvdSecCnt + 
  306.               FS__FAT_aBPBUnit[pFile->dev_index][pFile->fileid_lo].NumFATs * fatsize;
  307.   dsize     = ((FS_u32)((FS_u32)FS__FAT_aBPBUnit[pFile->dev_index][pFile->fileid_lo].RootEntCnt) * FS_FAT_DENTRY_SIZE) / FS_FAT_SEC_SIZE;
  308.   datastart = dstart + dsize;
  309.   /* Write data to clusters */
  310.   prevclust = 0;
  311.   while (todo) {  /* Write data loop */
  312.     /* Translate file ppinter position to cluster position*/
  313.     fileclustnum = pFile->filepos / bytesperclus;
  314.     /* 
  315.        Translate the file relative cluster position to an absolute cluster
  316.        position on the media. To avoid scanning the whole FAT of the file,
  317.        we remember the current cluster position in the FS_FILE data structure.
  318.     */
  319.     if (prevclust == 0) {
  320.       diskclustnum = pFile->CurClust;
  321.       if (diskclustnum == 0) {
  322.         /* No known current cluster position, we have to scan from the file's start cluster */
  323.         diskclustnum = FS__fat_diskclust(pFile->dev_index, pFile->fileid_lo, pFile->fileid_hi, fileclustnum);
  324.       }
  325.     } 
  326.     else {
  327.       /* Get next cluster of the file starting at the current cluster */
  328.       diskclustnum = FS__fat_diskclust(pFile->dev_index, pFile->fileid_lo, prevclust, 1);
  329.     }
  330.     prevclust        = diskclustnum;
  331.     pFile->CurClust  = diskclustnum;
  332.     if (diskclustnum == 0) {
  333.       /* Translation to absolute cluster failed */
  334.       pFile->error = FS_ERR_WRITEERROR;
  335.       FS__fat_free(buffer);
  336.       return ((N * Size - todo) / Size);
  337.     }
  338.     diskclustnum -= 2;
  339.     j = (pFile->filepos % bytesperclus) / FS_FAT_SEC_SIZE;
  340.     while (1) {  /* Cluster loop */
  341.       if (!todo) {
  342.         break;  /* Nothing more to write */
  343.       }
  344.       if (j >= FS__FAT_aBPBUnit[pFile->dev_index][pFile->fileid_lo].SecPerClus) {
  345.         break; /* End of cluster reached */
  346.       }
  347.       i = pFile->filepos % FS_FAT_SEC_SIZE;
  348.       /* 
  349.          We only have to read the sector from the media, if we do not
  350.          modify the whole sector. That is the case if
  352.          a) Writing starts not at the first byte of the sector
  353.          b) Less data than the sector contains is written
  354.       */
  355.       lexp = (i != 0);
  356.       lexp = lexp || (todo < FS_FAT_SEC_SIZE);
  357.       if (lexp) {
  358.         /* We have to read the old sector */
  359.         err = FS__lb_read(FS__pDevInfo[pFile->dev_index].devdriver, pFile->fileid_lo,
  360.                       datastart +
  361.                       diskclustnum * FS__FAT_aBPBUnit[pFile->dev_index][pFile->fileid_lo].SecPerClus + j,
  362.                       (void*)buffer);
  363.         if (err < 0) {
  364.           pFile->error = FS_ERR_WRITEERROR;
  365.           FS__fat_free(buffer);
  366.           return ((N * Size - todo) / Size);
  367.         }
  368.       }
  369.       while (1) {  /* Sector loop */
  370.         if (!todo) {
  371.           break;  /* Nothing more to write */
  372.         }
  373.         if (i >= FS_FAT_SEC_SIZE) {
  374.           break;  /* End of sector reached */
  375.         }
  376.         buffer[i] = *((FS_FARCHARPTR)(((FS_FARCHARPTR)pData) + N * Size - todo));
  377.         i++;
  378.         pFile->filepos++;
  379.         if (pFile->filepos > pFile->size) {
  380.           pFile->size = pFile->filepos;
  381.         }
  382.         todo--;
  383.       }  /* Sector loop */
  384.       /* Write the modified sector */
  385.       err = FS__lb_write(FS__pDevInfo[pFile->dev_index].devdriver, pFile->fileid_lo,
  386.                     datastart +
  387.                     diskclustnum * FS__FAT_aBPBUnit[pFile->dev_index][pFile->fileid_lo].SecPerClus + j,
  388.                     (void*)buffer);
  389.       if (err < 0) {
  390.         pFile->error = FS_ERR_WRITEERROR;
  391.         FS__fat_free(buffer);
  392.         return ((N * Size - todo) / Size);
  393.       }
  394.       j++;
  395.     }  /* Cluster loop */
  396.   } /* Write data loop */
  397.   if (i >= FS_FAT_SEC_SIZE) {
  398.     if (j >= FS__FAT_aBPBUnit[pFile->dev_index][pFile->fileid_lo].SecPerClus) {
  399.       /* File pointer is already in the next cluster */
  400.       pFile->CurClust = FS__fat_diskclust(pFile->dev_index, pFile->fileid_lo, prevclust, 1);
  401.     }
  402.   }
  403. #if (FS_FAT_FWRITE_UPDATE_DIR)
  404.   /* Modify directory entry */
  405.   err = _FS_fat_read_dentry(pFile->dev_index, pFile->fileid_lo, pFile->fileid_hi, pFile->fileid_ex, &s, &dsec, buffer);
  406.   if (err == 0) {
  407.     pFile->error = FS_ERR_WRITEERROR;
  408.     FS__fat_free(buffer);
  409.     return ((N * Size - todo) / Size);
  410.   }
  411.   s.data[28] = (unsigned char)(pFile->size & 0xff);   /* FileSize */
  412.   s.data[29] = (unsigned char)((pFile->size / 0x100UL) & 0xff);   
  413.   s.data[30] = (unsigned char)((pFile->size / 0x10000UL) & 0xff);
  414.   s.data[31] = (unsigned char)((pFile->size / 0x1000000UL) & 0xff);
  415.   val = FS_X_OS_GetTime();
  416.   s.data[22] = (unsigned char)(val & 0xff);
  417.   s.data[23] = (unsigned char)((val / 0x100) & 0xff);
  418.   val = FS_X_OS_GetDate();
  419.   s.data[24] = (unsigned char)(val & 0xff);
  420.   s.data[25] = (unsigned char)((val / 0x100) & 0xff);
  421.   err = _FS_fat_write_dentry(pFile->dev_index, pFile->fileid_lo, pFile->fileid_hi, &s, dsec, buffer);
  422.   if (err == 0) {
  423.     pFile->error = FS_ERR_WRITEERROR;
  424.   }
  425. #endif /* FS_FAT_FWRITE_UPDATE_DIR */
  426.   FS__fat_free(buffer);
  427.   return ((N * Size - todo) / Size);
  428. }
  431. /*********************************************************************
  432. *
  433. *             FS__fat_fclose
  434. *
  435.   Description:
  436.   FS internal function. Close a file referred by pFile.
  438.   Parameters:
  439.   pFile       - Pointer to a FS_FILE data structure. 
  440.   
  441.   Return value:
  442.   None.
  443. */
  445. void FS__fat_fclose(FS_FILE *pFile) {
  446. #if (FS_FAT_FWRITE_UPDATE_DIR==0)
  447.   FS__fat_dentry_type s;
  448.   char *buffer;
  449.   FS_u32 dsec;
  450.   FS_u16 val;
  451. #endif /* FS_FAT_FWRITE_UPDATE_DIR */
  452.   int err;
  454.   if (!pFile) {
  455.       return;
  456.   }
  457.   /* Check if media is OK */
  458.   err = FS__lb_status(FS__pDevInfo[pFile->dev_index].devdriver, pFile->fileid_lo);
  459.   if (err == FS_LBL_MEDIACHANGED) {
  460.     pFile->error = FS_ERR_DISKCHANGED;
  461.     FS__lb_ioctl(FS__pDevInfo[pFile->dev_index].devdriver, pFile->fileid_lo, FS_CMD_DEC_BUSYCNT, 0, (void*)0);  /* Turn off busy signal */
  462.     pFile->inuse = 0;
  463.     return;
  464.   }
  465.   else if (err < 0) {
  466.     pFile->error = FS_ERR_CLOSE;
  467.     FS__lb_ioctl(FS__pDevInfo[pFile->dev_index].devdriver, pFile->fileid_lo, FS_CMD_DEC_BUSYCNT, 0, (void*)0);  /* Turn off busy signal */
  468.     pFile->inuse = 0;
  469.     return;
  470.   }
  471. #if (FS_FAT_FWRITE_UPDATE_DIR==0)
  472.   /* Modify directory entry */
  473.   buffer = FS__fat_malloc(FS_FAT_SEC_SIZE);
  474.   if (!buffer) {
  475.     pFile->inuse = 0;
  476.     pFile->error = FS_ERR_CLOSE;
  477.     return;
  478.   }
  479.   err = _FS_fat_read_dentry(pFile->dev_index, pFile->fileid_lo, pFile->fileid_hi, pFile->fileid_ex, &s, &dsec, buffer);
  480.   if (err == 0) {
  481.     pFile->inuse = 0;
  482.     pFile->error = FS_ERR_CLOSE;
  483.     FS__fat_free(buffer);
  484.     return;
  485.   }
  486.   s.data[28] = (unsigned char)(pFile->size & 0xff);   /* FileSize */
  487.   s.data[29] = (unsigned char)((pFile->size / 0x100UL) & 0xff);   
  488.   s.data[30] = (unsigned char)((pFile->size / 0x10000UL) & 0xff);
  489.   s.data[31] = (unsigned char)((pFile->size / 0x1000000UL) & 0xff);
  490.   val = FS_X_OS_GetTime();
  491.   s.data[22] = (unsigned char)(val & 0xff);
  492.   s.data[23] = (unsigned char)((val / 0x100) & 0xff);
  493.   val = FS_X_OS_GetDate();
  494.   s.data[24] = (unsigned char)(val & 0xff);
  495.   s.data[25] = (unsigned char)((val / 0x100) & 0xff);
  496.   err = _FS_fat_write_dentry(pFile->dev_index, pFile->fileid_lo, pFile->fileid_hi, &s, dsec, buffer);
  497.   if (err == 0) {
  498.     pFile->error = FS_ERR_CLOSE;
  499.   }
  500.   FS__fat_free(buffer);
  501. #endif /* FS_FAT_FWRITE_UPDATE_DIR */
  502.   err = FS__lb_ioctl(FS__pDevInfo[pFile->dev_index].devdriver, pFile->fileid_lo, FS_CMD_FLUSH_CACHE, 2, (void*)0);
  503.   if (err < 0) {
  504.     pFile->error = FS_ERR_WRITEERROR;
  505.   }
  506.   pFile->inuse = 0;
  507.   FS__lb_ioctl(FS__pDevInfo[pFile->dev_index].devdriver, pFile->fileid_lo, FS_CMD_DEC_BUSYCNT, 0, (void*)0);  /* Turn off busy signal */
  508. }