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

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

uCOS

开发平台：

C/C++

fat_ioct.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_ioctc.c
  16. Purpose     : FAT File System Layer IOCTL
  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. #define FS_KNOWNMEDIA_NUM   sizeof(_FS_wd_format_media_table) / sizeof(_FS_wd_format_media_type)
  52. #ifndef FS_FAT_NOFORMAT
  53.   #define FS_FAT_NOFORMAT       0
  54. #endif
  56. #ifndef FS_FAT_DISKINFO
  57.   #define FS_FAT_DISKINFO       1
  58. #endif
  60. #ifndef FS_SUPPORT_SEC_ACCESS
  61.   #define FS_SUPPORT_SEC_ACCESS 1
  62. #endif
  64. /*********************************************************************
  65. *
  66. *             Local data types
  67. *
  68. **********************************************************************
  69. */
  71. #if (FS_FAT_NOFORMAT==0)
  73. typedef struct {
  74.   FS_i32  media_id;
  75.   FS_u32  totsec32;
  76.   FS_u32  hiddsec;
  77.   FS_u16  totsec16;
  78.   FS_u16  rootentcnt;
  79.   FS_u16  fatsz16;
  80.   FS_u16  secpertrk;
  81.   FS_u16  numheads;
  82.   char    secperclus;
  83.   char    media; 
  84.   char    fsystype;
  85. } _FS_wd_format_media_type;
  88. typedef struct {
  89.   FS_u32 SecNum;
  90.   FS_u32 Num;
  91. } _FS_FAT_ROOTENTCNT ;
  94. typedef struct {
  95.   FS_u32 SecNum;
  96.   FS_u16 Num;
  97. } _FS_FAT_SECPERCLUST;
  100. /*********************************************************************
  101. *
  102. *             Local Variables        
  103. *
  104. **********************************************************************
  105. */
  107. /*  media_id              totsec32       hidsec    totsec16   rootent  fatsz16  secpertrk  numheads secperclus  media   fstype */ 
  108. static const _FS_wd_format_media_type _FS_wd_format_media_table[] = {
  109.   { FS_MEDIA_RAM_16KB,  0x00000000UL, 0x00000000UL, 0x0020,   0x0040,  0x0001,  0x0004,     0x0004,   0x01, (char) 0xf8, 0 },
  110.   { FS_MEDIA_RAM_64KB,  0x00000000UL, 0x00000000UL, 0x0080,   0x0040,  0x0001,  0x0004,     0x0004,   0x01, (char) 0xf8, 0 },
  111.   { FS_MEDIA_RAM_128KB, 0x00000000UL, 0x00000000UL, 0x0100,   0x0080,  0x0001,  0x0004,     0x0004,   0x01, (char) 0xf8, 0 },
  112.   { FS_MEDIA_RAM_256KB, 0x00000000UL, 0x00000000UL, 0x0200,   0x0080,  0x0002,  0x0004,     0x0004,   0x01, (char) 0xf8, 0 },
  113.   { FS_MEDIA_RAM_512KB, 0x00000000UL, 0x00000000UL, 0x0400,   0x00e0,  0x0003,  0x0004,     0x0004,   0x01, (char) 0xf8, 0 },
  114.   { FS_MEDIA_FD_144MB,  0x00000000UL, 0x00000000UL, 0x0b40,   0x00e0,  0x0009,  0x0012,     0x0002,   0x01, (char) 0xf0, 0 },
  115.   { FS_MEDIA_SMC_1MB,   0x00000000UL, 0x0000000DUL, 0x07c3,   0x0100,  0x0001,  0x0004,     0x0004,   0x08, (char) 0xf8, 0 },
  116.   { FS_MEDIA_SMC_2MB,   0x00000000UL, 0x0000000bUL, 0x0f95,   0x0100,  0x0002,  0x0008,     0x0004,   0x08, (char) 0xf8, 0 },
  117.   { FS_MEDIA_SMC_4MB,   0x00000000UL, 0x0000001bUL, 0x1f25,   0x0100,  0x0002,  0x0008,     0x0004,   0x10, (char) 0xf8, 0 },
  118.   { FS_MEDIA_SMC_8MB,   0x00000000UL, 0x00000019UL, 0x3e67,   0x0100,  0x0003,  0x0010,     0x0004,   0x10, (char) 0xf8, 0 },
  119.   { FS_MEDIA_SMC_16MB,  0x00000000UL, 0x00000029UL, 0x7cd7,   0x0100,  0x0003,  0x0010,     0x0004,   0x20, (char) 0xf8, 0 },
  120.   { FS_MEDIA_SMC_32MB,  0x00000000UL, 0x00000023UL, 0xf9dd,   0x0100,  0x0006,  0x0010,     0x0008,   0x20, (char) 0xf8, 0 },
  121.   { FS_MEDIA_SMC_64MB,  0x0001f3c9UL, 0x00000037UL, 0x0000,   0x0100,  0x000c,  0x0020,     0x0008,   0x20, (char) 0xf8, 0 },
  122.   { FS_MEDIA_SMC_128MB, 0x0003e7d1UL, 0x0000002fUL, 0x0000,   0x0100,  0x0020,  0x0020,     0x0010,   0x20, (char) 0xf8, 1 },
  123.   { FS_MEDIA_MMC_32MB,  0x00000000UL, 0x00000020UL, 0xf460,   0x0200,  0x003d,  0x0020,     0x0004,   0x04, (char) 0xf8, 1 },
  124.   { FS_MEDIA_MMC_64MB,  0x0001e8e0UL, 0x00000020UL, 0x0000,   0x0200,  0x007a,  0x0020,     0x0008,   0x04, (char) 0xf8, 1 },
  125.   { FS_MEDIA_MMC_128MB, 0x0003d2e0UL, 0x00000020UL, 0x0000,   0x0200,  0x00f5,  0x0020,     0x0008,   0x04, (char) 0xf8, 1 },
  126.   { FS_MEDIA_SD_16MB,   0x00000000UL, 0x00000039UL, 0x7187,   0x0200,  0x0003,  0x0020,     0x0002,   0x20, (char) 0xf8, 0 },
  127.   { FS_MEDIA_SD_64MB,   0x0001dbd9UL, 0x00000027UL, 0x0000,   0x0200,  0x000c,  0x0020,     0x0008,   0x20, (char) 0xf8, 0 },
  128.   { FS_MEDIA_SD_128MB,  0x0003c09fUL, 0x00000061UL, 0x0000,   0x0200,  0x001f,  0x0020,     0x0008,   0x20, (char) 0xf8, 1 },
  129.   { FS_MEDIA_CF_32MB,   0x00000000UL, 0x00000020UL, 0xf760,   0x0200,  0x007c,  0x0020,     0x0004,   0x02, (char) 0xf8, 1 },
  130.   { FS_MEDIA_CF_64MB,   0x0001e860UL, 0x00000020UL, 0x0000,   0x0200,  0x007b,  0x0020,     0x0004,   0x04, (char) 0xf8, 1 }
  131. };
  134. /* table for getting number of root entries for a given media size */
  135. static const _FS_FAT_ROOTENTCNT _FS_auto_rootcnt[] = {
  136.   {         0x100,     0x40 },
  137.   {         0x200,     0x80 },
  138.   {      0x0b40UL,     0xe0 },
  139.   {  0x0001f3c9UL,    0x100 },
  140.   {  0xffffffffUL,    0x200 }
  141. };
  144. /* table for calculating cluster size */
  145. static const _FS_FAT_SECPERCLUST _FS_auto_secperclust[] = {
  146.   /* medias up to 512MB are formatted with FAT16 */
  147.   {     0x0b40UL, 0x0001 },
  148.   {      32680UL, 0x0002 },
  149.   {     262144UL, 0x0004 },
  150.   {     524288UL, 0x0008 },
  151.   {    1048576UL, 0x0010 },
  152.   /* medias bigger than 512MB are formatted with FAT32 */
  153.   {   16777216UL, 0x0008 },
  154.   {   33554432UL, 0x0010 },
  155.   {   67108864UL, 0x0020 },
  156.   { 0xffffffffUL, 0x0040 }
  157. };
  160. #endif /* FS_FAT_NOFORMAT==0 */
  162. /*********************************************************************
  163. *
  164. *             Local functions
  165. *
  166. **********************************************************************
  167. */
  169. #if (FS_FAT_NOFORMAT==0)
  171. /*********************************************************************
  172. *
  173. *             _FS_fat_format
  174. *
  175.   Description:
  176.   FS internal function. Format a media using specified parameters.
  177.   Currently this function needs many parameters. The function will be
  178.   improved. 
  180.   Parameters:
  181.   pDriver     - Pointer to a device driver function table.
  182.   Unit        - Unit number.
  183.   SecPerClus  - Number of sector per allocation unit.
  184.   RootEntCnt  - For FAT12/FAT16, this is the number of 32 byte root
  185.                 directory entries. 0 for FAT32.
  186.   TotSec16    - 16-bit total count of sectors. If zero, TotSec32 must 
  187.                 be none-zero.
  188.   TotSec32    - 32-bit total count of sectors. If zero, TotSec16 must 
  189.                 be none-zero.
  190.   Media       - Media byte.
  191.   FATSz16     - 16-bit count of sectors occupied by one FAT. 0 for
  192.                 FAT32 volumes, which use FATSz32.
  193.   FATSz32     - 32-bit count of sectors occupied by one FAT. This is
  194.                 valid for FAT32 medias only.
  195.   SecPerTrk   - Sectors per track.
  196.   NumHeads    - Number of heads.
  197.   HiddSec     - Count of hidden sectors preceding the partition.
  198.   FSysType    - ==0 => FAT12
  199.                 ==1 => FAT16
  200.                 ==2 => FAT32
  201.   
  202.   Return value:
  203.   >=0         - Media has been formatted.
  204.   <0          - An error has occured.
  205. */
  208. static int _FS_fat_format(const FS__device_type *pDriver,FS_u32 Unit, char SecPerClus, 
  209.                           FS_u16 RootEntCnt, FS_u16 TotSec16, FS_u32 TotSec32, char Media, 
  210.                           FS_u16 FATSz16, FS_u32 FATSz32, FS_u16 SecPerTrk,FS_u16 NumHeads, 
  211.                           FS_u32 HiddSec, char FSysType) {
  212.   FS__FAT_BPB bpb;
  213.   FS_u32 sector;
  214.   FS_u32 value;
  215.   char *buffer;
  216.   int i;
  217.   int j;
  218.   int n;
  219.   
  220.   buffer = FS__fat_malloc(FS_FAT_SEC_SIZE);
  221.   if (!buffer) {
  222.     return -1;
  223.   }
  224.   FS__CLIB_memset(buffer, 0x00, (FS_size_t)FS_FAT_SEC_SIZE);
  225.   /* Setup BPB */
  226.   FS__CLIB_memset(&bpb, 0x00, (FS_size_t)sizeof(bpb));
  227.   bpb.BytesPerSec = 0x0200;       /* _512_,1024,2048,4096           */
  228.   bpb.SecPerClus  = SecPerClus;   /* sec in allocation unit         */
  229.   if (FSysType != 2) {
  230.     bpb.RsvdSecCnt  = 0x0001;       /* 1 for FAT12 & FAT16            */
  231.   }
  232. #if (FS_FAT_NOFAT32==0)
  233.   else {
  234.     bpb.RsvdSecCnt  = 0x0020;       /* 32 for FAT32                   */
  235.   }
  236. #else
  237.   /* FAT32 disabled */
  238.   else {
  239.     FS__fat_free(buffer);
  240.     return -1;
  241.   }
  242. #endif /* FS_FAT_NOFAT32==0 */
  243.   bpb.NumFATs     = 0x02;         /* 2                              */
  244.   bpb.RootEntCnt  = RootEntCnt;   /* number of root dir entries     */
  245.   bpb.TotSec16    = TotSec16;     /* RSVD+FAT+ROOT+DATA (<64k)      */
  246.   bpb.FATSz16     = FATSz16;      /* number of FAT sectors          */
  247.   bpb.TotSec32    = TotSec32;     /* RSVD+FAT+ROOT+FATA (>=64k)     */
  248.   bpb.Signature   = 0xaa55;       /* 0xAA55 Signature               */
  250.   /* setup BPB specifics for FAT32 */
  251.   bpb.FATSz32     = FATSz32;      /* number of FAT sectors          */
  252.   bpb.ExtFlags    = 0x0000;       /* mirroring info                 */
  253.   bpb.RootClus    = 0x00000002UL; /* root dir clus for FAT32        */
  254.   bpb.FSInfo      = 0x0001;       /* position of FSInfo structure   */
  256.   /* 
  257.      Prepare buffer with information of the BPB 
  258.      offset 0 - 35 is same for FAT12/FAT16 and FAT32 
  259.   */
  261.   /* jmpBoot = 0xe9 0x0000 */
  262.   buffer[0]   = (char)0xe9;
  263.   buffer[1]   = (char)0x00;
  264.   buffer[2]   = (char)0x00;
  265.   /* OEMName = '        ' */
  266.   for (i = 3; i < 11; i++) {
  267.     buffer[i] = (char)0x20;
  268.   }
  269.   /* BytesPerSec */
  270.   buffer[11]  = (char)(bpb.BytesPerSec & 0xff);
  271.   buffer[12]  = (char)((unsigned int)(bpb.BytesPerSec & 0xff00) >> 8);
  272.   /* SecPerClus */
  273.   buffer[13]  = (char)bpb.SecPerClus;
  274.   /* RsvdSecCnt */
  275.   buffer[14]  = (char)(bpb.RsvdSecCnt & 0xff);
  276.   buffer[15]  = (char)((unsigned int)(bpb.RsvdSecCnt & 0xff00) >> 8);
  277.   /* NumFATs */
  278.   buffer[16]  = (char)bpb.NumFATs;
  279.   /* RootEntCnt */
  280.   buffer[17]  = (char)(bpb.RootEntCnt & 0xff);
  281.   buffer[18]  = (char)((unsigned int)(bpb.RootEntCnt & 0xff00) >> 8);
  282.   /* TotSec16 */
  283.   buffer[19]  = (char)(bpb.TotSec16 & 0xff);
  284.   buffer[20]  = (char)((unsigned int)(bpb.TotSec16 & 0xff00) >> 8);
  285.   /* Media */
  286.   buffer[21]  = Media;
  287.   /* FATSz16 */
  288.   buffer[22]  = (char)(bpb.FATSz16 & 0xff);
  289.   buffer[23]  = (char)((unsigned int)(bpb.FATSz16 & 0xff00) >> 8);
  290.   /* SecPerTrk */
  291.   buffer[24]  = (char)(SecPerTrk & 0xff);
  292.   buffer[25]  = (char)((unsigned int)(SecPerTrk & 0xff00) >> 8);
  293.   /* NumHeads */
  294.   buffer[26]  = (char)(NumHeads & 0xff);
  295.   buffer[27]  = (char)((unsigned int)(NumHeads & 0xff00) >> 8);
  296.   /* HiddSec */
  297.   buffer[28]  = (char)(HiddSec & 0xff);
  298.   buffer[29]  = (char)((FS_u32)(HiddSec & 0x0000ff00UL) >> 8);
  299.   buffer[30]  = (char)((FS_u32)(HiddSec & 0x00ff0000UL) >> 16);
  300.   buffer[31]  = (char)((FS_u32)(HiddSec & 0xff000000UL) >> 24);
  301.   /* TotSec32 */
  302.   buffer[32]  = (char)(bpb.TotSec32 & 0xff);
  303.   buffer[33]  = (char)((FS_u32)(bpb.TotSec32 & 0x0000ff00UL) >> 8);
  304.   buffer[34]  = (char)((FS_u32)(bpb.TotSec32 & 0x00ff0000UL) >> 16);
  305.   buffer[35]  = (char)((FS_u32)(bpb.TotSec32 & 0xff000000UL) >> 24);
  307.   /* Offset 36 and above have different meanings for FAT12/FAT16 and FAT32 */
  308.   if (FSysType != 2) {
  309.     /* FAT12/FAT16 */
  310.     /* DrvNum = 0x00 (floppy) */
  311.     buffer[36]  = (char)0x00;  
  312.     /* Reserved1 = 0x00 (floppy) */
  313.     buffer[37]  = (char)0x00;
  314.     /* BootSig = 0x00 (next three fields are not 'present') */
  315.     buffer[38]  = (char)0x00;
  316.     /* VolID = 0x00000000 (serial number, e.g. date/time) */
  317.     for (i = 39; i < 43; i++) {
  318.       buffer[i] = (char)0x00;
  319.     }
  320.     /* VolLab = ' ' */
  321.     for (i = 43; i < 54; i++) {
  322.       buffer[i] = (char)0x20;
  323.     }
  324.     /* FilSysType = 'FAT12' */
  325.     if (FSysType == 0) {
  326.       FS__CLIB_strncpy(&buffer[54], "FAT12   ", 8);
  327.     }
  328.     else {
  329.       FS__CLIB_strncpy(&buffer[54], "FAT16   ", 8);
  330.     }
  331.   }
  332. #if (FS_FAT_NOFAT32==0)
  333.   else {
  334.     /* FAT32 */
  335.     /* FATSz32 */
  336.     buffer[36]  = (char)(bpb.FATSz32 & 0xff);
  337.     buffer[37]  = (char)((FS_u32)(bpb.FATSz32 & 0x0000ff00UL) >> 8);
  338.     buffer[38]  = (char)((FS_u32)(bpb.FATSz32 & 0x00ff0000UL) >> 16);
  339.     buffer[39]  = (char)((FS_u32)(bpb.FATSz32 & 0xff000000UL) >> 24);
  340.     /* EXTFlags */
  341.     buffer[40]  = (char)(bpb.ExtFlags & 0xff);
  342.     buffer[41]  = (char)((unsigned int)(bpb.ExtFlags & 0xff00) >> 8);
  343.     /* FSVer = 0:0 */
  344.     buffer[42]  = 0x00;
  345.     buffer[43]  = 0x00;
  346.     /* RootClus */
  347.     buffer[44]  = (char)(bpb.RootClus & 0xff);
  348.     buffer[45]  = (char)((FS_u32)(bpb.RootClus & 0x0000ff00UL) >> 8);
  349.     buffer[46]  = (char)((FS_u32)(bpb.RootClus & 0x00ff0000UL) >> 16);
  350.     buffer[47]  = (char)((FS_u32)(bpb.RootClus & 0xff000000UL) >> 24);
  351.     /* FSInfo */
  352.     buffer[48]  = (char)(bpb.FSInfo & 0xff);
  353.     buffer[49]  = (char)((unsigned int)(bpb.FSInfo & 0xff00) >> 8);
  354.     /* BkBootSec = 0x0006; */
  355.     buffer[50]  = 0x06;
  356.     buffer[51]  = 0x00;
  357.     /* Reserved */
  358.     for (i = 52; i < 64; i++) {
  359.       buffer[i] = (char)0x00;
  360.     }
  361.     /* DrvNum = 0x00 (floppy) */
  362.     buffer[64]  = (char)0x00;
  363.     /* Reserved1 = 0x00 (floppy) */
  364.     buffer[65]  = (char)0x00;
  365.     /* BootSig = 0x00 (next three fields are not 'present') */
  366.     buffer[66]  = (char)0x00;
  367.     /* VolID = 0x00000000 (serial number, e.g. date/time) */
  368.     for (i = 67; i < 71; i++) {
  369.       buffer[i] = (char)0x00;
  370.     }
  371.     /* VolLab = ' ' */
  372.     for (i = 71; i < 82; i++) {
  373.       buffer[i] = (char)0x20;
  374.     }
  375.     /* FilSysType = 'FAT12' */
  376.     FS__CLIB_strncpy(&buffer[82], "FAT32   ", 8);
  377.   }
  378. #endif /* FS_FAT_NOFAT32==0 */
  379.   /* Signature = 0xAA55 */
  380.   buffer[510] = (char)0x55;
  381.   buffer[511] = (char)0xaa;
  382.   /* Write BPB to media */
  383.   i = FS__lb_write(pDriver, Unit, 0, (void*)buffer);
  384.   if (i < 0) {
  385.     FS__fat_free(buffer);
  386.     return -1;
  387.   }
  388.   if (FSysType == 2) {
  389.     /* Write backup BPB */
  390.     i = FS__lb_write(pDriver, Unit, 6, (void*)buffer);
  391.     if (i<0) {
  392.       FS__fat_free(buffer);
  393.       return -1;
  394.     }
  395.   }
  396.   /*  Init FAT 1 & 2   */
  397.   FS__CLIB_memset(buffer, 0x00, (FS_size_t)FS_FAT_SEC_SIZE);
  398.   for (sector = 0; sector < 2 * (bpb.FATSz16 + bpb.FATSz32); sector++) {
  399.     value = sector % (bpb.FATSz16 + bpb.FATSz32);
  400.     if (value != 0) {
  401.       i = FS__lb_write(pDriver, Unit, bpb.RsvdSecCnt + sector, (void*)buffer);
  402.       if (i<0) {
  403.         FS__fat_free(buffer);
  404.         return -1;
  405.       }
  406.     }
  407.   }
  408.   buffer[0] = (char)Media;
  409.   buffer[1] = (char)0xff;
  410.   buffer[2] = (char)0xff;
  411.   if (FSysType != 0) {
  412.     buffer[3] = (char)0xff;
  413.   }
  414. #if (FS_FAT_NOFAT32==0)
  415.   if (FSysType == 2) {
  416.     buffer[4]   = (char)0xff;
  417.     buffer[5]   = (char)0xff;
  418.     buffer[6]   = (char)0xff;
  419.     buffer[7]   = (char)0x0f;
  420.     buffer[8]   = (char)0xff;
  421.     buffer[9]   = (char)0xff;
  422.     buffer[10]  = (char)0xff;
  423.     buffer[11]  = (char)0x0f;
  424.   }
  425. #endif /* FS_FAT_NOFAT32==0 */
  426.   for (i = 0; i < 2; i++) {
  427.     j = FS__lb_write(pDriver, Unit, (FS_u32)bpb.RsvdSecCnt + i * ((FS_u32)bpb.FATSz16+bpb.FATSz32), (void*)buffer);
  428.     if (j < 0) {
  429.       FS__fat_free(buffer);
  430.       return -1;
  431.     } // two fat table
  432.   }
  433.   /* Init root directory area */
  434.   FS__CLIB_memset(buffer, 0x00, (FS_size_t)FS_FAT_SEC_SIZE);
  435.   if (bpb.RootEntCnt != 0) {
  436.     /* FAT12/FAT16 */
  437.     n = (((FS_u32)bpb.RootEntCnt * 32) / (FS_u32)512); //n show the sectors accupied by root directory entries
  438.     for (i = 0; i < n; i++) {
  439.       j = FS__lb_write(pDriver, Unit, bpb.RsvdSecCnt + 2 * bpb.FATSz16 + i, (void*)buffer); //reserved sectors under fat12/16 is 1
  440.       if (j < 0) {
  441.         FS__fat_free(buffer);
  442.         return -1;
  443.       }
  444.     }
  445.   }
  446. #if (FS_FAT_NOFAT32==0)
  447.   else {
  448.     /* FAT32 */
  449.     n = bpb.SecPerClus;
  450.     for (i = 0; i < n; i++) {
  451.       j = FS__lb_write(pDriver, Unit, bpb.RsvdSecCnt + 2 * bpb.FATSz32 + (bpb.RootClus - 2) * n + i, (void*)buffer);
  452.       if (j < 0) {
  453.         FS__fat_free(buffer);
  454.         return -1;
  455.       }
  456.     }
  457.   }
  458. #endif /* FS_FAT_NOFAT32==0 */
  459. #if (FS_FAT_NOFAT32==0)
  460.   if (FSysType == 2) {
  461.     /* Init FSInfo */
  462.     FS__CLIB_memset(buffer, 0x00, (FS_size_t)FS_FAT_SEC_SIZE);
  463.     /* LeadSig = 0x41615252 */
  464.     buffer[0]     = (char)0x52;
  465.     buffer[1]     = (char)0x52;
  466.     buffer[2]     = (char)0x61;
  467.     buffer[3]     = (char)0x41;
  468.     /* StructSig = 0x61417272 */
  469.     buffer[484]   = (char)0x72;
  470.     buffer[485]   = (char)0x72;
  471.     buffer[486]   = (char)0x41;
  472.     buffer[487]   = (char)0x61;
  473.     /* Invalidate last known free cluster count */
  474.     buffer[488]   = (char)0xff;
  475.     buffer[489]   = (char)0xff;
  476.     buffer[490]   = (char)0xff;
  477.     buffer[491]   = (char)0xff;
  478.     /* Give hint for free cluster search */
  479.     buffer[492]   = (char)0xff;
  480.     buffer[493]   = (char)0xff;
  481.     buffer[494]   = (char)0xff;
  482.     buffer[495]   = (char)0xff;
  483.     /* TrailSig = 0xaa550000 */
  484.     buffer[508]   = (char)0x00;
  485.     buffer[509]   = (char)0x00;
  486.     buffer[510]   = (char)0x55;
  487.     buffer[511]   = (char)0xaa;
  488.     i = FS__lb_write(pDriver, Unit, bpb.FSInfo, (void*)buffer);
  489.     if (i < 0) {
  490.       FS__fat_free(buffer);
  491.       return -1;
  492.     }
  493.   }
  494. #endif /* FS_FAT_NOFAT32==0 */
  495.   FS__fat_free(buffer);
  496.   return 0;
  497. }
  500. /*********************************************************************
  501. *
  502. *             _FS_FAT_AutoFormat
  503. *
  504.   Description:
  505.   FS internal function. Get information about the media from the 
  506.   device driver. Based on that informaton, calculate parameters for
  507.   formatting that media and call the format routine.
  509.   Parameters:
  510.   Idx         - Index of device in the device information table 
  511.                 referred by FS__pDevInfo.
  512.   Unit        - Unit number.
  513.   
  514.   Return value:
  515.   >=0         - Media has been formatted.
  516.   <0          - An error has occured.
  517. */
  519. static int _FS_FAT_AutoFormat(int Idx, FS_u32 Unit) {
  520.   struct {
  521.     FS_u32 hiddennum;
  522.     FS_u32 headnum;
  523.     FS_u32 secnum;
  524.     FS_u32 partsize;
  525.   } devinfo;
  526.   FS_u32 rootentcnt;
  527.   FS_u32 fatsz;
  528.   FS_u32 rootdirsectors;
  529.   FS_u32 tmpval1;
  530.   FS_u32 tmpval2;
  531.   FS_u32 fatsz32;
  532.   FS_u32 totsec32;
  533.   FS_u32 resvdseccnt;
  534.   FS_u16 totsec16;
  535.   FS_u16 fatsz16;
  536.   int i;
  537.   unsigned char secperclust;
  538.   char fsystype;
  540.   /* Get info from device */
  541.   devinfo.hiddennum = 0x00001111UL;
  542.   devinfo.headnum   = 0x00002222UL;
  543.   devinfo.secnum    = 0x00003333UL;
  544.   devinfo.partsize  = 0x00004444UL;
  545.   i = FS__lb_ioctl(FS__pDevInfo[Idx].devdriver, Unit, FS_CMD_GET_DEVINFO, 0, (void*)&devinfo);
  546.   if (i) {
  547.     return -1;
  548.   }
  549.   /* Check if the driver really supports FS_CMD_GET_DEVINFO */
  550.   if (devinfo.hiddennum == 0x00001111UL) {
  551.     if (devinfo.headnum == 0x00002222UL) {
  552.       if (devinfo.secnum == 0x00003333UL) {
  553.         if (devinfo.partsize == 0x00004444UL) {
  554.           return -1;
  555.         }
  556.       }
  557.     }
  558.   }
  559.   if (devinfo.partsize <= 1048576UL) {
  560.     fsystype = 1;   /* FAT16 */
  561.   }
  562. #if (FS_FAT_NOFAT32==0)
  563.   else {
  564.     fsystype = 2;   /* FAT32 */
  565.   }
  566. #else
  567.   else {
  568.     /* FAT32 disabled */
  569.     return -1;
  570.   }
  571. #endif /* FS_FAT_NOFAT32==0 */
  573.   /* Set correct RootEntCnt & ResvdSecCnt */ 
  574.   if (fsystype != 2) {
  575.     /* FAT16 */
  576.     i = 0;
  577.     while (_FS_auto_rootcnt[i].SecNum < devinfo.partsize) {
  578.       i++;
  579.     }
  580.     rootentcnt = (FS_u16)_FS_auto_rootcnt[i].Num;
  581.     resvdseccnt = 1;
  582.   }
  583. #if (FS_FAT_NOFAT32==0)
  584.   else {
  585.     /* FAT32 */
  586.     rootentcnt = 0;
  587.     resvdseccnt = 0x20;
  588.   }
  589. #endif /* FS_FAT_NOFAT32==0 */
  591.   /* Determinate SecPerClust */
  592.   i = 0;
  593.   while (_FS_auto_secperclust[i].SecNum < devinfo.partsize) {
  594.     i++;
  595.   }
  596.   secperclust = (unsigned char) _FS_auto_secperclust[i].Num;
  597.   /* 
  598.      FAT16/FAT32 FAT size calculation 
  599.      The formula used is following the Microsoft specification
  600.      version 1.03 very closely. Therefore the calculated FAT
  601.      size can be up to 8 sectors bigger than required for the 
  602.      media. This is a waste of up to 8 sectors, but not a problem
  603.      regarding correctness of the media's data.
  604.   */
  605.   rootdirsectors = ((rootentcnt * 32 ) + 511) / 512;
  606.   tmpval1 = devinfo.partsize - (resvdseccnt + rootdirsectors);
  607.   tmpval2 = (256 * secperclust) + 2;
  608. #if (FS_FAT_NOFAT32==0)
  609.   if (fsystype == 2) {
  610.     tmpval2 = tmpval2 / 2;
  611.   }
  612. #endif /* FS_FAT_NOFAT32==0 */
  613.   fatsz = (tmpval1 + (tmpval2 - 1)) / tmpval2;
  614.   if (fsystype != 2) {
  615.     fatsz16 = (FS_u16)fatsz;
  616.     fatsz32 = 0;
  617.   }
  618. #if (FS_FAT_NOFAT32==0)
  619.   else {
  620.     fatsz16 = 0;
  621.     fatsz32 = fatsz;
  622.   }
  623. #endif /* FS_FAT_NOFAT32==0 */
  625.   /* Number of total sectors (512 byte units) of the media
  626.      This is independent of FAT type (FAT12/FAT16/FAT32) */
  627.   if (devinfo.partsize < 0x10000UL) {
  628.     totsec16 = (FS_u16)devinfo.partsize;
  629.     totsec32 = 0;
  630.   }
  631.   else {
  632.     totsec16 = 0;
  633.     totsec32 = devinfo.partsize;
  634.   }
  635.   /* Format media using calculated values */
  636.   i = _FS_fat_format(FS__pDevInfo[Idx].devdriver,
  637.                         Unit,
  638.                         secperclust,
  639.                         (FS_u16)rootentcnt,
  640.                         totsec16,
  641.                         totsec32,
  642.                         (char)0xf8,
  643.                         fatsz16,
  644.                         fatsz32,
  645.                         (FS_u16)devinfo.secnum,
  646.                         (FS_u16)devinfo.headnum,
  647.                         devinfo.hiddennum,
  648.                         fsystype);
  649.   return i;
  650. }
  652. #endif /* FS_FAT_NOFORMAT==0 */
  655. #if FS_FAT_DISKINFO
  657. /*********************************************************************
  658. *
  659. *             _FS_fat_GetTotalFree
  660. *
  661.   Description:
  662.   FS internal function. Store information about used/unused clusters
  663.   in a FS_DISKFREE_T data structure.
  665.   Parameters:
  666.   Idx         - Index of device in the device information table 
  667.                 referred by FS__pDevInfo.
  668.   Unit        - Unit number.
  669.   pDiskData   - Pointer to a FS_DISKFREE_T data structure.
  670.   
  671.   Return value:
  672.   ==0         - Information is stored in pDiskData.
  673.   <0          - An error has occured.
  674. */
  676. static int _FS_fat_GetTotalFree(int Idx, FS_u32 Unit, FS_DISKFREE_T *pDiskData) {
  677.   FS_u32 freeclust;
  678.   FS_u32 usedclust;
  679.   FS_u32 totclust;
  680.   FS_u32 fatentry;
  681.   FS_u32 fatsize;
  682.   FS_i32 fatoffs;
  683.   FS_i32 bytespersec;
  684.   FS_i32 cursec;
  685.   FS_i32 fatsec;
  686.   FS_i32 lastsec;
  687.   FS_i32 fatindex;
  688.   int fattype;
  689.   int err;
  690.   char *buffer;
  691.   unsigned char a;
  692.   unsigned char b;
  693. #if (FS_FAT_NOFAT32==0)
  694.   unsigned char c;
  695.   unsigned char d;
  696. #endif
  697.   
  698.   if (!pDiskData) {
  699.     return -1;  /* No pointer to a FS_DISKFREE_T structure */
  700.   }
  701.   buffer = FS__fat_malloc(FS_FAT_SEC_SIZE);
  702.   if (!buffer) {
  703.     return -1;
  704.   }
  705.   fattype = FS__fat_which_type(Idx, Unit);
  706. #if (FS_FAT_NOFAT32!=0)
  707.   if (fattype == 2) {
  708.     FS__fat_free(buffer);
  709.     return -1;
  710.   }
  711. #endif /* FS_FAT_NOFAT32!=0 */
  712.   fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz16;
  713.   if (fatsize == 0) {
  714.     fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz32;
  715.   }
  716.   bytespersec = (FS_i32)FS__FAT_aBPBUnit[Idx][Unit].BytesPerSec;
  717.   /* Calculate total allocation units on disk */
  718.   totclust = FS__FAT_aBPBUnit[Idx][Unit].TotSec16;
  719.   if (!totclust) {
  720.     totclust = FS__FAT_aBPBUnit[Idx][Unit].TotSec32;
  721.   }
  722.   totclust  -= FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt;
  723.   totclust  -= 2*fatsize;
  724.   usedclust  = FS__FAT_aBPBUnit[Idx][Unit].RootEntCnt;
  725.   usedclust *= 0x20;
  726.   usedclust /= bytespersec;
  727.   totclust  -= usedclust;
  728.   totclust  /= FS__FAT_aBPBUnit[Idx][Unit].SecPerClus;
  729.   /* Scan FAT for free and used entries */
  730.   cursec     = 0;
  731.   fatsec     = 0;
  732.   lastsec    = -1;
  733.   fatentry   = 0xffffUL;
  734.   freeclust  = 0;
  735.   usedclust  = 0;
  736.   while (1) {
  737.     if (cursec >= (FS_i32)totclust) {
  738.       break;  /* Last cluster reached */
  739.     }
  740.     if (fatsec >= (FS_i32)fatsize + FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt) {
  741.       break;  /* End of FAT reached */
  742.     }
  743.     if (fattype == 1) {
  744.       fatindex = (cursec + 2) + ((cursec + 2) / 2);    /* FAT12 */
  745.     }
  746.     else if (fattype == 2) {
  747.       fatindex = (cursec + 2) * 4;               /* FAT32 */
  748.     }
  749.     else {
  750.       fatindex = (cursec + 2) * 2;               /* FAT16 */
  751.     }
  752.     fatsec = FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt + (fatindex / bytespersec);
  753.     fatoffs = fatindex % bytespersec;
  754.     if (fatsec != lastsec) {
  755.       err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
  756.       if (err < 0) {
  757.         err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec, (void*)buffer);
  758.         if (err < 0) {
  759.           FS__fat_free(buffer);
  760.           return -1;
  761.         }
  762.         /* Try to repair original FAT sector with contents of copy */
  763.         FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
  764.       }
  765.       lastsec = fatsec;
  766.     }
  767.     if (fattype == 1) {
  768.       if (fatoffs == (bytespersec - 1)) {
  769.         a = buffer[fatoffs];
  770.         err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsec+1, (void*)buffer);
  771.         if (err < 0) {
  772.           err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec + 1, (void*)buffer);
  773.           if (err < 0) {
  774.             FS__fat_free(buffer);
  775.             return -1;
  776.           }
  777.           /* Try to repair original FAT sector with contents of copy */
  778.           FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec + 1, (void*)buffer);
  779.         }
  780.         lastsec = fatsec + 1;
  781.         b = buffer[0];
  782.       }
  783.       else {
  784.         a = buffer[fatoffs];
  785.         b = buffer[fatoffs + 1];
  786.       }
  787.       if (cursec & 1) {
  788.         fatentry = ((a & 0xf0) >> 4 ) + 16 * b;
  789.       }
  790.       else {
  791.         fatentry = a + 256 * (b & 0x0f);
  792.       }
  793.       fatentry &= 0x0fff;
  794.     }
  795. #if (FS_FAT_NOFAT32==0)
  796.     else if (fattype == 2) {
  797.       a = buffer[fatoffs];
  798.       b = buffer[fatoffs + 1];
  799.       c = buffer[fatoffs + 2];
  800.       d = buffer[fatoffs + 3];
  801.       fatentry = a + 0x100UL * b + 0x10000UL * c + 0x1000000UL * d;
  802.       fatentry &= 0x0fffffffUL;
  803.     }
  804. #endif /* FS_FAT_NOFAT32==0 */
  805.     else {
  806.       a = buffer[fatoffs];
  807.       b = buffer[fatoffs + 1];
  808.       fatentry = a + 256 * b;
  809.       fatentry &= 0xffffUL;
  810.     }
  811.     cursec++;
  812.     if (fatentry == 0) {
  813.       freeclust++;
  814.     }
  815.     else {
  816.       usedclust++;
  817.     }
  818.   }
  819.   FS__fat_free(buffer);
  820.   pDiskData->total_clusters      = totclust;
  821.   pDiskData->avail_clusters      = freeclust;
  822.   pDiskData->sectors_per_cluster = FS__FAT_aBPBUnit[Idx][Unit].SecPerClus;
  823.   pDiskData->bytes_per_sector    = (FS_u16)bytespersec;
  824.   return 0;
  825. }
  827. #endif /* FS_FAT_DISKINFO */
  830. /*********************************************************************
  831. *
  832. *             Global functions
  833. *
  834. **********************************************************************
  835. */
  837. /*********************************************************************
  838. *
  839. *             FS__fat_ioctl
  840. *
  841.   Description:
  842.   FS internal function. Execute device command. The FAT layer checks
  843.   first, if it has to process the command (e.g. format). Any other
  844.   command is passed to the device driver.
  846.   Parameters:
  847.   Idx         - Index of device in the device information table 
  848.                 referred by FS__pDevInfo.
  849.   Unit        - Unit number.
  850.   Cmd         - Command to be executed.
  851.   Aux         - Parameter depending on command.
  852.   pBuffer     - Pointer to a buffer used for the command.
  853.   
  854.   Return value:
  855.   Command specific. In general a negative value means an error.
  856. */
  858. int FS__fat_ioctl(int Idx, FS_u32 Unit, FS_i32 Cmd, FS_i32 Aux, void *pBuffer) {
  859.   int x;
  860. #if ((FS_SUPPORT_SEC_ACCESS) || (FS_FAT_NOFORMAT==0))
  861.   int i;
  862. #endif
  863. #if (FS_FAT_NOFORMAT==0)
  864.   int j;
  865. #endif
  867.   FS__lb_ioctl(FS__pDevInfo[Idx].devdriver, Unit, FS_CMD_INC_BUSYCNT, 0, (void*)0);  /* Turn on busy signal */
  868. #if (FS_FAT_NOFORMAT==0)
  869.   if (Cmd == FS_CMD_FORMAT_MEDIA) {
  870.     j = 0;
  871.     while (1) {
  872.       if (j >= FS_KNOWNMEDIA_NUM) {
  873.         break;  /* Not a known media */
  874.       }
  875.       if (_FS_wd_format_media_table[j].media_id == Aux) {
  876.         break;  /* Media found in the list */
  877.       }
  878.       j++;
  879.     } //find the right media
  880.     if (j >= FS_KNOWNMEDIA_NUM) { //can't find the right media
  881.       FS__lb_ioctl(FS__pDevInfo[Idx].devdriver, Unit, FS_CMD_DEC_BUSYCNT, 0, (void*)0);  /* Turn off busy signal */
  882.       return -1;
  883.     }
  884.     i = FS__lb_status(FS__pDevInfo[Idx].devdriver, Unit); //get status of device, if ok return 1
  885.     if (i >= 0) {
  886.       x = _FS_fat_format(FS__pDevInfo[Idx].devdriver,
  887.                           Unit,
  888.                           _FS_wd_format_media_table[j].secperclus,
  889.                           _FS_wd_format_media_table[j].rootentcnt,
  890.                           _FS_wd_format_media_table[j].totsec16,
  891.                           _FS_wd_format_media_table[j].totsec32,
  892.                           _FS_wd_format_media_table[j].media,
  893.                           _FS_wd_format_media_table[j].fatsz16,
  894.                           0,
  895.                           _FS_wd_format_media_table[j].secpertrk,
  896.                           _FS_wd_format_media_table[j].numheads,
  897.                           _FS_wd_format_media_table[j].hiddsec,
  898.                           _FS_wd_format_media_table[j].fsystype);
  899.       i = FS__lb_ioctl(FS__pDevInfo[Idx].devdriver, Unit, FS_CMD_FLUSH_CACHE, 0, (void*)0);
  900.       if (i < 0) {
  901.         x = i;
  902.       }
  903.       else {
  904.         /* Invalidate BPB */
  905.         for (i = 0; i < (int)FS__maxdev; i++) {
  906.           for (j = 0; j < (int)FS__fat_maxunit; j++) {
  907.               FS__FAT_aBPBUnit[i][j].Signature = 0x0000;
  908.           }
  909.         }
  910.       }
  911.     }
  912.     else {
  913.       FS__lb_ioctl(FS__pDevInfo[Idx].devdriver, Unit, FS_CMD_DEC_BUSYCNT, 0, (void*)0);  /* Turn off busy signal */
  914.       return -1;
  915.     }
  916.   }
  917.   else if (Cmd == FS_CMD_FORMAT_AUTO) {
  918.     i = FS__lb_status(FS__pDevInfo[Idx].devdriver, Unit);
  919.     if (i >= 0) {
  920.       x = _FS_FAT_AutoFormat(Idx, Unit);
  921.       i = FS__lb_ioctl(FS__pDevInfo[Idx].devdriver, Unit, FS_CMD_FLUSH_CACHE, 0, (void*)0);
  922.       if (i < 0) {
  923.         x = i;
  924.       }
  925.     }
  926.     else {
  927.       x = -1;
  928.     }
  929.   }
  930. #else /* FS_FAT_NOFORMAT==0 */
  931.   if (Cmd == FS_CMD_FORMAT_MEDIA) {
  932.     x = -1;  /* Format command is not supported */
  933.   }
  934. #endif /* FS_FAT_NOFORMAT==0 */
  935. #if FS_FAT_DISKINFO
  936.   else if (Cmd == FS_CMD_GET_DISKFREE) {
  937.     i = FS__fat_checkunit(Idx, Unit);
  938.     if (i > 0) {
  939.       x = _FS_fat_GetTotalFree(Idx, Unit, (FS_DISKFREE_T*)pBuffer);
  940.       i = FS__lb_ioctl(FS__pDevInfo[Idx].devdriver, Unit, FS_CMD_FLUSH_CACHE, 0, (void*)0);
  941.       if (i < 0) {
  942.         x = i;
  943.       }
  944.     }
  945.     else {
  946.       x = -1;
  947.     }
  948.   }
  949. #else /* FS_FAT_DISKINFO==0 */
  950.   else if (Cmd == FS_CMD_GET_DISKFREE) {
  951.     x = -1; /* Diskinfo command not supported */
  952.   }
  953. #endif /* FS_FAT_DISKINFO */
  954. #if FS_SUPPORT_SEC_ACCESS
  955.   else if ((Cmd == FS_CMD_READ_SECTOR) || (Cmd == FS_CMD_WRITE_SECTOR)) {
  956.     if (!pBuffer) {
  957.       FS__lb_ioctl(FS__pDevInfo[Idx].devdriver, Unit, FS_CMD_DEC_BUSYCNT, 0, (void*)0);
  958.       return -1;
  959.     }
  960.     i = FS__lb_status(FS__pDevInfo[Idx].devdriver, Unit);
  961.     if (i >= 0) {
  962.       if (Cmd == FS_CMD_READ_SECTOR) {
  963.         x = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, Aux, pBuffer);
  964.       }
  965.       else {
  966.         x = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, Aux, pBuffer);
  967.       }
  968.     }
  969.     else {
  970.       x = -1;
  971.     }
  972.   }
  973. #else /* FS_SUPPORT_SEC_ACCESS */
  974.   else if ((Cmd == FS_CMD_READ_SECTOR) || (Cmd == FS_CMD_WRITE_SECTOR)) {
  975.     FS__lb_ioctl(FS__pDevInfo[Idx].devdriver, Unit, FS_CMD_DEC_BUSYCNT, 0, (void*)0);
  976.     return -1;
  977.   }
  978. #endif /* FS_SUPPORT_SEC_ACCESS */
  979.   else {
  980.     /* Maybe command for driver */
  981.     x = FS__lb_ioctl(FS__pDevInfo[Idx].devdriver, Unit, Cmd, Aux, (void*)pBuffer);
  982.   }
  983.   FS__lb_ioctl(FS__pDevInfo[Idx].devdriver, Unit, FS_CMD_DEC_BUSYCNT, 0, (void*)0);  /* Turn off busy signal */
  984.   return x;
  985. }