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

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

uCOS

开发平台：

C/C++

fat_misc.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_misc.c
  16. Purpose     : File system's FAT File System Layer misc 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. #include "fs_dev.h"
  34. #include "fs_api.h"
  35. #include "fs_fsl.h"
  36. #include "fs_int.h"
  37. #include "fs_os.h"
  38. #include "fs_lbl.h"
  39. #include "fs_fat.h"
  40. #include "fs_clib.h"
  43. /*********************************************************************
  44. *
  45. *             #define constants
  46. *
  47. **********************************************************************
  48. */
  50. #ifndef FS_FAT_NOFAT32
  51.   #define FS_FAT_NOFAT32        0
  52. #endif /* FS_FAT_NOFAT32 */
  54. #ifndef FS_DIR_MAXOPEN
  55.   #define FS_DIR_MAXOPEN        0
  56. #endif /* FS_DIR_MAXOPEN */
  58. #define FS_MEMBLOCK_NUM   (FS_MAXOPEN+FS_DIR_MAXOPEN)*2
  61. /*********************************************************************
  62. *
  63. *             Local data types
  64. *
  65. **********************************************************************
  66. */
  68. typedef struct {
  69.   int status;
  70.   char memory[FS_FAT_SEC_SIZE];
  71. } _FS_FAT_block_type;
  74. /*********************************************************************
  75. *
  76. *             Local Variables        
  77. *
  78. **********************************************************************
  79. */
  81. static _FS_FAT_block_type          _FS_memblock[FS_MEMBLOCK_NUM];
  84. /*********************************************************************
  85. *
  86. *             Local functions section
  87. *
  88. **********************************************************************
  89. */
  91. /*********************************************************************
  92. *
  93. *             _FS_ReadBPB
  94. *
  95.   Description:
  96.   FS internal function. Read Bios-Parameter-Block from a device and
  97.   copy the relevant data to FS__FAT_aBPBUnit.
  99.   Parameters:
  100.   Idx         - Index of device in the device information table 
  101.                 referred by FS__pDevInfo.
  102.   Unit        - Unit number.
  103.  
  104.   Return value:
  105.   ==0         - BPB successfully read.
  106.   <0          - An error has occured.
  107. */
  109. static int _FS_ReadBPB(int Idx, FS_u32 Unit) {
  110.   int err;
  111.   unsigned char *buffer;
  112.   
  113.   buffer = (unsigned char*)FS__fat_malloc(FS_FAT_SEC_SIZE);
  114.   if (!buffer) {
  115.     return -1;
  116.   }
  117.   err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, 0, (void*)buffer);
  118.   if (err < 0) {
  119.     FS__fat_free(buffer);
  120.     return -1;
  121.   }
  122.   /* Assign FS__FAT_aBPBUnit */
  123.   FS__FAT_aBPBUnit[Idx][Unit].BytesPerSec   = buffer[11] + 256 * buffer[12];      /* _512_,1024,2048,4096           */
  124.   FS__FAT_aBPBUnit[Idx][Unit].SecPerClus    = buffer[13];                         /* sec in allocation unit         */
  125.   FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt    = buffer[14] + 256 * buffer[15];      /* 1 for FAT12 & FAT16            */
  126.   FS__FAT_aBPBUnit[Idx][Unit].NumFATs       = buffer[16];                         /* 2                              */
  127.   FS__FAT_aBPBUnit[Idx][Unit].RootEntCnt    = buffer[17] + 256 * buffer[18];      /* number of root dir entries     */
  128.   FS__FAT_aBPBUnit[Idx][Unit].TotSec16      = buffer[19] + 256 * buffer[20];      /* RSVD + FAT + ROOT + FATA (<64k) */
  129.   FS__FAT_aBPBUnit[Idx][Unit].FATSz16       = buffer[22] + 256 * buffer[23];      /* number of FAT sectors          */
  130.   FS__FAT_aBPBUnit[Idx][Unit].TotSec32      = buffer[32] + 0x100UL * buffer[33]   /* RSVD + FAT + ROOT + FATA (>=64k) */
  131.                                               + 0x10000UL * buffer[34] 
  132.                                               + 0x1000000UL * buffer[35];
  133.   if (FS__FAT_aBPBUnit[Idx][Unit].FATSz16 == 0) {
  134.     FS__FAT_aBPBUnit[Idx][Unit].FATSz32       = buffer[36] + 0x100UL * buffer[37]   /* number of FAT sectors          */
  135.                                                 + 0x10000UL * buffer[38] 
  136.                                                 + 0x1000000UL * buffer[39];
  137.     FS__FAT_aBPBUnit[Idx][Unit].ExtFlags      = buffer[40] + 256 * buffer[41];      /* mirroring info                 */
  138.     FS__FAT_aBPBUnit[Idx][Unit].RootClus      = buffer[44] + 0x100UL * buffer[45]   /* root dir clus for FAT32        */
  139.                                                 + 0x10000UL * buffer[46] 
  140.                                                 + 0x1000000UL * buffer[47];
  141.     FS__FAT_aBPBUnit[Idx][Unit].FSInfo        = buffer[48] + 256 * buffer[49];      /* position of FSInfo structure   */
  142.   }
  143.   else {
  144.     FS__FAT_aBPBUnit[Idx][Unit].FATSz32       = 0;
  145.     FS__FAT_aBPBUnit[Idx][Unit].ExtFlags      = 0;
  146.     FS__FAT_aBPBUnit[Idx][Unit].RootClus      = 0;
  147.     FS__FAT_aBPBUnit[Idx][Unit].FSInfo        = 0;
  148.   }
  149.   FS__FAT_aBPBUnit[Idx][Unit].Signature     = buffer[FS_FAT_SEC_SIZE-2] 
  150.                                               + 256 * buffer[FS_FAT_SEC_SIZE-1];
  151.   FS__fat_free(buffer);
  152.   return err;
  153. }
  156. /*********************************************************************
  157. *
  158. *             _FS__fat_FindFreeCluster
  159. *
  160.   Description:
  161.   FS internal function. Find the next free entry in the FAT.
  163.   Parameters:
  164.   Idx         - Index of device in the device information table 
  165.                 referred by FS__pDevInfo.
  166.   Unit        - Unit number.
  167.   pFATSector  - Returns the sector number of the free entry. 
  168.   pLastSector - Returns the sector number of the sector in pBuffer.
  169.   pFATOffset  - Returns the offset of the free FAT entry within the
  170.                 sector pFATSector.
  171.   LastClust   - Cluster, which will be used to link the new allocated
  172.                 cluster to. Here it is used at hint for where to start
  173.                 in the FAT.
  174.   pBuffer     - Pointer to a sector buffer.
  175.   FSysType    - ==1 => FAT12
  176.                 ==0 => FAT16
  177.                 ==2 => FAT32
  178.   FATSize     - Size of one FAT ind sectors.
  179.   BytesPerSec - Number of bytes in each sector.
  180.  
  181.   Return value:
  182.   >=0         - Number of the free cluster.
  183.   <0          - An error has occured.
  184. */
  186. static FS_i32 _FS__fat_FindFreeCluster(int Idx, FS_u32 Unit, FS_i32 *pFATSector, 
  187.                                        FS_i32 *pLastSector, FS_i32 *pFATOffset, 
  188.                                        FS_i32 LastClust, unsigned char *pBuffer, 
  189.                                        int FSysType, FS_u32 FATSize, FS_i32 BytesPerSec) {
  190.   FS_u32 totclst;
  191.   FS_u32 rootdirsize;
  192.   FS_i32 curclst;
  193.   FS_i32 fatindex;
  194.   int err;
  195.   int scan;
  196.   unsigned char fatentry;
  197.   unsigned char a;
  198.   unsigned char b;
  199. #if (FS_FAT_NOFAT32==0)  
  200.   unsigned char c;
  201.   unsigned char d;
  202. #endif  
  203.   
  204.   if (LastClust > 0) {
  205.     curclst = LastClust + 1;  /* Start scan after the previous allocated sector */
  206.   }
  207.   else {
  208.     curclst = 0;  /*  Start scan at the beginning of the media */
  209.   }
  210.   scan          = 0;
  211.   *pFATSector   = 0;
  212.   *pLastSector  = -1;
  213.   fatentry      = 0xff;
  214.   /* Calculate total number of data clusters on the media */
  215.   totclst = (FS_u32)FS__FAT_aBPBUnit[Idx][Unit].TotSec16;
  216.   if (totclst == 0) {
  217.     totclst = FS__FAT_aBPBUnit[Idx][Unit].TotSec32;
  218.   }
  219.   rootdirsize = ((FS_u32)((FS_u32)FS__FAT_aBPBUnit[Idx][Unit].RootEntCnt) * FS_FAT_DENTRY_SIZE) / BytesPerSec;
  220.   totclst     = totclst - (FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt + FS__FAT_aBPBUnit[Idx][Unit].NumFATs * FATSize + rootdirsize);
  221.   totclst    /= FS__FAT_aBPBUnit[Idx][Unit].SecPerClus;
  222.   while (1) {
  223.     if (curclst >= (FS_i32)totclst) {
  224.       scan++;
  225.       if (scan > 1) {
  226.         break;  /* End of clusters reached after 2nd scan */
  227.       }
  228.       if (LastClust <= 0) {
  229.         break;  /* 1st scan started already at zero */
  230.       }
  231.       curclst   = 0;  /* Try again starting at the beginning of the FAT */
  232.       fatentry  = 0xff;
  233.     }
  234.     if (fatentry == 0) {
  235.       break;  /* Free entry found */
  236.     }
  237.     if (FSysType == 1) {
  238.       fatindex = curclst + (curclst / 2);    /* FAT12 */
  239.     }
  240.     else if (FSysType == 2) {
  241.       fatindex = curclst * 4;               /* FAT32 */
  242.     }
  243.     else {
  244.       fatindex = curclst * 2;               /* FAT16 */
  245.     }
  246.     *pFATSector = FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt + (fatindex / BytesPerSec);
  247.     *pFATOffset = fatindex % BytesPerSec;
  248.     if (*pFATSector != *pLastSector) {
  249.       err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, *pFATSector, (void*)pBuffer);
  250.       if (err < 0) {
  251.         err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, FATSize + *pFATSector, (void*)pBuffer);
  252.         if (err < 0) {
  253.           return -1;
  254.         }
  255.         /* Try to repair original FAT sector with contents of copy */
  256.         FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, *pFATSector, (void*)pBuffer);
  257.       }
  258.       *pLastSector = *pFATSector;
  259.     }
  260.     if (FSysType == 1) {
  261.       if (*pFATOffset == (BytesPerSec - 1)) {
  262.         a = pBuffer[*pFATOffset];
  263.         err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, *pFATSector + 1, (void*)pBuffer);
  264.         if (err < 0) {
  265.           err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, FATSize + *pFATSector + 1, (void*)pBuffer);
  266.           if (err < 0) {
  267.             return -1;
  268.           }
  269.           /* Try to repair original FAT sector with contents of copy */
  270.           FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, *pFATSector + 1, (void*)pBuffer);
  271.         }
  272.         *pLastSector = *pFATSector + 1;
  273.         b = pBuffer[0];
  274.       }
  275.       else {
  276.         a = pBuffer[*pFATOffset];
  277.         b = pBuffer[*pFATOffset + 1];
  278.       }
  279.       if (curclst & 1) {
  280.         fatentry = ((a & 0xf0) >> 4 ) | b;
  281.       }
  282.       else {
  283.         fatentry = a | (b & 0x0f);
  284.       }
  285.     }
  286. #if (FS_FAT_NOFAT32==0)
  287.     else if (FSysType == 2) {
  288.       a = pBuffer[*pFATOffset];
  289.       b = pBuffer[*pFATOffset + 1];
  290.       c = pBuffer[*pFATOffset + 2];
  291.       d = pBuffer[*pFATOffset + 3];
  292.       fatentry = a | b | c | d;
  293.     }
  294. #endif /* FS_FAT_NOFAT32==0 */
  295.     else {
  296.       a = pBuffer[*pFATOffset];
  297.       b = pBuffer[*pFATOffset + 1];
  298.       fatentry = a | b;
  299.     }
  300.     if (fatentry != 0) {
  301.       curclst++;  /* Cluster is in use or defect, so try the next one */
  302.     }
  303.   }
  304.   if (fatentry == 0) {
  305.     return curclst;  /* Free cluster found */
  306.   }
  307.   return -1;
  308. }
  311. /*********************************************************************
  312. *
  313. *             _FS__fat_SetEOFMark
  314. *
  315.   Description:
  316.   FS internal function. Set the EOF mark in the FAT for a cluster.
  317.   The function does not write the FAT sector. An exception is FAT12,
  318.   if the FAT entry is in two sectors. 
  320.   Parameters:
  321.   Idx         - Index of device in the device information table 
  322.                 referred by FS__pDevInfo.
  323.   Unit        - Unit number.
  324.   FATSector   - FAT sector, where the cluster is located. 
  325.   pLastSector - Pointer to an FS_i32, which contains the number of the 
  326.                 sector in pBuffer.
  327.   FATOffset   - Offset of the cluster in the FAT sector.
  328.   Cluster     - Cluster number, where to set the EOF mark.
  329.   pBuffer     - Pointer to a sector buffer.
  330.   FSysType    - ==1 => FAT12
  331.                 ==0 => FAT16
  332.                 ==2 => FAT32
  333.   FATSize     - Size of one FAT ind sectors.
  334.   BytesPerSec - Number of bytes in each sector.
  335.  
  336.   Return value:
  337.   >=0         - EOF mark set.
  338.   <0          - An error has occured.
  339. */
  341. static int _FS__fat_SetEOFMark(int Idx, FS_u32 Unit, FS_i32 FATSector, 
  342.                                FS_i32 *pLastSector, FS_i32 FATOffset, 
  343.                                FS_i32 Cluster, unsigned char *pBuffer, 
  344.                                int FSysType, FS_u32 FATSize, FS_i32 BytesPerSec) {
  345.   int err1;
  346.   int err2;
  347.   int lexp;
  348.   
  349.   if (FSysType == 1) {
  350.     if (FATOffset == (BytesPerSec - 1)) {
  351.       /* Entry in 2 sectors (we have 2nd sector in buffer) */
  352.       if (Cluster & 1) {
  353.         pBuffer[0]  = (char)0xff;
  354.       }
  355.       else {
  356.         pBuffer[0] |= (char)0x0f;
  357.       }
  358.       err1 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, FATSector + 1, (void*)pBuffer);
  359.       err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, FATSize + FATSector + 1, (void*)pBuffer);
  360.       lexp = (err1 < 0);
  361.       lexp = lexp || (err2 < 0);
  362.       if (lexp) {
  363.         return -1;
  364.       }
  365.       err1 = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, FATSector, (void*)pBuffer);
  366.       if (err1 < 0) {
  367.         err1 = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, FATSize + FATSector, (void*)pBuffer);
  368.         if (err1 < 0) {
  369.           return -1;
  370.         }
  371.         /* Try to repair original FAT sector with contents of copy */
  372.         FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, FATSector, (void*)pBuffer);
  373.       }
  374.       *pLastSector = FATSector;
  375.       if (Cluster & 1) {
  376.         pBuffer[FATOffset] |= (char)0xf0;
  377.       }
  378.       else {
  379.         pBuffer[FATOffset]  = (char)0xff;
  380.       }
  381.     }
  382.     else {
  383.       if (Cluster & 1) {
  384.         pBuffer[FATOffset]   |= (char)0xf0;
  385.         pBuffer[FATOffset+1]  = (char)0xff;
  386.       }
  387.       else {
  388.         pBuffer[FATOffset]    = (char)0xff;
  389.         pBuffer[FATOffset+1] |= (char)0x0f;
  390.       }
  391.     }
  392.   }
  393. #if (FS_FAT_NOFAT32==0)
  394.   else if (FSysType == 2) { /* FAT32 */
  395.     pBuffer[FATOffset]      = (char)0xff;
  396.     pBuffer[FATOffset + 1]  = (char)0xff;
  397.     pBuffer[FATOffset + 2]  = (char)0xff;
  398.     pBuffer[FATOffset + 3]  = (char)0x0f;
  399.   }
  400. #endif /* FS_FAT_NOFAT32==0 */
  401.   else { /* FAT16 */
  402.     pBuffer[FATOffset]      = (char)0xff;
  403.     pBuffer[FATOffset + 1]  = (char)0xff;
  404.   }
  405.   return 0;
  406. }
  409. /*********************************************************************
  410. *
  411. *             _FS__fat_LinkCluster
  412. *
  413.   Description:
  414.   FS internal function. Link the new cluster with the EOF mark to the 
  415.   cluster list.
  417.   Parameters:
  418.   Idx         - Index of device in the device information table 
  419.                 referred by FS__pDevInfo.
  420.   Unit        - Unit number.
  421.   pLastSector - Pointer to an FS_i32, which contains the number of the 
  422.                 sector in pBuffer.
  423.   Cluster     - Cluster number of the new cluster with the EOF mark.
  424.   LastClust   - Number of cluster, to which the new allocated cluster
  425.                 is linked to.
  426.   pBuffer     - Pointer to a sector buffer.
  427.   FSysType    - ==1 => FAT12
  428.                 ==0 => FAT16
  429.                 ==2 => FAT32
  430.   FATSize     - Size of one FAT ind sectors.
  431.   BytesPerSec - Number of bytes in each sector.
  432.  
  433.   Return value:
  434.   >=0         - Link has been made.
  435.   <0          - An error has occured.
  436. */
  438. static int _FS__fat_LinkCluster(int Idx, FS_u32 Unit, FS_i32 *pLastSector, FS_i32 Cluster,
  439.                                 FS_i32 LastClust, unsigned char *pBuffer, int FSysType, 
  440.                                 FS_u32 FATSize, FS_i32 BytesPerSec) {
  441.   FS_i32 fatindex;
  442.   FS_i32 fatoffs;
  443.   FS_i32 fatsec;
  444.   int lexp;
  445.   int err;
  446.   int err2;
  447.   unsigned char a;
  448.   unsigned char b;
  449. #if (FS_FAT_NOFAT32==0)  
  450.   unsigned char c;
  451.   unsigned char d;
  452. #endif
  454.   /* Link old last cluster to this one */
  455.   if (FSysType == 1) {
  456.     fatindex = LastClust + (LastClust / 2); /* FAT12 */
  457.   }
  458.   else if (FSysType == 2) {
  459.     fatindex = LastClust * 4;               /* FAT32 */
  460.   }
  461.   else {
  462.     fatindex = LastClust * 2;               /* FAT16 */
  463.   }
  464.   fatsec = FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt + (fatindex / BytesPerSec);
  465.   fatoffs = fatindex % BytesPerSec;
  466.   if (fatsec != *pLastSector) {
  467.     /* 
  468.        FAT entry, which has to be modified is not in the same FAT sector, which is
  469.        currently in the buffer. So write it to the media now.
  470.     */
  471.     err  = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, *pLastSector, (void*)pBuffer);
  472.     err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, *pLastSector + FATSize, (void*)pBuffer);
  473.     lexp = (err < 0);
  474.     lexp = lexp || (err2 < 0);
  475.     if (lexp) {
  476.       return -1;
  477.     }
  478.     err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)pBuffer);
  479.     if (err < 0) {
  480.       err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, FATSize + fatsec, (void*)pBuffer);
  481.       if (err<0) {
  482.         return -1;
  483.       }
  484.       /* Try to repair original FAT sector with contents of copy */
  485.       FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)pBuffer);
  486.     }
  487.     *pLastSector = fatsec;
  488.   }
  489.   a = Cluster & 0xff;
  490.   b = (Cluster / 0x100L) & 0xff;
  491. #if (FS_FAT_NOFAT32==0)
  492.   c = (Cluster / 0x10000L) & 0xff;
  493.   d = (Cluster / 0x1000000L) & 0x0f;
  494. #endif      
  495.   if (FSysType == 1) {
  496.     if (fatoffs == (BytesPerSec - 1)) {
  497.       /* Entry in 2 sectors (we have 2nd sector in buffer) */
  498.       if (LastClust & 1) {
  499.         pBuffer[fatoffs]   &= (char)0x0f;
  500.         pBuffer[fatoffs]   |= (char)((a << 4) & 0xf0);
  501.       }
  502.       else {
  503.         pBuffer[fatoffs]    = (char)(a & 0xff);
  504.       }
  505.       err  = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)pBuffer);
  506.       err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, FATSize + fatsec, (void*)pBuffer);
  507.       lexp = (err < 0);
  508.       lexp = lexp || (err2 < 0);
  509.       if (lexp) {
  510.         return -1;
  511.       }
  512.       err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsec + 1, (void*)pBuffer);
  513.       if (err < 0) {
  514.         return -1;
  515.       }
  516.       *pLastSector = fatsec + 1;
  517.       if (LastClust & 1) {
  518.         pBuffer[0]  = (char)(((a >> 4) & 0x0f) | ((b << 4) & 0xf0));
  519.       }
  520.       else {
  521.         pBuffer[0] &= (char)0xf0;
  522.         pBuffer[0] |= (char)(b & 0x0f);
  523.       }
  524.       err  = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec + 1, (void*)pBuffer);
  525.       err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, FATSize + fatsec + 1, (void*)pBuffer);
  526.       lexp = (err < 0);
  527.       lexp = lexp || (err2 < 0);
  528.       if (lexp) {
  529.         return -1;
  530.       }
  531.     }
  532.     else {
  533.       if (LastClust & 1) {
  534.         pBuffer[fatoffs]     &= (char)0x0f;
  535.         pBuffer[fatoffs]     |= (char)((a << 4) & 0xf0);
  536.         pBuffer[fatoffs + 1]  = (char)(((a >> 4) & 0x0f) | ((b << 4) & 0xf0));
  537.       }
  538.       else {
  539.         pBuffer[fatoffs]      = (char)(a & 0xff);
  540.         pBuffer[fatoffs + 1] &= (char)0xf0;
  541.         pBuffer[fatoffs + 1] |= (char)(b & 0x0f);
  542.       }
  543.       err  = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)pBuffer);
  544.       err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, FATSize + fatsec, (void*)pBuffer);
  545.       lexp = (err < 0);
  546.       lexp = lexp || (err2 < 0);
  547.       if (lexp) {
  548.         return -1;
  549.       }
  550.     }
  551.   }
  552. #if (FS_FAT_NOFAT32==0)
  553.   else if (FSysType == 2) { /* FAT32 */
  554.     pBuffer[fatoffs]      = a;
  555.     pBuffer[fatoffs + 1]  = b;
  556.     pBuffer[fatoffs + 2]  = c;
  557.     pBuffer[fatoffs + 3]  = d;
  558.     err  = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)pBuffer);
  559.     err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, FATSize + fatsec, (void*)pBuffer);
  560.     lexp = (err < 0) ;
  561.     lexp = lexp || (err2 < 0);
  562.     if (lexp) {
  563.       return -1;
  564.     }
  565.   }
  566. #endif /* FS_FAT_NOFAT32==0 */
  567.   else { /* FAT16 */
  568.     pBuffer[fatoffs]      = a;
  569.     pBuffer[fatoffs + 1]  = b;
  570.     err  = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)pBuffer);
  571.     err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, FATSize + fatsec, (void*)pBuffer);
  572.     lexp = (err < 0);
  573.     lexp = lexp || (err2 < 0);
  574.     if (lexp) {
  575.       return -1;
  576.     }
  577.   }
  578.   return 0;
  579. }
  582. /*********************************************************************
  583. *
  584. *             Global functions section
  585. *
  586. **********************************************************************
  588.   Functions in this section are used by FAT File System layer only
  589.   
  590. */
  592. /*********************************************************************
  593. *
  594. *             FS__fat_block_init
  595. *
  596.   Description:
  597.   FS internal function. Init FAT block memory management.
  599.   Parameters:
  600.   None.
  601.  
  602.   Return value:
  603.   None.
  604. */
  606. void FS__fat_block_init(void) {
  607.   int i;
  609.   FS_X_OS_LockMem();
  610.   for (i = 0; i < FS_MEMBLOCK_NUM; i++) {
  611.     _FS_memblock[i].status = 0;
  612.   }
  613.   FS_X_OS_UnlockMem();
  614. }
  617. /*********************************************************************
  618. *
  619. *             FS__fat_malloc
  620. *
  621.   Description:
  622.   FS internal function. Allocate a sector buffer.
  624.   Parameters:
  625.   Size        - Size of the sector buffer. Normally this is 512.
  626.                 Parameter is for future extension.
  627.  
  628.   Return value:
  629.   ==0         - Cannot allocate a buffer.
  630.   !=0         - Address of a buffer.
  631. */
  634. char *FS__fat_malloc(unsigned int Size) {
  635.   int i;
  637.   FS_X_OS_LockMem();
  638.   if (Size <= FS_FAT_SEC_SIZE) {
  639.     for (i = 0; i < FS_MEMBLOCK_NUM; i++) {
  640.       if (_FS_memblock[i].status == 0) {
  641.         _FS_memblock[i].status = 1;
  642.         FS__CLIB_memset((void*)_FS_memblock[i].memory, 0, (FS_size_t)FS_FAT_SEC_SIZE);
  643.         FS_X_OS_UnlockMem();
  644.         return ((void*)_FS_memblock[i].memory);
  645.       }
  646.     }
  647.   }
  648.   FS_X_OS_UnlockMem();
  649.   return 0;
  650. }
  653. /*********************************************************************
  654. *
  655. *             FS__fat_free
  656. *
  657.   Description:
  658.   FS internal function. Free sector buffer.
  660.   Parameters:
  661.   pBuffer     - Pointer to a buffer, which has to be set free.
  662.  
  663.   Return value:
  664.   None.
  665. */
  667. void FS__fat_free(void *pBuffer) {
  668.   int i;
  670.   FS_X_OS_LockMem();
  671.   for (i = 0; i < FS_MEMBLOCK_NUM; i++) {
  672.     if (((void*)_FS_memblock[i].memory) == pBuffer) {
  673.       _FS_memblock[i].status = 0;
  674.       FS_X_OS_UnlockMem();
  675.       return;
  676.     }
  677.   }
  678.   FS_X_OS_UnlockMem();
  679. }
  682. /*********************************************************************
  683. *
  684. *             FS__fat_checkunit
  685. *
  686.   Description:
  687.   FS internal function. Read Bios-Parameter-Block from a device and
  688.   check, if it contains valid data.
  690.   Parameters:
  691.   Idx         - Index of device in the device information table 
  692.                 referred by FS__pDevInfo.
  693.   Unit        - Unit number.
  694.  
  695.   Return value:
  696.   ==1         - BPB is okay.
  697.   ==0         - An error has occured.
  698. */
  700. int FS__fat_checkunit(int Idx, FS_u32 Unit) {
  701.   int err;
  702.   int status;
  703.   int lexp;
  704.   
  705.   status = FS__lb_status(FS__pDevInfo[Idx].devdriver, Unit);
  706.   if (status < 0) {
  707.     return 0;
  708.   }
  709.   if (status == FS_LBL_MEDIACHANGED) {
  710.     /* Mount new volume */
  711.     err = _FS_ReadBPB(Idx, Unit);
  712.     if (err < 0) {
  713.       return 0;
  714.     }
  715.   }
  716.   if (FS__FAT_aBPBUnit[Idx][Unit].Signature != 0xaa55) {
  717.     err = _FS_ReadBPB(Idx, Unit);
  718.     lexp = (err < 0);
  719.     lexp = lexp || (FS__FAT_aBPBUnit[Idx][Unit].Signature != 0xaa55);
  720.     if (lexp) {
  721.       return 0;
  722.     }
  723.   }
  724.   if (FS__FAT_aBPBUnit[Idx][Unit].NumFATs != 2) {
  725.     return 0;  /* Only 2 FATs are supported */
  726.   }
  727.   if (FS__FAT_aBPBUnit[Idx][Unit].FATSz16 == 0) {
  728.     if (FS__FAT_aBPBUnit[Idx][Unit].ExtFlags & 0x0080) {
  729.       return 0;  /* Only mirroring at runtime supported */
  730.     }
  731.   }
  732.   return 1;
  733. }
  736. /*********************************************************************
  737. *
  738. *             FS__fat_which_type
  739. *
  740.   Description:
  741.   FS internal function. Determine FAT type used on a media. This
  742.   function is following the MS specification very closely.
  744.   Parameters:
  745.   Idx         - Index of device in the device information table 
  746.                 referred by FS__pDevInfo.
  747.   Unit        - Unit number.
  748.  
  749.   Return value:
  750.   ==0         - FAT16.
  751.   ==1         - FAT12.
  752.   ==2         - FAT32
  753. */
  755. int FS__fat_which_type(int Idx, FS_u32 Unit) {
  756.   FS_u32 coc;
  757.   FS_u32 fatsize;
  758.   FS_u32 totsec;
  759.   FS_u32 datasec;
  760.   FS_u32 bytespersec;
  761.   FS_u32 dsize;
  763.   bytespersec   = (FS_u32)FS__FAT_aBPBUnit[Idx][Unit].BytesPerSec;
  764.   dsize         = ((FS_u32)((FS_u32)FS__FAT_aBPBUnit[Idx][Unit].RootEntCnt) * FS_FAT_DENTRY_SIZE) / bytespersec;
  765.   fatsize       = FS__FAT_aBPBUnit[Idx][Unit].FATSz16;
  766.   if (fatsize == 0) {
  767.     fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz32;
  768.   }
  769.   totsec = (FS_u32)FS__FAT_aBPBUnit[Idx][Unit].TotSec16;
  770.   if (totsec == 0) {
  771.     totsec = FS__FAT_aBPBUnit[Idx][Unit].TotSec32;
  772.   }
  773.   datasec = totsec - (FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt +
  774.                       FS__FAT_aBPBUnit[Idx][Unit].NumFATs * fatsize + dsize);
  775.   coc     = datasec / FS__FAT_aBPBUnit[Idx][Unit].SecPerClus;
  776.   if (coc < 4085) {
  777.     return 1;  /* FAT12 */
  778.   }
  779.   else if (coc < 65525) {
  780.     return 0;  /* FAT16 */
  781.   }
  782.   return 2;  /* FAT32 */
  783. }
  786. /*********************************************************************
  787. *
  788. *             FS__fat_FAT_find_eof
  789. *
  790.   Description:
  791.   FS internal function. Find the next EOF mark in the FAT.
  793.   Parameters:
  794.   Idx         - Index of device in the device information table 
  795.                 referred by FS__pDevInfo.
  796.   Unit        - Unit number.
  797.   StrtClst    - Starting cluster in FAT.
  798.   pClstCnt    - If not zero, this is a pointer to an FS_u32, which
  799.                 is used to return the number of clusters found
  800.                 between StrtClst and the next EOF mark.
  801.  
  802.   Return value:
  803.   >=0         - Cluster, which contains the EOF mark.
  804.   <0          - An error has occured.
  805. */
  807. FS_i32 FS__fat_FAT_find_eof(int Idx, FS_u32 Unit, FS_i32 StrtClst, FS_u32 *pClstCnt) {
  808.   FS_u32 clstcount;
  809.   FS_u32 fatsize;
  810.   FS_u32 maxclst;
  811.   FS_i32 fatindex;
  812.   FS_i32 fatsec;
  813.   FS_i32 fatoffs;
  814.   FS_i32 lastsec;
  815.   FS_i32 curclst;
  816.   FS_i32 bytespersec;
  817.   FS_i32 eofclst;
  818.   int fattype;
  819.   int err;
  820.   char *buffer;
  821.   unsigned char a;
  822.   unsigned char b;
  823. #if (FS_FAT_NOFAT32==0)
  824.   unsigned char c;
  825.   unsigned char d;
  826. #endif /* FS_FAT_NOFAT32==0 */
  827.   
  828.   fattype = FS__fat_which_type(Idx, Unit);
  829.   if (fattype == 1) {
  830.     maxclst = 4085UL;       /* FAT12 */
  831.   }
  832.   else if (fattype == 2) {
  833. #if (FS_FAT_NOFAT32 == 0)
  834.     maxclst = 0x0ffffff0UL; /* FAT32 */
  835. #else
  836.     return -1;
  837. #endif /* (FS_FAT_NOFAT32==0) */    
  838.   }
  839.   else {
  840.     maxclst = 65525UL;      /* FAT16 */
  841.   }
  842.   buffer = FS__fat_malloc(FS_FAT_SEC_SIZE);
  843.   if (!buffer) {
  844.     return -1;
  845.   }
  846.   fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz16;
  847.   if (fatsize == 0) {
  848.     fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz32;
  849.   }
  850.   bytespersec   = (FS_i32)FS__FAT_aBPBUnit[Idx][Unit].BytesPerSec;
  851.   curclst       = StrtClst;
  852.   lastsec       = -1;
  853.   clstcount     = 0;
  854.   while (clstcount < maxclst) {
  855.     eofclst = curclst;
  856.     clstcount++;
  857.     if (fattype == 1) {
  858.       fatindex = curclst + (curclst / 2);   /* FAT12 */
  859.     }
  860. #if (FS_FAT_NOFAT32==0)    
  861.     else if (fattype == 2) {
  862.       fatindex = curclst * 4;               /* FAT32 */
  863.     }
  864. #endif /* FS_FAT_NOFAT32==0 */    
  865.     else {
  866.       fatindex = curclst * 2;               /* FAT16 */
  867.     }
  868.     fatsec  = FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt + (fatindex / bytespersec);
  869.     fatoffs = fatindex % bytespersec;
  870.     if (fatsec != lastsec) {
  871.       err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
  872.       if (err < 0) {
  873.         err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec, (void*)buffer);
  874.         if (err < 0) {
  875.           FS__fat_free(buffer);
  876.           return -1;
  877.         }
  878.         /* Try to repair original FAT sector with contents of copy */
  879.         FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
  880.       }
  881.       lastsec = fatsec;
  882.     }
  883.     if (fattype == 1) {
  884.       if (fatoffs == (bytespersec - 1)) {
  885.         a   = buffer[fatoffs];
  886.         err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsec + 1, (void*)buffer);
  887.         if (err < 0) {
  888.           err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec + 1, (void*)buffer);
  889.           if (err < 0) {
  890.             FS__fat_free(buffer);
  891.             return -1;
  892.           }
  893.           /* Try to repair original FAT sector with contents of copy */
  894.           FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec + 1, (void*)buffer);
  896.         }
  897.         lastsec = fatsec + 1;
  898.         b       = buffer[0];
  899.       }
  900.       else {
  901.         a = buffer[fatoffs];
  902.         b = buffer[fatoffs + 1];
  903.       }
  904.       if (curclst & 1) {
  905.         curclst = ((a & 0xf0) >> 4 ) + 16 * b;
  906.       }
  907.       else {
  908.         curclst = a + 256 * (b & 0x0f);
  909.       }
  910.       curclst &= 0x0fffL;
  911.       if (curclst >= 0x0ff8L) {
  912.         /* EOF found */
  913.         FS__fat_free(buffer);
  914.         if (pClstCnt) {
  915.           *pClstCnt = clstcount;
  916.         }
  917.         return eofclst;
  918.       }
  919.     }
  920. #if (FS_FAT_NOFAT32==0)
  921.     else if (fattype == 2) {
  922.       a         = buffer[fatoffs];
  923.       b         = buffer[fatoffs + 1];
  924.       c         = buffer[fatoffs + 2];
  925.       d         = buffer[fatoffs + 3];
  926.       curclst   = a + 0x100L * b + 0x10000L * c + 0x1000000L * d;
  927.       curclst  &= 0x0fffffffL;
  928.       if (curclst >= (FS_i32)0x0ffffff8L) {
  929.         /* EOF found */
  930.         FS__fat_free(buffer);
  931.         if (pClstCnt) {
  932.           *pClstCnt = clstcount;
  933.         }
  934.         return eofclst;
  935.       }
  936.     }
  937. #endif /* FS_FAT_NOFAT32==0 */
  938.     else {
  939.       a         = buffer[fatoffs];
  940.       b         = buffer[fatoffs + 1];
  941.       curclst   = a + 256 * b;
  942.       curclst  &= 0xffffL;
  943.       if (curclst >= (FS_i32)0xfff8L) {
  944.         /* EOF found */
  945.         FS__fat_free(buffer);
  946.         if (pClstCnt) {
  947.           *pClstCnt = clstcount;
  948.         }
  949.         return eofclst;
  950.       }
  951.     }
  952.   } /* while (clstcount<maxclst) */
  953.   FS__fat_free(buffer);
  954.   return -1;
  955. }
  958. /*********************************************************************
  959. *
  960. *             FS__fat_FAT_alloc
  961. *
  962.   Description:
  963.   FS internal function. Allocate a new cluster in the FAT and link it
  964.   to LastClust. Assign an EOF mark to the new allocated cluster.
  965.   The function has grown a lot, since it supports all FAT types (FAT12,
  966.   FAT16 & FAT32). There is also room for performance improvement, when
  967.   makeing the new FAT entry and the old entry is within the same FAT
  968.   sector.
  970.   Parameters:
  971.   Idx         - Index of device in the device information table 
  972.                 referred by FS__pDevInfo.
  973.   Unit        - Unit number.
  974.   LastClust   - Number of cluster, to which the new allocated cluster
  975.                 is linked to. If this is negative, the new cluster is
  976.                 not linked to anything and only the EOF mark is set.
  977.  
  978.   Return value:
  979.   >=0         - Number of new allocated cluster, which contains the 
  980.                 EOF mark.
  981.   <0          - An error has occured.
  982. */
  984. FS_i32 FS__fat_FAT_alloc(int Idx, FS_u32 Unit, FS_i32 LastClust) {
  985.   FS_u32 fatsize;
  986.   FS_i32 fatoffs = 0;
  987.   FS_i32 bytespersec;
  988.   FS_i32 curclst;
  989.   FS_i32 fatsec;
  990.   FS_i32 lastsec;
  991.   unsigned char *buffer;
  992.   int fattype;
  993.   int err;
  994.   int err2;
  995.   int lexp;
  996.   
  997.   buffer = (unsigned char*)FS__fat_malloc(FS_FAT_SEC_SIZE);
  998.   if (!buffer) {
  999.     return -1;
  1000.   }
  1001.   fattype = FS__fat_which_type(Idx, Unit);
  1002. #if (FS_FAT_NOFAT32!=0)
  1003.   if (fattype == 2) {
  1004.     FS__fat_free(buffer);
  1005.     return -1;
  1006.   }
  1007. #endif /* FS_FAT_NOFAT32!=0 */
  1008.   fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz16;
  1009.   if (fatsize == 0) {
  1010.     fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz32;
  1011.   }
  1012.   bytespersec   = (FS_i32)FS__FAT_aBPBUnit[Idx][Unit].BytesPerSec;
  1013.   /* Find a free cluster in the FAT */
  1014.   curclst       = _FS__fat_FindFreeCluster(Idx, Unit, &fatsec, &lastsec, &fatoffs, LastClust, buffer, fattype, fatsize, bytespersec);
  1015.   if (curclst < 0) {
  1016.     FS__fat_free(buffer);   /* No free cluster found. */
  1017.     return -1;
  1018.   }
  1019.   /* Make an EOF entry for the new cluster */
  1020.   err = _FS__fat_SetEOFMark(Idx, Unit, fatsec, &lastsec, fatoffs, curclst, buffer, fattype, fatsize, bytespersec);
  1021.   if (err < 0) {
  1022.     FS__fat_free(buffer);
  1023.     return -1;
  1024.   }
  1025.   /* Link the new cluster to the cluster list */
  1026.   if (LastClust < 0) {
  1027.     err  = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, lastsec, (void*)buffer);
  1028.     err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsize + lastsec, (void*)buffer);
  1029.     lexp = (err < 0);
  1030.     lexp = lexp || (err2 < 0);
  1031.     if (lexp) {
  1032.       FS__fat_free(buffer);
  1033.       return -1;
  1034.     }
  1035.   }
  1036.   else {
  1037.     err = _FS__fat_LinkCluster(Idx, Unit, &lastsec, curclst, LastClust, buffer, fattype, fatsize, bytespersec);
  1038.     if (err < 0) {
  1039.       FS__fat_free(buffer);
  1040.       return -1;
  1041.     }
  1042.   }
  1043.   
  1044. #if (FS_FAT_NOFAT32==0)
  1045.   /* Update the FSInfo structure */
  1046.   if (fattype == 2) {  /* FAT32 */
  1047.     /* Modify FSInfo */
  1048.     err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, FS__FAT_aBPBUnit[Idx][Unit].FSInfo, (void*)buffer);
  1049.     if (err < 0) {
  1050.       FS__fat_free(buffer);
  1051.       return -1;
  1052.     }
  1053.     /* Check for FSInfo structure in buffer */
  1054.     if (buffer[0] == (char)0x52) {
  1055.       if (buffer[1] == (char)0x52) {
  1056.         if (buffer[2] == (char)0x61) {
  1057.           if (buffer[3] == (char)0x41) {
  1058.             if (buffer[484] == (char)0x72) {
  1059.               if (buffer[485] == (char)0x72) {
  1060.                 if (buffer[486] == (char)0x41) {
  1061.                   if (buffer[487] == (char)0x61) {
  1062.                     if (buffer[508] == (char)0x00) {
  1063.                       if (buffer[509] == (char)0x00) {
  1064.                         if (buffer[510] == (char)0x55) {
  1065.                           if (buffer[511] == (char)0xaa) {
  1066.                             /* Invalidate last known free cluster count */
  1067.                             buffer[488] = (char)0xff;
  1068.                             buffer[489] = (char)0xff;
  1069.                             buffer[490] = (char)0xff;
  1070.                             buffer[491] = (char)0xff;
  1071.                             /* Give hint for free cluster search */
  1072.                             buffer[492] = curclst & 0xff;
  1073.                             buffer[493] = (curclst / 0x100L) & 0xff;
  1074.                             buffer[494] = (curclst / 0x10000L) & 0xff;
  1075.                             buffer[495] = (curclst / 0x1000000L) & 0x0f;
  1076.                             err  = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, FS__FAT_aBPBUnit[Idx][Unit].FSInfo, (void*)buffer);
  1077.                             if (err < 0) {
  1078.                               FS__fat_free(buffer);
  1079.                               return -1;
  1080.                             }
  1081.                           }
  1082.                         }
  1083.                       }
  1084.                     }
  1085.                   }
  1086.                 }
  1087.               }
  1088.             }
  1089.           }
  1090.         }
  1091.       }
  1092.     } /* buffer contains FSInfo structure */
  1093.   } /* FS_Info modification for fattype==2 */
  1094. #endif /* FS_FAT_NOFAT32==0 */
  1095.   FS__fat_free(buffer);
  1096.   return curclst;
  1097. }
  1100. /*********************************************************************
  1101. *
  1102. *             FS__fat_diskclust
  1103. *
  1104.   Description:
  1105.   FS internal function. Walk through the FAT starting at StrtClst for
  1106.   ClstNum times. Return the found cluster number of the media. This is
  1107.   very similar to FS__fat_FAT_find_eof.
  1108.   
  1109.   Parameters:
  1110.   Idx         - Index of device in the device information table 
  1111.                 referred by FS__pDevInfo.
  1112.   Unit        - Unit number.
  1113.   StrtClst    - Starting point for FAT walk.
  1114.   ClstNum     - Number of steps.
  1115.  
  1116.   Return value:
  1117.   > 0         - Number of cluster found after ClstNum steps.
  1118.   ==0         - An error has occured.
  1119. */
  1121. FS_i32 FS__fat_diskclust(int Idx, FS_u32 Unit, FS_i32 StrtClst, FS_i32 ClstNum) {
  1122.   FS_u32 fatsize;
  1123.   FS_i32 fatindex;
  1124.   FS_i32 fatsec;
  1125.   FS_i32 fatoffs;
  1126.   FS_i32 lastsec;
  1127.   FS_i32 curclst;
  1128.   FS_i32 todo;
  1129.   FS_i32 bytespersec;
  1130.   int err;
  1131.   int fattype;
  1132.   char *buffer;
  1133.   unsigned char a;
  1134.   unsigned char b;
  1135. #if (FS_FAT_NOFAT32==0)
  1136.   unsigned char c;
  1137.   unsigned char d;
  1138. #endif /* FS_FAT_NOFAT32==0 */
  1140.   fattype = FS__fat_which_type(Idx, Unit);
  1141. #if (FS_FAT_NOFAT32!=0)
  1142.   if (fattype == 2) {
  1143.     return 0;
  1144.   }
  1145. #endif  /* FS_FAT_NOFAT32!=0 */
  1146.   buffer = FS__fat_malloc(FS_FAT_SEC_SIZE);
  1147.   if (!buffer) {
  1148.     return 0;
  1149.   }
  1150.   fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz16;
  1151.   if (fatsize == 0) {
  1152.     fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz32;
  1153.   }
  1154.   bytespersec = (FS_i32)FS__FAT_aBPBUnit[Idx][Unit].BytesPerSec;
  1155.   todo        = ClstNum;
  1156.   curclst     = StrtClst;
  1157.   lastsec     = -1;
  1158.   while (todo) {
  1159.     if (fattype == 1) {
  1160.       fatindex = curclst + (curclst / 2);    /* FAT12 */
  1161.     }
  1162. #if (FS_FAT_NOFAT32==0)
  1163.     else if (fattype == 2) {
  1164.       fatindex = curclst * 4;               /* FAT32 */
  1165.     }
  1166. #endif /* FS_FAT_NOFAT32==0 */
  1167.     else {
  1168.       fatindex = curclst * 2;               /* FAT16 */
  1169.     }
  1170.     fatsec  = FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt + (fatindex / bytespersec);
  1171.     fatoffs = fatindex % bytespersec;
  1172.     if (fatsec != lastsec) {
  1173.       err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
  1174.       if (err < 0) {
  1175.         err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec, (void*)buffer);
  1176.         if (err < 0) {
  1177.           FS__fat_free(buffer);
  1178.           return 0;
  1179.         }
  1180.         /* Try to repair original FAT sector with contents of copy */
  1181.         FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
  1182.       }
  1183.       lastsec = fatsec;
  1184.     }
  1185.     if (fattype == 1) {
  1186.       if (fatoffs == (bytespersec - 1)) {
  1187.         a = buffer[fatoffs];
  1188.         err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsec + 1, (void*)buffer);
  1189.         if (err < 0) {
  1190.           err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec + 1, (void*)buffer);
  1191.           if (err < 0) {
  1192.             FS__fat_free(buffer);
  1193.             return 0;
  1194.           }
  1195.           /* Try to repair original FAT sector with contents of copy */
  1196.           FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec + 1, (void*)buffer);
  1197.         }
  1198.         lastsec = fatsec + 1;
  1199.         b = buffer[0];
  1200.       }
  1201.       else {
  1202.         a = buffer[fatoffs];
  1203.         b = buffer[fatoffs + 1];
  1204.       }
  1205.       if (curclst & 1) {
  1206.         curclst = ((a & 0xf0) >> 4) + 16 * b;
  1207.       }
  1208.       else {
  1209.         curclst = a + 256 * (b & 0x0f);
  1210.       }
  1211.       curclst &= 0x0fffL;
  1212.       if (curclst >= 0x0ff8L) {
  1213.         FS__fat_free(buffer);
  1214.         return 0;
  1215.       }
  1216.     }
  1217. #if (FS_FAT_NOFAT32==0)
  1218.     else if (fattype == 2) {
  1219.       a = buffer[fatoffs];
  1220.       b = buffer[fatoffs + 1];
  1221.       c = buffer[fatoffs + 2];
  1222.       d = buffer[fatoffs + 3];
  1223.       curclst = a + 0x100L * b + 0x10000L * c + 0x1000000L * d;
  1224.       curclst &= 0x0fffffffL;
  1225.       if (curclst >= (FS_i32)0x0ffffff8L) {
  1226.         FS__fat_free(buffer);
  1227.         return 0;
  1228.       }
  1229.     }
  1230. #endif /* FS_FAT_NOFAT32==0 */
  1231.     else {
  1232.       a = buffer[fatoffs];
  1233.       b = buffer[fatoffs + 1];
  1234.       curclst  = a + 256 * b;
  1235.       curclst &= 0xffffL;
  1236.       if (curclst >= (FS_i32)0xfff8L) {
  1237.         FS__fat_free(buffer);
  1238.         return 0;
  1239.       }
  1240.     }
  1241.     todo--;
  1242.   }
  1243.   FS__fat_free(buffer);
  1244.   return curclst;
  1245. }
  1248. /*********************************************************************
  1249. *
  1250. *             Global Variables
  1251. *
  1252. **********************************************************************
  1253. */
  1255. const FS__fsl_type FS__fat_functable = {
  1256. #if (FS_FAT_NOFAT32==0)
  1257.   "FAT12/FAT16/FAT32",
  1258. #else
  1259.   "FAT12/FAT16",
  1260. #endif /* FS_FAT_NOFAT32==0 */
  1261.   FS__fat_fopen,        /* open  */
  1262.   FS__fat_fclose,       /* close */
  1263.   FS__fat_fread,        /* read  */
  1264.   FS__fat_fwrite,       /* write */
  1265.   0,                    /* tell  */
  1266.   0,                    /* seek  */
  1267.   FS__fat_ioctl,        /* ioctl */
  1268. #if FS_POSIX_DIR_SUPPORT
  1269.   FS__fat_opendir,      /* opendir   */
  1270.   FS__fat_closedir,     /* closedir  */
  1271.   FS__fat_readdir,      /* readdir   */
  1272.   0,                    /* rewinddir */
  1273.   FS__fat_MkRmDir,      /* mkdir     */
  1274.   FS__fat_MkRmDir,      /* rmdir     */
  1275. #endif  /* FS_POSIX_DIR_SUPPORT */
  1276. };