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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
Fx_mo.c
资源名称：tb_i86_wr_1019_1102.　[点击查看]
上传用户：super_houu
上传日期：2008-09-21
资源大小：4099k
文件大小：26k
源码类别：

DVD

开发平台：

Others

Fx_mo.c：源码内容
  1. /**************************************************************************/ 
  2. /*                                                                        */ 
  3. /*            Copyright (c) 1996-2002 by Express Logic Inc.               */ 
  4. /*                                                                        */ 
  5. /*  This software is copyrighted by and is the sole property of Express   */ 
  6. /*  Logic, Inc.  All rights, title, ownership, or other interests         */ 
  7. /*  in the software remain the property of Express Logic, Inc.  This      */ 
  8. /*  software may only be used in accordance with the corresponding        */ 
  9. /*  license agreement.  Any unauthorized use, duplication, transmission,  */ 
  10. /*  distribution, or disclosure of this software is expressly forbidden.  */ 
  11. /*                                                                        */
  12. /*  This Copyright notice may not be removed or modified without prior    */ 
  13. /*  written consent of Express Logic, Inc.                                */ 
  14. /*                                                                        */ 
  15. /*  Express Logic, Inc. reserves the right to modify this software        */ 
  16. /*  without notice.                                                       */ 
  17. /*                                                                        */ 
  18. /*  Express Logic, Inc.                     info@expresslogic.com         */
  19. /*  11423 West Bernardo Court               http://www.expresslogic.com   */
  20. /*  San Diego, CA  92127                                                  */
  21. /*                                                                        */
  22. /**************************************************************************/
  25. /**************************************************************************/
  26. /**************************************************************************/
  27. /**                                                                       */ 
  28. /** FileX Component                                                       */ 
  29. /**                                                                       */
  30. /**   Media (MED)                                                         */
  31. /**                                                                       */
  32. /**************************************************************************/
  33. /**************************************************************************/
  35. #include "Config.h" // Global Configuration - do not remove!
  37. #ifdef ENABLE_FILEX
  39. #ifdef _DEBUG
  40. #undef IFTRACE
  41. #define IFTRACE if (gTraceFileSys)
  42. #include "DebugDbgMain.h"
  43. #endif //_DEBUG
  45. #define FX_SOURCE_CODE
  47. /* Include necessary system files.  */
  49. #include "PlaycoreFileSysFileXfx_api.h"
  50. #include "PlaycoreFileSysFileXfx_sys.h"
  51. #include "PlaycoreFileSysFileXfx_med.h"
  52. #include "PlaycoreFileSysFileXfx_uti.h"
  54. /**************************************************************************/ 
  55. /*                                                                        */ 
  56. /*  FUNCTION                                               RELEASE        */ 
  57. /*                                                                        */ 
  58. /*    _fx_media_open                                      PORTABLE C      */ 
  59. /*                                                           3.0          */ 
  60. /*  AUTHOR                                                                */ 
  61. /*                                                                        */ 
  62. /*    William E. Lamie, Express Logic, Inc.                               */ 
  63. /*                                                                        */ 
  64. /*  DESCRIPTION                                                           */ 
  65. /*                                                                        */ 
  66. /*    This function opens the specified media with the supplied device    */ 
  67. /*    driver.  The specified media must conform to the MS-DOS compatible  */ 
  68. /*    file format, which is verified during the media open process.  In   */ 
  69. /*    addition, the supplied FileX device driver must also conform to     */ 
  70. /*    the FileX device driver specification.                              */ 
  71. /*                                                                        */ 
  72. /*    The MS-DOS boot sector (512 bytes) that is verified by this         */ 
  73. /*    function must look like the following:                              */ 
  74. /*                                                                        */ 
  75. /*          Byte Offset         Meaning             Size                  */ 
  76. /*                                                                        */ 
  77. /*            0x000         Jump Instructions        3                    */ 
  78. /*            0x003         OEM Name                 8                    */ 
  79. /*            0x00B        *Bytes per Sector         2                    */ 
  80. /*            0x00D        *Sectors per Cluster      1                    */ 
  81. /*            0x00E        *Reserved Sectors         2                    */ 
  82. /*            0x010        *Number of FATs           1                    */ 
  83. /*            0x011        *Max Root Dir Entries     2                    */ 
  84. /*            0x013        *Number of Sectors        2                    */ 
  85. /*            0x015         Media Type               1                    */ 
  86. /*            0x016        *Sectors per FAT          2                    */ 
  87. /*            0x018        *Sectors per Track        2                    */ 
  88. /*            0x01A        *Number of Heads          2                    */ 
  89. /*            0x01C        *Hidden Sectors           4                    */ 
  90. /*            0x020        *Huge Sectors             4                    */ 
  91. /*            0x024         Drive Number             1                    */ 
  92. /*            0x025         Reserved                 1                    */ 
  93. /*            0x026         Boot Signature           1                    */ 
  94. /*            0x027         Volume ID                4                    */ 
  95. /*            0x02B         Volume Label             11                   */ 
  96. /*            0x036         File System Type         8                    */ 
  97. /*             ...              ...                 ...                   */ 
  98. /*            0x1FE       **Signature (0x55aa)       2                    */ 
  99. /*                                                                        */ 
  100. /*            * Denotes which elements of the boot record                 */ 
  101. /*              FileX uses.                                               */ 
  102. /*                                                                        */ 
  103. /*            **Denotes the element is checked by the I/O                 */ 
  104. /*              driver.  This eliminates the need for a minimum           */ 
  105. /*              512-byte buffer for FileX.                                */ 
  106. /*                                                                        */ 
  107. /*  Note: All values above are in little endian format, i.e. the LSB is   */ 
  108. /*        in the lowest address.                                          */ 
  109. /*                                                                        */ 
  110. /*  INPUT                                                                 */ 
  111. /*                                                                        */ 
  112. /*    media_ptr                             Media control block pointer   */ 
  113. /*    media_name                            Pointer to media name string  */ 
  114. /*    media_driver                          Media driver entry function   */ 
  115. /*    driver_info_ptr                       Optional information pointer  */ 
  116. /*                                            supplied to media driver    */ 
  117. /*    memory_ptr                            Pointer to memory used by the */ 
  118. /*                                            FileX for this media.       */ 
  119. /*    memory_size                           Size of media memory - must   */ 
  120. /*                                            at least 512 bytes and      */ 
  121. /*                                            one sector size.            */ 
  122. /*                                                                        */ 
  123. /*  OUTPUT                                                                */ 
  124. /*                                                                        */ 
  125. /*    return status                                                       */ 
  126. /*                                                                        */ 
  127. /*  CALLS                                                                 */ 
  128. /*                                                                        */ 
  129. /*    I/O Driver                                                          */ 
  130. /*    _fx_media_boot_info_extract           Extract media information     */ 
  131. /*    _fx_utility_FAT_entry_read            Pickup FAT entry contents     */ 
  132. /*    tx_semaphore_create                   Create protection semaphore   */ 
  133. /*                                                                        */ 
  134. /*  CALLED BY                                                             */ 
  135. /*                                                                        */ 
  136. /*    Application Code                                                    */ 
  137. /*                                                                        */ 
  138. /*  RELEASE HISTORY                                                       */ 
  139. /*                                                                        */ 
  140. /*    DATE              NAME                      DESCRIPTION             */ 
  141. /*                                                                        */ 
  142. /*  01-01-1999     William E. Lamie         Initial Version 1.0           */ 
  143. /*  04-19-1999     William E. Lamie         Corrected logic for 12/16-bit */ 
  144. /*                                            FAT determination,          */ 
  145. /*                                            resulting in version 1.0a   */ 
  146. /*  03-01-2000     William E. Lamie         Modified comment(s), moved    */ 
  147. /*                                            data sector start setup to  */ 
  148. /*                                            ensure it is valid prior to */ 
  149. /*                                            calculating total clusters, */ 
  150. /*                                            and added initialization    */ 
  151. /*                                            current path string,        */ 
  152. /*                                            resulting in version 1.0b.  */ 
  153. /*  01-28-2001     William E. Lamie         Modified comment(s),          */ 
  154. /*                                            added support for logical   */ 
  155. /*                                            sector cache, optimized FAT */ 
  156. /*                                            entry search, and local     */ 
  157. /*                                            path setup, resulting in    */ 
  158. /*                                            version 2.0.                */
  159. /*  03-01-2002     Mohammad N. Minhaz       Modified comment(s), and      */ 
  160. /*                                            added logic to read FAT32   */ 
  161. /*                                            boot record, resulting in   */ 
  162. /*                                            version 3.0.                */ 
  163. /*                                                                        */ 
  164. /**************************************************************************/ 
  165. UINT  _fx_media_open(FX_MEDIA *media_ptr, CHAR *media_name,
  166.                  VOID (*media_driver)(FX_MEDIA *), VOID *driver_info_ptr, 
  167.                  VOID *memory_ptr, ULONG memory_size, UINT partition)
  168. {
  170. FX_MEDIA_PTR        tail_ptr;
  171. ULONG                cluster_number;
  172. ULONG                FAT_entry;
  173. ULONG                i;
  174. FX_CACHED_SECTOR    *cache_entry_ptr;
  175. UINT                status;
  177.     /* Save the basic information in the media control block.  */
  178.     media_ptr -> fx_media_name               = media_name;
  179.     media_ptr -> fx_media_driver_entry       = media_driver;
  180.     media_ptr -> fx_media_memory_buffer      = (UCHAR_PTR)memory_ptr;
  181.     media_ptr -> fx_media_sector_cache_end   = (UCHAR_PTR)memory_ptr;
  182.     media_ptr -> fx_media_memory_buffer_orig = (UCHAR_PTR)memory_ptr;
  183.     media_ptr -> fx_media_memory_size        = memory_size;
  185.     /* Initialize the supplied media I/O driver.  First, build the 
  186.        initialize driver request.  */
  187.     media_ptr -> fx_media_driver_request =              FX_DRIVER_INIT;
  188.     media_ptr -> fx_media_driver_status =               FX_IO_ERROR;
  189.     media_ptr -> fx_media_driver_buffer         = memory_ptr;
  190.     media_ptr -> fx_media_driver_info =                 driver_info_ptr;
  191.     media_ptr -> fx_media_driver_write_protect =        FX_FALSE;
  192.     media_ptr -> fx_media_driver_free_sector_update =   FX_FALSE;
  194.     /* Call the specified I/O driver with the initialize request.  */
  195.     (media_ptr -> fx_media_driver_entry) (media_ptr);
  197.     /* Determine if the I/O driver initialized successfully.  */
  198.     if (media_ptr -> fx_media_driver_status != FX_SUCCESS)
  199.     {
  201.         /* Return the driver error status.  */
  202.         return(FX_IO_ERROR);
  203.     }
  205.     // Get geometry of device.
  206.     status = _fx_utility_get_geometry( media_ptr, FALSE, 0, 0 );
  207.     
  208.     if ( status != FX_SUCCESS )
  209.     {
  210.         return status;
  211.     }
  213.     /* Read the boot sector from the device.  Build the read boot sector
  214.        command. fx_media_driver_logical_sector holds the partition to be
  215.        opened. */
  216.     media_ptr -> fx_media_driver_request        = FX_DRIVER_BOOT_READ;
  217.     media_ptr -> fx_media_driver_status         = FX_IO_ERROR;
  218.     media_ptr -> fx_media_driver_buffer         = memory_ptr;
  219.     media_ptr -> fx_media_driver_logical_sector = partition;
  220.     media_ptr -> fx_media_driver_sectors        = 1;
  222.     /* Invoke the driver to read the boot sector.  */
  223.     (media_ptr -> fx_media_driver_entry) (media_ptr);
  225.     /* Determine if the boot sector was read correctly. */
  226.     if (media_ptr -> fx_media_driver_status != FX_SUCCESS)
  227.     {
  228.         /* Create the media protection structure if FX_SINGLE_THREAD is not
  229.         defined.  */
  230. #ifndef FX_SINGLE_THREAD
  232.         os_semaphore_create(&(media_ptr -> fx_media_protect), "FileX Media Semaphore", 1);
  234. #endif
  236.         /* Load the media ID field in the media control block.  */
  237.         media_ptr -> fx_media_id =  (ULONG) FX_MEDIA_DIRECT_ID;
  239.         /* There are no hidden sectors in the media. */
  240.         media_ptr -> fx_media_hidden_sectors = 0;
  242.         /* Default value. */
  243.         media_ptr ->fx_media_bytes_per_sector = 512;
  245.         /* Return a successful status.  */
  246.         return(FX_DIRECT_SUCCESS);
  247.     }
  249.     /* Extract and validate the media parameters from the boot sector.  */
  250.     if (_fx_media_boot_info_extract(media_ptr,
  251.                                     media_ptr -> fx_media_driver_buffer) !=
  252.                                     FX_SUCCESS)
  253.     {
  255.         /* Return the invalid media error status.  */
  256.         return(FX_MEDIA_INVALID);
  257.     }
  259.     /* Determine how many logical sector's can be cached with user's supplied 
  260.        buffer area - there must be at least enough for one sector!  */
  261.     media_ptr -> fx_media_sector_cache_size =  memory_size / media_ptr -> fx_media_bytes_per_sector;
  263.     /* Is there at least one?  */
  264.     if (media_ptr -> fx_media_sector_cache_size == 0)
  265.     {
  267.         /* Error in the buffer size supplied by user.  */
  268.         return(FX_BUFFER_ERROR);
  269.     }
  271.     /* Adjust the internal cache to fit the fixed number of sector cache control blocks
  272.        built into the media control block.  */
  273.     if (media_ptr -> fx_media_sector_cache_size > FX_MAX_SECTOR_CACHE)
  274.     {
  276.         /* Adjust the number of cache sectors downward.  If this is insufficient,
  277.            the FX_MAX_SECTOR_CACHE constant in FX_API.H must be changed and the FileX
  278.            library must be rebuilt.  */
  279.         media_ptr -> fx_media_sector_cache_size =  FX_MAX_SECTOR_CACHE;
  280.     }
  282.     /* Otherwise, everything is okay.  Initialize the data structures for managing the 
  283.        logical sector cache.  */
  284.     i =  (UINT) media_ptr -> fx_media_sector_cache_size;
  285.     cache_entry_ptr =  media_ptr -> fx_media_sector_cache;
  286.     while (i--)
  287.     {
  289.         /* Initialize each of the cache entries.  */
  290.         cache_entry_ptr -> fx_cached_sector_memory_buffer =  (UCHAR_PTR) memory_ptr;
  291.         cache_entry_ptr -> fx_cached_sector =                0;
  292.         cache_entry_ptr -> fx_cached_sector_buffer_dirty =   FX_FALSE;
  293.         cache_entry_ptr -> fx_cached_sector_next_used =      cache_entry_ptr + 1;
  295.         /* Move to the next cache sector entry.  */
  296.         cache_entry_ptr++;
  298.         /* Update the memory pointer to the next buffer slot.  */
  299.         memory_ptr =  (VOID *) (((UCHAR_PTR) memory_ptr) + media_ptr -> fx_media_bytes_per_sector);
  300.     }
  302.     /* Backup to the last cache entry to set it's next pointer to NULL.  */
  303.     cache_entry_ptr--;
  304.     cache_entry_ptr -> fx_cached_sector_next_used =  FX_NULL;
  306.     /* Remember the last memory address used by the caching logic.  */
  307.     media_ptr -> fx_media_sector_cache_end =  (UCHAR_PTR) memory_ptr;
  309.     /* Setup the head pointer of the list.  */
  310.     media_ptr -> fx_media_sector_cache_list_ptr =  media_ptr -> fx_media_sector_cache;
  312.     if (media_ptr -> fx_media_32_bit_FAT == FX_TRUE)
  313.     {
  315.         /* fx_media_root_sector_start has been extracted from FX_ROOT_CLUS_32 in fx_mbie.c */
  316.         media_ptr -> fx_media_root_sector_start = media_ptr -> fx_media_data_sector_start +
  317.             (media_ptr -> fx_media_root_clus_32 - FX_FAT_ENTRY_START) * 
  318.             media_ptr -> fx_media_sectors_per_cluster;
  320.         /* Calculate maximum possible value for fx_media_root_directory_entries */
  321.         i = 0;
  322.         for(cluster_number = media_ptr->fx_media_root_clus_32;;)
  323.         {
  325.             status =  _fx_utility_FAT_entry_read(media_ptr, cluster_number, &FAT_entry);
  326.             i++;
  327.             /* Determine if the read was successful.  */
  328.             if (status != FX_SUCCESS)
  329.                 return(FX_FAT_READ_ERROR);
  330.             if ((cluster_number == FAT_entry) || (i > media_ptr -> fx_media_total_sectors))
  331.                 return(FX_FAT_READ_ERROR);
  332.             if (FAT_entry >= FX_RESERVED_1_32)
  333.                 break;
  334.             cluster_number = FAT_entry;
  335.         }
  337.         media_ptr -> fx_media_root_directory_entries = (i * media_ptr->fx_media_sectors_per_cluster * 
  338.             media_ptr->fx_media_bytes_per_sector) / FX_DIR_ENTRY_SIZE; 
  339.     }
  341.     /* Calculate the number of available clusters.  */
  342.     media_ptr -> fx_media_available_clusters =  0;
  344.     /* Set the cluster search start to an invalid value.  */
  345.     media_ptr -> fx_media_cluster_search_start =  0;
  347.     /* Loop to read each cluster entry in the first FAT.  */
  348.     for (cluster_number = FX_FAT_ENTRY_START; 
  349.                 cluster_number < (media_ptr -> fx_media_total_clusters) + FX_FAT_ENTRY_START; 
  350.                                                                                 cluster_number++)
  351.     {
  352.         /* Read a FAT entry.  */
  353.         status =  _fx_utility_FAT_entry_read(media_ptr, cluster_number, &FAT_entry);
  355.         /* Determine if the read was successful.  */
  356.         if (status != FX_SUCCESS)
  357.             return(FX_FAT_READ_ERROR);
  359.         /* Now determine if the FAT entry is available.  */
  360.         if (FAT_entry == FX_FREE_CLUSTER)
  361.         {
  363.             /* Increment the number of available clusters.  */
  364.             media_ptr -> fx_media_available_clusters++;
  366.             /* Check to see if the cluster search value is invalid.  */
  367.             if (media_ptr -> fx_media_cluster_search_start == 0)
  368.             {
  369.             
  370.                 /* Remember the first free cluster to start further searches from.  */
  371.                 media_ptr -> fx_media_cluster_search_start =  cluster_number;
  372.             }
  373.         }
  374.     }
  376.     /* If there were no free clusters, just set the search pointer to the 
  377.        first cluster number.  */
  378.     if (media_ptr -> fx_media_cluster_search_start == 0)
  379.         media_ptr -> fx_media_cluster_search_start =  FX_FAT_ENTRY_START;
  381.     /* Setup the current working directory fields to default to the root
  382.        directory.  */
  383.     media_ptr -> fx_media_default_path.fx_path_directory.fx_dir_entry_name[0] =     0;
  384.     media_ptr -> fx_media_default_path.fx_path_string[0] =                   (CHAR) 0;
  385.     media_ptr -> fx_media_default_path.fx_path_string[FX_MAXIMUM_PATH-1] =   (CHAR) 0;
  386.     media_ptr -> fx_media_default_path.fx_path_string[FX_MAXIMUM_PATH-2] =   (CHAR) 0;
  387.     media_ptr -> fx_media_default_path.fx_path_current_entry =                      0;
  389.     /* Initialize the opened file linked list and associated counter.  */
  390.     media_ptr -> fx_media_opened_file_list =      FX_NULL;
  391.     media_ptr -> fx_media_opened_file_count =     0;
  393.     /* Create the media protection structure if FX_SINGLE_THREAD is not
  394.        defined.  */
  395. #ifndef FX_SINGLE_THREAD
  397.     os_semaphore_create(&(media_ptr -> fx_media_protect), "FileX Media Semaphore", 1);
  399. #endif
  401.     /* At this point, the media has been opened successfully.  Place the 
  402.        media on the linked list of currently opened media.  */
  404.     /* Load the media ID field in the media control block.  */
  405.     media_ptr -> fx_media_id =  (ULONG) FX_MEDIA_ID;
  407.     /* Place the thread on the list of opened media.  First,
  408.        check for an empty list.  */
  409.     if (_fx_system_media_opened_ptr)
  410.     {
  412.         /* Pickup tail pointer.  */
  413.         tail_ptr =  _fx_system_media_opened_ptr -> fx_media_opened_previous;
  415.         /* Place the new media in the list.  */
  416.         _fx_system_media_opened_ptr -> fx_media_opened_previous =  media_ptr;
  417.         tail_ptr -> fx_media_opened_next =  media_ptr;
  419.         /* Setup this media's opened links.  */
  420.         media_ptr -> fx_media_opened_previous =  tail_ptr;
  421.         media_ptr -> fx_media_opened_next =      _fx_system_media_opened_ptr;
  422.     }
  423.     else
  424.     {
  426.         /* The opened media list is empty.  Add the media to empty list.  */
  427.         _fx_system_media_opened_ptr =           media_ptr;
  428.         media_ptr -> fx_media_opened_next =     media_ptr;
  429.         media_ptr -> fx_media_opened_previous = media_ptr;
  430.     }
  432.     /* Increment the opened media counter.  */
  433.     _fx_system_media_opened_count++;
  435.     /* Return a successful status.  */
  436.     return(FX_SUCCESS);
  437. }
  440. /**************************************************************************/ 
  441. /*                                                                        */ 
  442. /*  FUNCTION                                               RELEASE        */ 
  443. /*                                                                        */ 
  444. /*    _fx_media_invalidate                                PORTABLE C      */ 
  445. /*                                                           3.0          */ 
  446. /*  AUTHOR                                                                */ 
  447. /*                                                                        */ 
  448. /*    Ofir Alon, Zoran MicroElectronics Ltd.                              */ 
  449. /*                                                                        */ 
  450. /*  DESCRIPTION                                                           */ 
  451. /*                                                                        */ 
  452. /*    This function marks the specified media as closed, without touching */
  453. /*    anything else or making flush operations. If any memory needs to be */
  454. /*    freed, it will do so. This is used when we need to reopen a media   */
  455. /*    but it is possible that the media has changed (like a card taken    */
  456. /*    out and then another card inserted instead) so it will not be       */
  457. /*    to correct to flush the media.                                      */
  458. /*                                                                        */ 
  459. /*  INPUT                                                                 */ 
  460. /*                                                                        */ 
  461. /*    media_ptr                             Media control block pointer   */
  462. /*                                                                        */ 
  463. /*  OUTPUT                                                                */ 
  464. /*                                                                        */ 
  465. /*    Return status                                                       */ 
  466. /*                                                                        */ 
  467. /*  CALLS                                                                 */ 
  468. /*                                                                        */ 
  469. /*    None.                                                               */
  470. /*                                                                        */ 
  471. /*  CALLED BY                                                             */ 
  472. /*                                                                        */ 
  473. /*    Application Code                                                    */ 
  474. /*                                                                        */ 
  475. /*  RELEASE HISTORY                                                       */ 
  476. /*                                                                        */ 
  477. /*    DATE              NAME                      DESCRIPTION             */ 
  478. /*                                                                        */ 
  479. /*  10-04-2002     Ofir Alon                Initial Version 3.0           */ 
  480. /*                                                                        */ 
  481. /**************************************************************************/ 
  482. UINT _fx_media_invalidate( FX_MEDIA *media_ptr )
  483. {
  484.     // Mark media as closed.
  485.     media_ptr->fx_media_id = FX_MEDIA_CLOSED_ID;
  487. #ifndef FX_SINGLE_THREAD
  489.     tx_semaphore_delete(&(media_ptr -> fx_media_protect));
  491. #endif
  493.     return FX_SUCCESS;
  494. }
  495. #endif