Category

Development Platform
Home > SourceCode/Document > Multimedia program > DVD > View Code
Fx_upg.c
Package: tb_i86_wr_1019_1102.　[view]
Upload User: super_houu
Upload Date: 2008-09-21
Package Size: 4099k
Code Size: 13k
Category:

DVD

Development Platform:

Others

Fx_upg.c：Code Content
  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. /**   Utility (UTI)                                                       */
  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"
  52. #ifndef FX_MEDIA_PART_DEFINED
  53. typedef struct FX_MEDIA_PART_STRUCT
  54. {
  55.     ULONG fx_media_part_start;    
  56.     ULONG fx_media_part_size;
  57. } FX_MEDIA_PART;
  58. #endif
  61. /**************************************************************************/ 
  62. /*                                                                        */ 
  63. /*  FUNCTION                                               RELEASE        */ 
  64. /*                                                                        */ 
  65. /*    _fx_utility_partition_get                           PORTABLE C      */ 
  66. /*                                                           3.0          */ 
  67. /*  AUTHOR                                                                */ 
  68. /*                                                                        */ 
  69. /*    Mohammad N. Minhaz, Express Logic, Inc.                             */ 
  70. /*                                                                        */ 
  71. /*  DESCRIPTION                                                           */ 
  72. /*                                                                        */ 
  73. /*    This function parses the partition sector and completes the         */ 
  74. /*    supplied partition entry structure.                                 */ 
  75. /*                                                                        */ 
  76. /*  INPUT                                                                 */ 
  77. /*                                                                        */ 
  78. /*    part_tab                              Pointer to partition table    */ 
  79. /*    count                                 Number of partitions found    */ 
  80. /*    sect                                  Base sector                   */ 
  81. /*    sect_buf                              Buffer containing partition   */ 
  82. /*                                            table                       */ 
  83. /*                                                                        */ 
  84. /*  OUTPUT                                                                */ 
  85. /*                                                                        */ 
  86. /*    return status                                                       */ 
  87. /*                                                                        */ 
  88. /*  CALLS                                                                 */ 
  89. /*                                                                        */ 
  90. /*    None                                                                */ 
  91. /*                                                                        */ 
  92. /*  CALLED BY                                                             */ 
  93. /*                                                                        */ 
  94. /*    Application Driver                                                  */ 
  95. /*                                                                        */ 
  96. /*  RELEASE HISTORY                                                       */ 
  97. /*                                                                        */ 
  98. /*    DATE              NAME                      DESCRIPTION             */ 
  99. /*                                                                        */ 
  100. /*  07-04-2002     Mohammad N. Minhaz       Initial Version 1.0           */ 
  101. /*                                                                        */ 
  102. /**************************************************************************/ 
  103. UINT  _fx_utility_partition_get(FX_MEDIA_PART *part_tab, 
  104.                                 UINT *count, ULONG sect, UCHAR *sect_buf)
  105. {
  106.     UINT i;
  107.     ULONG base_sect, val;
  108.  
  110.     base_sect = 0;
  111.     /* find out if it is a sub partition */
  112.     for(i = 0; i < *count ; i++)
  113.         if (sect == part_tab[i].fx_media_part_start){
  114.             base_sect = part_tab[i].fx_media_part_start; 
  115.             break; /* sub part */
  116.         }
  118.     for(i = 446; i <= 494; i+=16)
  119.     {
  120.         if (sect_buf[i + 4] == 0) /* no partition entry here */
  121.             continue;
  122.         val = (ULONG) sect_buf[i + 8] ; /* little endian start value */
  123.         val = (((ULONG) sect_buf[i + 9]) << 8) | val;
  124.         val = (((ULONG) sect_buf[i + 10]) << 16) | val;
  125.         val = (((ULONG) sect_buf[i + 11]) << 24) | val;
  126.         part_tab[*count].fx_media_part_start = val + base_sect;
  128.         val =(ULONG) sect_buf[i + 12] ; /* little endian size value */
  129.         val = (((ULONG) sect_buf[i + 13]) << 8) | val;
  130.         val = (((ULONG) sect_buf[i + 14]) << 16) | val;
  131.         val = (((ULONG) sect_buf[i + 15]) << 24) | val;
  132.         part_tab[*count].fx_media_part_size = val;
  133.         
  134.         (*count)++;
  135.     }
  136.     return FX_SUCCESS;
  137. }
  140. /**************************************************************************/ 
  141. /*                                                                        */ 
  142. /*  FUNCTION                                               RELEASE        */ 
  143. /*                                                                        */ 
  144. /*    _fx_partition_offset_calculate                      PORTABLE C      */ 
  145. /*                                                           3.0          */ 
  146. /*  AUTHOR                                                                */ 
  147. /*                                                                        */ 
  148. /*    Mohammad N. Minhaz, Express Logic, Inc.                             */ 
  149. /*                                                                        */ 
  150. /*  DESCRIPTION                                                           */ 
  151. /*                                                                        */ 
  152. /*    This function calculates the sector offset to the specified         */ 
  153. /*    partition.  The buffer containing the partition table is also       */ 
  154. /*    supplied to this function.  If the buffer supplied is a boot        */ 
  155. /*    record (which could be the case in non-partition systems), this     */ 
  156. /*    function returns an offset of zero and a successful status          */ 
  157. /*    indicating that the buffer supplied is the boot record.  Otherwise, */ 
  158. /*    if the partition is found, this function returns the sector offset  */ 
  159. /*    to its boot record along with a successful status.  If the          */ 
  160. /*    specified partition is not found or the buffer is not a partition   */ 
  161. /*    table or boot record, this function returns an error.               */ 
  162. /*                                                                        */ 
  163. /*  INPUT                                                                 */ 
  164. /*                                                                        */ 
  165. /*    part_sector                           Pointer to buffer containing  */ 
  166. /*                                            either the partition table  */ 
  167. /*                                            or the boot sector          */ 
  168. /*    partition                             Desired partition             */ 
  169. /*    partition_sector_offset               Pointer to destination for    */ 
  170. /*                                            returning the sector offset */ 
  171. /*                                            table                       */ 
  172. /*                                                                        */ 
  173. /*  OUTPUT                                                                */ 
  174. /*                                                                        */ 
  175. /*    return status                                                       */ 
  176. /*                                                                        */ 
  177. /*  CALLS                                                                 */ 
  178. /*                                                                        */ 
  179. /*     _fx_utility_partition_get            Actual partition parsing      */ 
  180. /*                                            routine                     */ 
  181. /*                                                                        */ 
  182. /*  CALLED BY                                                             */ 
  183. /*                                                                        */ 
  184. /*    Application Driver                                                  */ 
  185. /*                                                                        */ 
  186. /*  RELEASE HISTORY                                                       */ 
  187. /*                                                                        */ 
  188. /*    DATE              NAME                      DESCRIPTION             */ 
  189. /*                                                                        */ 
  190. /*  07-04-2002     Mohammad N. Minhaz       Initial Version 1.0           */ 
  191. /*                                                                        */ 
  192. /**************************************************************************/ 
  193. UINT _fx_partition_offset_calculate( VOID  *part_sector,
  194.                                      UINT   partition,
  195.                                      ULONG *partition_start,
  196.                                      ULONG *partition_size )
  197. {
  198.     
  199.     FX_MEDIA_PART part_tab[4];
  200.     UINT count;
  201.     UCHAR *part_sect;
  203.     part_sect = part_sector;
  204.     count = 0;
  206.     if ((part_sect[510] != 0x55) || (part_sect[511] != 0xAA))
  207.         return FX_NOT_FOUND ; /* not a valid sector to work on */
  209.     if ((part_sect[0] == 0xe9) || ((part_sect[0] == 0xeb) && (part_sect[2] == 0x90)))    
  210.     {  /* a bootable sector */
  211.             *partition_start = 0;
  212.             return FX_SUCCESS;
  213.     }
  214.     
  215.     /* not bootable, look for partition */
  216.     _fx_utility_partition_get(part_tab, &count, 0, part_sect);
  218.     if (partition >= count)
  219.           return FX_NOT_FOUND;
  221.     if ( partition_start != NULL )
  222.     {
  223.         *partition_start = part_tab[partition].fx_media_part_start;
  224.     }
  226.     if ( partition_size != NULL )
  227.     {
  228.         *partition_size  = part_tab[partition].fx_media_part_size;
  229.     }
  231.     return(FX_SUCCESS);
  232. }
  233. #endif