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

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

uCOS

开发平台：

C/C++

wd_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        : wd_misc.c
  16. Purpose     : Device Driver using Windows I/O function for logical sector
  17.               access.
  18. ----------------------------------------------------------------------
  19. Known problems or limitations with current version
  20. ----------------------------------------------------------------------
  21. None.
  22. ---------------------------END-OF-HEADER------------------------------
  23. */
  25. /*********************************************************************
  26. *
  27. *             #include Section
  28. *
  29. **********************************************************************
  30. */
  32. #include "fs_port.h"
  33. #include "fs_dev.h" 
  34. #include "fs_lbl.h" 
  35. #include "fs_conf.h"
  36. #include "fs_api.h"
  37. #include "fs_clib.h"
  39. #if FS_USE_WINDRIVE_DRIVER
  41. #ifndef _WIN32
  42. #error Driver requires Windows API
  43. #endif /* _WIN32 */
  45. #include <windows.h>
  48. /*********************************************************************
  49. *
  50. *             Local data types
  51. *
  52. **********************************************************************
  53. */
  55. typedef struct {
  56.   FS_u32 block;
  57.   char buffer[FS_WD_BLOCKSIZE];
  58. } _FS_wd_cachetype;
  61. /*********************************************************************
  62. *
  63. *             Local variables        
  64. *
  65. **********************************************************************
  66. */
  68. static unsigned char      _workbuffer[512];
  69. static HANDLE             _hdrive[FS_WD_MAXUNIT];
  70. static _FS_wd_cachetype   _FS_wd_cache[FS_WD_MAXUNIT][FS_WD_CACHENUM];
  71. static int                _FS_wd_cache_index[FS_WD_MAXUNIT];
  72. static _FS_wd_cachetype   _FS_wd_wbuffer[FS_WD_MAXUNIT][FS_WD_WBUFFNUM];
  73. static int                _online[FS_WD_MAXUNIT];
  76. /*********************************************************************
  77. *
  78. *             Local functions
  79. *
  80. **********************************************************************
  81. */
  83. /*********************************************************************
  84. *
  85. *             _FS_WD_DevStatus
  86. *
  87.   Description:
  88.   FS driver function. Get status of the media.
  90.   Parameters:
  91.   Unit        - Unit number.
  92.  
  93.   Return value:
  94.   ==1 (FS_LBL_MEDIACHANGED) - The media of the device has changed.
  95.   ==0                       - Device okay and ready for operation.
  96.   <0                        - An error has occured.
  97. */
  99. static int _FS_WD_DevStatus(FS_u32 Unit) {
  100.   int i;
  102.   if (!_online[Unit]) {
  103.     _online[Unit] = 1;
  104.     if (Unit == 0) {
  105.       _hdrive[Unit] = CreateFile(FS_WD_DEV0NAME, 
  106.                                   GENERIC_READ | GENERIC_WRITE,
  107.                                   FILE_SHARE_READ | FILE_SHARE_WRITE,
  108.                                   NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
  109.                                   NULL);
  110.     }
  111.     else {
  112.       _hdrive[Unit] = CreateFile(FS_WD_DEV1NAME, 
  113.                                   GENERIC_READ | GENERIC_WRITE,
  114.                                   FILE_SHARE_READ | FILE_SHARE_WRITE,
  115.                                   NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
  116.                                   NULL);
  117.     }
  118.     for (i = 0; i < FS_WD_CACHENUM; i++) {
  119.       _FS_wd_cache[Unit][i].block = -1;
  120.     }
  121.     _FS_wd_cache_index[Unit] = 0;
  122.     for (i = 0; i < FS_WD_WBUFFNUM; i++) {
  123.       _FS_wd_wbuffer[Unit][i].block = -1;
  124.     }
  125.     return FS_LBL_MEDIACHANGED;
  126.   }
  127.   return 0;
  128. }
  131. /*********************************************************************
  132. *
  133. *             _FS_WD_DevRead
  134. *
  135.   Description:
  136.   FS driver function. Read a sector from the media.
  138.   Parameters:
  139.   Unit        - Unit number.
  140.   Sector      - Sector to be read from the device.
  141.   pBuffer     - Pointer to buffer for storing the data.
  142.  
  143.   Return value:
  144.   ==0         - Sector has been read and copied to pBuffer.
  145.   <0          - An error has occured.
  146. */
  148. static int _FS_WD_DevRead(FS_u32 Unit, FS_u32 Sector, void *pBuffer) {
  149.   DWORD bytenum;
  150.   BOOL success;
  151.   int i;
  152.   int x;
  154.   x = 0;
  155.   /* check if pBuffer in wbuffer */
  156.   i = 0;
  157.   while (i < FS_WD_WBUFFNUM) {
  158.     if (_FS_wd_wbuffer[Unit][i].block == Sector) {
  159.       FS__CLIB_memcpy(pBuffer, _FS_wd_wbuffer[Unit][i].buffer, 512);
  160.       return 0;
  161.     }
  162.     i++;
  163.   }
  164.   for (i = 0; i < FS_WD_CACHENUM; i++) {
  165.     if (_FS_wd_cache[Unit][i].block == Sector) {
  166.       FS__CLIB_memcpy(pBuffer, _FS_wd_cache[Unit][i].buffer, 512);
  167.       return 0;
  168.     }
  169.   }
  170.   SetFilePointer(_hdrive[Unit],Sector * 512, 0, FILE_BEGIN);
  171.   success = ReadFile(_hdrive[Unit], pBuffer, 512, &bytenum, NULL);
  172.   if (!success) {
  173.     x = -1;
  174.   }
  175.   _FS_wd_cache[Unit][_FS_wd_cache_index[Unit]].block = Sector;
  176.   FS__CLIB_memcpy(_FS_wd_cache[Unit][_FS_wd_cache_index[Unit]].buffer, pBuffer, 512);
  177.   _FS_wd_cache_index[Unit]++;
  178.   if (_FS_wd_cache_index[Unit] >= FS_WD_CACHENUM) {
  179.     _FS_wd_cache_index[Unit] = 0;
  180.   }
  181.   return x;
  182. }
  185. /*********************************************************************
  186. *
  187. *             _FS_WD_DevWrite
  188. *
  189.   Description:
  190.   FS driver function. Write sector to the media.
  192.   Parameters:
  193.   Unit        - Unit number.
  194.   Sector      - Sector to be written to the device.
  195.   pBuffer     - Pointer to data to be stored.
  196.  
  197.   Return value:
  198.   ==0         - Sector has been written to the device.
  199.   <0          - An error has occured.
  200. */
  202. static int _FS_WD_DevWrite(FS_u32 Unit, FS_u32 Sector, void *pBuffer) {
  203.   DWORD bytenum;
  204.   BOOL success;
  205.   int i;
  206.   int j;
  207.   int x;
  209.   x = 0;
  210.   /* clear in read cache */
  211.   for (i = 0; i < FS_WD_CACHENUM; i++) {
  212.     if (_FS_wd_cache[Unit][i].block == Sector) {
  213.       _FS_wd_cache[Unit][i].block = -1;
  214.     }
  215.   }
  216.   /* check if pBuffer in wbuffer */
  217.   i = 0;
  218.   while (i < FS_WD_WBUFFNUM) {
  219.     if (_FS_wd_wbuffer[Unit][i].block == Sector) {
  220.       FS__CLIB_memcpy(_FS_wd_wbuffer[Unit][i].buffer, pBuffer, 512);
  221.       return 0;
  222.     }
  223.     i++;
  224.   }
  225.   /* check for free wbuffer */
  226.   i = 0;
  227.   while (i < FS_WD_WBUFFNUM) {
  228.     if (_FS_wd_wbuffer[Unit][i].block == -1) {
  229.       FS__CLIB_memcpy(_FS_wd_wbuffer[Unit][i].buffer, pBuffer, 512);
  230.       _FS_wd_wbuffer[Unit][i].block = Sector;
  231.       return 0;
  232.     }
  233.     i++;
  234.   }
  235.   /* write back complete cache  */
  236.   i = 0;
  237.   while (1) {
  238.     if (i >= FS_WD_WBUFFNUM) {
  239.       break;  /* End of cache reached */
  240.     }
  241.     if (_FS_wd_wbuffer[Unit][i].block != -1) {
  242.       break;  /* Valid cache entry found */
  243.     }
  244.     i++;
  245.   }
  246.   while (i < FS_WD_WBUFFNUM) {
  247.     for (j = 0; j < FS_WD_WBUFFNUM; j++) {
  248.       if (_FS_wd_wbuffer[Unit][j].block != -1) {
  249.         if (_FS_wd_wbuffer[Unit][j].block < _FS_wd_wbuffer[Unit][i].block) {
  250.           i = j;
  251.         }
  252.       }
  253.     }
  254.     if (_FS_wd_wbuffer[Unit][i].block != -1) {
  255.       SetFilePointer(_hdrive[Unit], _FS_wd_wbuffer[Unit][i].block * 512, 0, FILE_BEGIN);
  256.       success = WriteFile(_hdrive[Unit], _FS_wd_wbuffer[Unit][i].buffer, 512, &bytenum, NULL);
  257.       if (!success) {
  258.         x = -1;
  259.       }
  260.       _FS_wd_wbuffer[Unit][i].block = -1;
  261.     }
  262.     i = 0;
  263.     while (1) {
  264.       if (i >= FS_WD_WBUFFNUM) {
  265.         break;  /* End of cache reached. */
  266.       }
  267.       if (_FS_wd_wbuffer[Unit][i].block != -1) {
  268.         break;  /* Valid entry found */
  269.       }
  270.       i++;
  271.     }
  272.   } 
  273.   FS__CLIB_memcpy(_FS_wd_wbuffer[Unit][0].buffer, pBuffer, 512);
  274.   _FS_wd_wbuffer[Unit][0].block = Sector;
  275.   return x;
  276. }
  279. /*********************************************************************
  280. *
  281. *             _FS_WD_DevIoCtl
  282. *
  283.   Description:
  284.   FS driver function. Execute device command.
  286.   Parameters:
  287.   Unit        - Unit number.
  288.   Cmd         - Command to be executed.
  289.   Aux         - Parameter depending on command.
  290.   pBuffer     - Pointer to a buffer used for the command.
  291.  
  292.   Return value:
  293.   Command specific. In general a negative value means an error.
  294. */
  296. static int _FS_WD_DevIoCtl(FS_u32 Unit, FS_i32 Cmd, FS_i32 Aux, void *pBuffer) {
  297.   FS_u32 *info;
  298.   DWORD bytenum;
  299.   BOOL success;
  300.   int i;
  301.   int x;
  302.   int lexp;
  304.   x = 0;
  305.   if (Cmd == FS_CMD_FLUSH_CACHE) {
  306.     if (_online[Unit]) {
  307.       i = 0;
  308.       while (i < FS_WD_WBUFFNUM) {
  309.         if (_FS_wd_wbuffer[Unit][i].block != -1) {
  310.           SetFilePointer(_hdrive[Unit], _FS_wd_wbuffer[Unit][i].block * 512, 0, FILE_BEGIN);
  311.           success = WriteFile(_hdrive[Unit], _FS_wd_wbuffer[Unit][i].buffer, 512, &bytenum, NULL);
  312.           if (!success) {
  313.             x = -1;
  314.           }
  315.           _FS_wd_wbuffer[Unit][i].block = -1;
  316.         }
  317.         i++;
  318.       }
  319.       CloseHandle(_hdrive[Unit]);
  320.       _online[Unit] = 0;
  321.     }
  322.   }
  323.   else if (Cmd == FS_CMD_GET_DEVINFO)  {
  324.     if (!pBuffer) {
  325.       return -1;
  326.     }
  327.     if (!_online[Unit]) {
  328.       if (Unit == 0) {
  329.         _hdrive[Unit] = CreateFile(FS_WD_DEV0NAME, 
  330.                             GENERIC_READ | GENERIC_WRITE,
  331.                             FILE_SHARE_READ | FILE_SHARE_WRITE,
  332.                             NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
  333.                             NULL);
  334.       }
  335.       else {
  336.         _hdrive[Unit] = CreateFile(FS_WD_DEV1NAME, 
  337.                             GENERIC_READ | GENERIC_WRITE,
  338.                             FILE_SHARE_READ | FILE_SHARE_WRITE,
  339.                             NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
  340.                             NULL);
  341.       }
  342.     }
  343.     SetFilePointer(_hdrive[Unit], 0, 0, FILE_BEGIN);
  344.     success = ReadFile(_hdrive[Unit], _workbuffer, 512, &bytenum, NULL);
  345.     lexp = !success;
  346.     lexp = lexp || (_workbuffer[510] != 0x55);
  347.     lexp = lexp || (_workbuffer[511] != 0xaa);
  348.     if (lexp) {
  349.       if (!_online[Unit]) {
  350.         CloseHandle(_hdrive[Unit]);
  351.       }
  352.       return -1;
  353.     }
  354.     info = pBuffer;
  355.     /* hidden */
  356.     *info = (FS_u32)_workbuffer[28] + 0x100UL * _workbuffer[29] + 0x10000UL * _workbuffer[30] + 0x1000000UL * _workbuffer[31];
  357.     info++;
  358.     /* headnum */
  359.     *info = (FS_u32)_workbuffer[26] + 0x100UL * _workbuffer[27];
  360.     info++;
  361.     /* secpertrk */
  362.     *info = (FS_u32)_workbuffer[24] + 0x100UL * _workbuffer[25];
  363.     info++;
  364.     /* total sectors */
  365.     *info = (FS_u32)_workbuffer[32] + 0x100UL * _workbuffer[33] + 0x10000UL * _workbuffer[34] + 0x1000000UL * _workbuffer[35]
  366.             + _workbuffer[19] + 0x100UL * _workbuffer[20];
  367.     if (!_online[Unit]) {
  368.       CloseHandle(_hdrive[Unit]);
  369.     }
  370.   }
  371.   return x;
  372. }
  375. /*********************************************************************
  376. *
  377. *             Global variables        
  378. *
  379. **********************************************************************
  380. */
  382. const FS__device_type FS__windrive_driver = {
  383.   "Windrive driver",
  384.   _FS_WD_DevStatus,
  385.   _FS_WD_DevRead,
  386.   _FS_WD_DevWrite,
  387.   _FS_WD_DevIoCtl
  388. };
  390. #endif /* FS_USE_WINDRIVE_DRIVER */