Ignore:
Timestamp:
Mar 26, 2014, 6:44:44 PM (11 years ago)
Author:
alain
Message:

Introducing a major release, to suppoort the tsar_generic_leti platform
and the various (external or internal) peripherals configurations.
The map.xml format has been modified, in order to support the new
vci_iopic componentand a new policy for peripherals initialisation.
The IRQs are nom described in the XICU and IOPIC components
(and not anymore in the processors).
To enforce this major change, the map.xml file signature changed:
The signature value must be: 0xDACE2014

This new release has been tested on the tsar_generic_leti platform
for the following mappings:

  • 4c_4p_sort_leti
  • 4c_4p_sort_leti_ext
  • 4c_4p_transpose_leti
  • 4c_4p_transpose_leti_ext
  • 4c_1p_four_leti_ext
Location:
soft/giet_vm/giet_fat32
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/giet_fat32/fat32.c

    r291 r295  
    1717// 2. This FAT32 library uses a FAT cache whose storage capacity is one
    1818//    sector (512 bytes, or 128 cluster indexes in FAT)
    19 // 3. This FAT32 library can be used in three modes: BOOT/KERNEL/USER
    20 //    defining three different behaviours for the IOC driver.
     19// 3. This FAT32 library can be used in four modes: BOOT_PA/BOOT_VA/KERNEL/USER
     20//    defining different behaviours for the IOC driver.
    2121//////////////////////////////////////////////////////////////////////////////////
    2222
    … …  
    4646    temp[8] = 0;
    4747
    48     _tty_get_lock( 0 );
    49     _puts("\n*********************** fat_cache_lba = ");
    50     _putx( fat.cache_lba );
    51     _puts(" **************************\n");
     48    _printf("\n*********************** fat_cache_lba = %x *****************************\n",
     49            fat.cache_lba );
    5250
    5351    for ( line=0 ; line<16 ; line++ )
    5452    {
    5553        // display address
    56         _putx( (fat.cache_lba<<9) + (line<<5) );
    57         _puts(" : ");
     54        _printf( "%x : ", (fat.cache_lba<<9) + (line<<5) );
    5855
    5956        // display data hexa
    … …  
    6562                                 (fat.fat_cache[byte+2]<< 8) |
    6663                                 (fat.fat_cache[byte+3]);
    67             _putx( hexa );
    68             _puts(" | ");
     64            _printf("%x | ", hexa );
    6965
    7066            // prepare display ascii
    … …  
    7672       
    7773        // display data ascii
    78         _puts( (char*)temp );
    79         _puts("\n");
    80     }
    81     _puts("***************************************************************************\n");
    82     _tty_release_lock( 0 );
     74        _printf( (char*)temp );
     75        _printf("\n");
     76    }
     77    _printf("**************************************************************************\n");
    8378} // end display_fat_cache() 
    8479#endif
    … …  
    202197       
    203198        // access fat
    204         if( _ioc_read( mode,              // mode for IOC driver
     199        if( _ioc_read( 0,                 // channel
     200                       mode,              // mode for IOC driver
    205201                       lba,               // sector index
    206202                       fat.fat_cache,     // fat cache
    207203                       1 ) )              // one sector
    208204        {
    209             _tty_get_lock( 0 );
    210             _puts("[FAT_ERROR] in get_next cluster_id() cannot read block ");
    211             _putd( lba );
    212             _puts("\n");
    213             _tty_release_lock( 0 );
     205            _printf("[FAT_ERROR] in get_next cluster_id() "
     206                    "cannot read block %x\n", lba );
    214207            return 1;
    215208        }
    … …  
    271264
    272265#if GIET_DEBUG_FAT
    273 _tty_get_lock( 0 );
    274 _puts("\n[FAT DEBUG] filename ");
    275 _puts( string );
    276 _tty_release_lock( 0 );
     266_printf("\n[FAT DEBUG] filename %s", string );
    277267#endif
    278268
    … …  
    282272
    283273#if GIET_DEBUG_FAT
    284 _tty_get_lock( 0 );
    285 _puts(" converted to 8.3 SFN format : ");
    286 _puts( sfn_string );
    287 _puts("\n");
    288 _tty_release_lock( 0 );
     274_printf(" converted to 8.3 SFN format : %s\n", sfn_string );
    289275#endif
    290276
    … …  
    298284
    299285#if GIET_DEBUG_FAT
    300 _tty_get_lock( 0 );
    301 _puts(" converted to 8.3 SFN format : ");
    302 _puts( string );
    303 _puts("\n");
    304 _tty_release_lock( 0 );
     286_printf(" converted to 8.3 SFN format : %s\n", sfn_string );
    305287#endif
    306288
    … …  
    358340
    359341#if GIET_DEBUG_FAT
    360 _tty_get_lock( 0 );
    361 _puts(" converted to 8.3 SFN format : ");
    362 _puts( sfn_string );
    363 _puts("\n");
    364 _tty_release_lock( 0 );
     342_printf(" converted to 8.3 SFN format : %s\n", sfn_string );
    365343#endif
    366344
    … …  
    524502    is_sfn = is_short( file_name, sfn );
    525503
    526     if ( _ioc_read( IOC_KERNEL_MODE, // mode for IOC driver
     504    if ( _ioc_read( 0,               // channel
     505                    IOC_KERNEL_MODE, // mode for IOC driver
    527506                    lba,             // sector index
    528507                    fat.fat_cache,   // buffer address
    529508                    1 ) )            // one sector
    530509    {
    531         _tty_get_lock( 0 );
    532         _puts("[FAT ERROR] in update_entry() cannot read sector ");
    533         _putd( lba );
    534         _puts("\n");
    535         _tty_release_lock( 0 );
     510        _printf("[FAT ERROR] in update_entry() cannot read sector %x\n", lba );
    536511        return 1;
    537512    }
    … …  
    562537            else if (ord == NO_MORE_ENTRY )            // end of directory : return
    563538            {
    564                 _tty_get_lock( 0 );
    565                 _puts("[FAT ERROR] in update_entry() end of directory reaches ");
    566                 _puts("\n");
    567                 _tty_release_lock( 0 );
     539                _printf("[FAT ERROR] in update_entry() : reaches end of directory\n");
    568540                return 1;
    569541            }
    … …  
    591563            else if (ord == NO_MORE_ENTRY )                        // end of directory : return
    592564            {
    593                 _tty_get_lock( 0 );
    594                 _puts("[FAT ERROR] in update_entry() end of directory reaches ");
    595                 _puts("\n");
    596                 _tty_release_lock( 0 );
     565                _printf("[FAT ERROR] in update_entry() reaches end of directory\n");
    597566                return 1;
    598567            }
    … …  
    643612    }
    644613
    645     return _ioc_write( IOC_KERNEL_MODE,
    646                        lba, 
    647                        fat.fat_cache,
    648                        1     );
    649 }
    650 //////////////////////////////////////////////////////////////////////////////////
    651 // This function update FS_INFO, for new last cluster allocated and number of free
    652 // cluster.
     614    return _ioc_write( 0,                // channel
     615                       IOC_KERNEL_MODE,  // mode
     616                       lba,              // sector index
     617                       fat.fat_cache,    // source buffer
     618                       1 );              // one sector
     619}
     620//////////////////////////////////////////////////////////////////////////////////
     621// This function update FS_INFO:
     622// last cluster allocated and number of free cluster.
    653623// Return 0 in case of success, > 0 if failure.
    654624//////////////////////////////////////////////////////////////////////////////////
    … …  
    658628
    659629#if GIET_DEBUG_FAT
    660 _tty_get_lock( 0 );
    661 _puts("\n[FAT DEBUG] Enter in update_fs_info()\n");
    662 _tty_release_lock( 0 );
     630_printf("\n[FAT DEBUG] Enter update_fs_info()\n");
    663631#endif
    664632
    … …  
    670638    else                                   // miss cache
    671639    {
    672         if ( _ioc_read( IOC_KERNEL_MODE,   // mode for IOC driver
     640        if ( _ioc_read( 0,                 // channel
     641                        IOC_KERNEL_MODE,   // mode for IOC driver
    673642                        lba,               // sector index
    674                         fat.fat_cache,     // fat cache
     643                        fat.fat_cache,     // source buffer
    675644                        1 ) )              // one sector
    676645        {
    677             _tty_get_lock( 0 );
    678             _puts("[FAT_ERROR] in update_fat() cannot read block ");
    679             _putd( lba );
    680             _puts("\n");
    681             _tty_release_lock( 0 );
     646            _printf("[FAT_ERROR] in update_fat() cannot read block %x\n", lba );
    682647            return 1;
    683648        }
    … …  
    686651        write_entry( FS_FREE_CLUSTER_HINT, fat.fat_cache, fat.last_cluster_allocated );
    687652    }
    688     return _ioc_write( IOC_KERNEL_MODE,       
    689                        lba,           
    690                        fat.fat_cache,           
    691                        1 );
     653    return _ioc_write( 0,                // channel
     654                       IOC_KERNEL_MODE,  // mode   
     655                       lba,              // sector index
     656                       fat.fat_cache,    // source buffer
     657                       1 );              // one sector
    692658}
    693659
    … …  
    703669
    704670#if GIET_DEBUG_FAT
    705 _tty_get_lock( 0 );
    706 _puts("\n[FAT DEBUG] Enter in update_fat() :\n");
    707 _puts("    - Cluster to update = ");
    708 _putd( cluster );
    709 _puts("\n");
    710 _puts("    - Value to write = ");
    711 _putd( value );
    712 _puts("\n");
    713 _tty_release_lock( 0 );
     671_printf("\n[FAT DEBUG] Enter update_fat() : cluster = %x / value = %x\n",
     672        cluster, value );
    714673#endif
    715674
    … …  
    720679    else                                   // miss cache
    721680    {
    722         if ( _ioc_read( IOC_KERNEL_MODE,   // mode for IOC driver
     681        if ( _ioc_read( 0,                 // channel
     682                        IOC_KERNEL_MODE,   // mode for IOC driver
    723683                        lba,               // sector index
    724                         fat.fat_cache,     // fat cache
     684                        fat.fat_cache,     // source buffer
    725685                        1 ) )              // one sector
    726686        {
    727             _tty_get_lock( 0 );
    728             _puts("[FAT_ERROR] in update_fat() cannot read block ");
    729             _putd( lba );
    730             _puts("\n");
    731             _tty_release_lock( 0 );
     687            _printf("[FAT_ERROR] in update_fat() cannot read block %x\n");
    732688            return 1;
    733689        }
    … …  
    735691        write_entry( ((cluster % 128) << 2), 4, fat.fat_cache, value );
    736692    }
    737     return _ioc_write( IOC_KERNEL_MODE,       
    738                        lba,           
    739                        fat.fat_cache,           
    740                        1 );
     693    return _ioc_write( 0,                // channel
     694                       IOC_KERNEL_MODE,  // mode     
     695                       lba,              // sector indexs
     696                       fat.fat_cache,    // source buffer
     697                       1 );              // one sector
    741698}
    742699
    … …  
    759716    if ( get_next_cluster_id( IOC_KERNEL_MODE, free_cluster ) != FREE_CLUSTER)
    760717    {
    761         _tty_get_lock( 0 );
    762         _puts("\n[FAT ERROR] in _fat_allocate() : first free_cluster isnt free\n");
    763         _tty_release_lock( 0 );
     718        _printf("\n[FAT ERROR] in _fat_allocate() : first free_cluster not free\n");
    764719        return -1;
    765720    }
    … …  
    767722    if ( count > fat.number_free_cluster )
    768723    {
    769         _tty_get_lock( 0 );
    770         _puts("\n[FAT ERROR] in _fat_allocate() : Not enough free cluster(s) for this allocation\n");
    771         _tty_release_lock( 0 );
     724        _printf("\n[FAT ERROR] in _fat_allocate() : Not enough free cluster(s)\n");
    772725        return -1;
    773726    }
    774727
    775728#if GIET_DEBUG_FAT
    776 _tty_get_lock( 0 );
    777 _puts("\n[FAT DEBUG] Enter in _fat_allocate() :\n");
    778 _puts("    - Need to allocate ");
    779 _putd( count );
    780 _puts(" cluster(s) for file ");
    781 _putd( fd_id );
    782 _puts("\n");
    783 _tty_release_lock( 0 );
     729_printf("\n[FAT DEBUG] Enter in _fat_allocate() for file %d\n", fd_id );
    784730#endif
    785731
    … …  
    795741
    796742#if GIET_DEBUG_FAT
    797 _tty_get_lock( 0 );
    798 _puts("\n[FAT DEBUG] Cluster to update is : ");
    799 _putd( last_cluster_file );
    800 _puts("\n");
    801 _puts("[FAT DEBUG] Free cluster is : ");
    802 _putd( free_cluster );
    803 _puts("\n");
    804 _puts("[FAT DEBUG] Number of cluster need to be allocated : ");
    805 _putd( cluster_to_allocate );
    806 _puts("\n");
    807 _tty_release_lock( 0 );
     743_printf("\n[FAT DEBUG] cluster to update = %x / free cluster = %x / clusters required = %d\n",
     744        last_cluster_file, free_cluster, cluster_to_allocate );
    808745#endif
    809746
    … …  
    812749        if ( update_fat( last_cluster_file, free_cluster ) )
    813750        {
    814             _tty_get_lock( 0 );
    815             _puts("\n[FAT ERROR] in _fat_allocate() : update fat for file ");
    816             _putd( fd_id );
    817             _puts(" failed\n");
    818             _tty_release_lock( 0 );
     751            _printf("\n[FAT ERROR] in _fat_allocate() : update fat failed\n");
    819752            return -1;
    820753        }
    … …  
    831764            if ( update_fat( last_cluster_file, END_OF_CHAIN_CLUSTER ) )
    832765            {
    833                 _tty_get_lock( 0 );
    834                 _puts("\n[FAT ERROR] in _fat_allocate() : update fat for file ");
    835                 _putd( fd_id );
    836                 _puts(" failed\n");
    837                 _tty_release_lock( 0 );
     766                _printf("\n[FAT ERROR] in _fat_allocate() : update fat failed\n");
    838767                return -1;
    839768            }
    … …  
    845774        if ( get_next_cluster_id( IOC_KERNEL_MODE, free_cluster ) != FREE_CLUSTER)
    846775        {
    847             _tty_get_lock( 0 );
    848             _puts("\n[FAT ERROR] in _fat_allocate() : free_cluster isnt free\n");
    849             _tty_release_lock( 0 );
     776            _printf("\n[FAT ERROR] in _fat_allocate() : free_cluster not free\n");
    850777            return -1;
    851778        }
    … …  
    859786    if ( update_fs_info() )
    860787    {
    861         _tty_get_lock( 0 );
    862         _puts("\n[FAT ERROR] in _fat_allocate() : update fs_info for file ");
    863         _putd( fd_id );
    864         _puts(" failed\n");
    865         _tty_release_lock( 0 );
     788        _printf("\n[FAT ERROR] in _fat_allocate() : update fs_info failed\n");
    866789        return -1;
    867790    }
    … …  
    895818
    896819#if GIET_DEBUG_FAT
    897 _tty_get_lock( 0 );
    898 _puts("\n[FAT DEBUG] enter _scan_directory() searching dir/file : ");
    899 _puts( file_name );
    900 _puts("\n");
    901 _tty_release_lock( 0 );
     820_printf("\n[FAT DEBUG] enter _scan_directory() searching dir/file %s", filename );
    902821#endif
    903822
    … …  
    920839    // load first cluster sector from DATA region into FAT cache
    921840    // other sectors will be loaded inside loop as required
    922     if( _ioc_read( mode,            // mode for IOC driver
     841    if( _ioc_read( 0,               // channel
     842                   mode,            // mode for IOC driver
    923843                   lba,             // sector index
    924844                   fat.fat_cache,   // buffer address
    925845                   1 ) )            // one sector
    926846    {
    927         _tty_get_lock( 0 );
    928         _puts("[FAT ERROR] in scan directory() cannot read sector ");
    929         _putd( lba );
    930         _puts("\n");
    931         _tty_release_lock( 0 );
     847        _printf("[FAT ERROR] in scan directory() cannot read sector %x\n", lba );
    932848        return -1;
    933849    }
    … …  
    935851    fat.cache_lba = lba;
    936852
    937     #if GIET_DEBUG_FAT
    938     display_fat_cache();
    939     #endif
     853#if GIET_DEBUG_FAT
     854display_fat_cache();
     855#endif
    940856
    941857    // in this loop we scan all names in directory identified by cluster:
    … …  
    961877                block_id = fat.sectors_per_cluster;
    962878            }
    963             if( _ioc_read( mode,            // mode for IOC driver
     879            if( _ioc_read( 0,               // channel
     880                           mode,            // mode for IOC driver
    964881                           lba,             // sector index
    965882                           fat.fat_cache,   // buffer address
    966883                           1 ) )            // one sector
    967884            {
    968                 _tty_get_lock( 0 );
    969                 _puts("[FAT ERROR] in scan directory() cannot read sector ");
    970                 _putd( lba );
    971                 _puts("\n");
    972                 _tty_release_lock( 0 );
     885                _printf("[FAT ERROR] in scan directory() cannot read sector %x\n", lba );
    973886                return -1;
    974887            }
    … …  
    1072985            *lba_dir_entry = lba;
    1073986
    1074 #if GIET_DEBUG_FAT
    1075 _tty_get_lock( 0 );
    1076 _puts("\n[FAT DEBUG] FILE FOUND\n");
    1077 _tty_release_lock( 0 );
    1078 #endif
    1079987            return read_cluster( dir_entry );
    1080988        }
    … …  
    10941002                       unsigned int    dir_cluster )
    10951003{
    1096     _tty_get_lock( 0 );
    1097     _puts("\n[FAT ERROR] _fat_create() not implemented\n");
    1098     _tty_release_lock( 0 );
     1004    _printf("\n[FAT ERROR] _fat_create() not implemented\n");
    10991005    return 0;
    11001006}  //end _fat_create()
    … …  
    11151021
    11161022#if GIET_DEBUG_FAT
    1117 _tty_get_lock( 0 );
    1118 _puts("\n[FAT DEBUG] Enter _fat_init() / fat_cache_base = ");
    1119 _putx( (unsigned int)fat.fat_cache );
    1120 _puts("\n");
    1121 _tty_release_lock( 0 );
     1023unsigned int procid  = _get_procid();
     1024unsigned int cid     = procid / NB_PROCS_MAX;
     1025unsigned int lpid    = procid % NB_PROCS_MAX;
     1026unsigned int x       = cid >> Y_WIDTH;
     1027unsigned int y       = cid & ((1<<Y_WIDTH) - 1);
     1028
     1029_printf("\n[FAT DEBUG] Processor[%d,%d,%d] enters _fat_init()\n",
     1030        x, y, lpid );
    11221031#endif
    11231032
    11241033    // load Master Boot Record (sector 0) into fat cache
    1125     if ( _ioc_read( mode,             // mode for IOC driver
     1034    if ( _ioc_read( 0,                // channel
     1035                    mode,             // mode for IOC driver
    11261036                    0,                // sector index
    11271037                    fat.fat_cache,    // buffer address
    11281038                    1 ) )             // one sector
    11291039    {
    1130         _tty_get_lock( 0 );
    1131         _puts("\n[FAT ERROR] in _fat_init() cannot load Boot Sector\n");
    1132         _tty_release_lock( 0 );
     1040        _printf("\n[FAT ERROR] in _fat_init() cannot load Boot Sector\n");
    11331041        return -1;
    11341042    }
    11351043    fat.cache_lba = 0;
    11361044   
     1045#if GIET_DEBUG_FAT
     1046display_fat_cache();
     1047#endif
     1048
    11371049    // checking Boot sector integrity
    11381050    if( MBR_SIGNATURE_VALUE != read_entry( MBR_SIGNATURE_POSITION, fat.fat_cache, 1))
    11391051    {
    1140         _tty_get_lock( 0 );
    1141         _puts("\n[FAT ERROR] Boot sector not recognized or corrupt \n");
    1142         _tty_release_lock( 0 );
     1052        _printf("\n[FAT ERROR] Boot sector not recognized or corrupt \n");
    11431053        return -1; 
    11441054    }
    11451055
    11461056#if GIET_DEBUG_FAT
    1147 _tty_get_lock( 0 );
    1148 _puts("\n[FAT DEBUG] Boot Sector Loaded\n");
    1149 _tty_release_lock( 0 );
     1057_printf("\n[FAT DEBUG] Boot Sector Loaded\n");
    11501058#endif
    11511059
    … …  
    11551063
    11561064    // load Partition Boot Record (first partition sector) into fat cache
    1157     if ( _ioc_read( mode,                // mode for IOC driver
     1065    if ( _ioc_read( 0,                   // channel
     1066                    mode,                // mode for IOC driver
    11581067                    fat.partition_lba,   // sector index
    11591068                    fat.fat_cache,       // buffer address
    11601069                    1 ) )                // one sector
    11611070    {
    1162         _tty_get_lock( 0 );
    1163         _puts("\n[FAT ERROR] in _fat_init() cannot load block ");
    1164         _putd( fat.partition_lba );
    1165         _puts("\n");
    1166         _tty_release_lock( 0 );
     1071        _printf("\n[FAT ERROR] in _fat_init() cannot load block %x\n", fat.partition_lba );
    11671072        return -1;
    11681073    }
    … …  
    11701075
    11711076#if GIET_DEBUG_FAT
    1172 _tty_get_lock( 0 );
    1173 _puts("\n[FAT DEBUG] Partition First Sector Loaded\n");
    1174 _tty_release_lock( 0 );
     1077_printf("\n[FAT DEBUG] Partition First Sector Loaded\n");
    11751078#endif
    11761079
    … …  
    11791082    if( read_entry( BPB_BYTSPERSEC, fat.fat_cache, 1 ) != 512 )
    11801083    {
    1181         _tty_get_lock( 0 );
    1182         _puts("\n[FAT ERROR] The sector size must be 512 bytes\n");
    1183         _tty_release_lock( 0 );
     1084        _printf("\n[FAT ERROR] The sector size must be 512 bytes\n");
    11841085        return -1; 
    11851086    }
    11861087    if( read_entry( BPB_RSVDSECCNT, fat.fat_cache, 1 ) != 32 )
    11871088    {
    1188         _tty_get_lock( 0 );
    1189         _puts("\n[FAT ERROR] The RSVD region in FAT32 must be 32 sectors\n");
    1190         _tty_release_lock( 0 );
     1089        _printf("\n[FAT ERROR] The RSVD region in FAT32 must be 32 sectors\n");
    11911090        return -1; 
    11921091    }
    11931092    if( read_entry( BPB_NUMFATS, fat.fat_cache, 1 ) != 1 )
    11941093    {
    1195         _tty_get_lock( 0 );
    1196         _puts("\n[FAT ERROR] The number of FAT copies in FAT region must be 1\n");
    1197         _tty_release_lock( 0 );
     1094        _printf("\n[FAT ERROR] The number of FAT copies in FAT region must be 1\n");
    11981095        return -1; 
    11991096    }
    12001097    if( (read_entry( BPB_FAT32_FATSZ32, fat.fat_cache, 1 ) & 0xF) != 0 )
    12011098    {
    1202         _tty_get_lock( 0 );
    1203         _puts("\n[FAT ERROR] The FAT region in FAT32 must be multiple of 32 sectors\n");
    1204         _tty_release_lock( 0 );
     1099        _printf("\n[FAT ERROR] The FAT region in FAT32 must be multiple of 32 sectors\n");
    12051100        return -1; 
    12061101    }
    1207 
    12081102    if( read_entry( BPB_FAT32_ROOTCLUS, fat.fat_cache, 1 ) != 2 )
    12091103    {
    1210         _tty_get_lock( 0 );
    1211         _puts("\n[FAT ERROR] The first cluster index must be 2\n");
    1212         _tty_release_lock( 0 );
     1104        _printf("\n[FAT ERROR] The first cluster index must be 2\n");
    12131105        return -1; 
    12141106    }
    … …  
    12271119
    12281120#if GIET_DEBUG_FAT
    1229 _tty_get_lock( 0 );
    1230 _puts("\n[FAT DEBUG] FS_INFO Sector = ");
    1231 _putd(fat.fs_info_lba);
    1232 _puts("\n");
    1233 _tty_release_lock( 0 );
     1121_printf("\n[FAT DEBUG] FS_INFO Sector = %x\n", fat.fs_info_lba );
    12341122#endif
    12351123
    12361124    // load FS_INFO into fat cache
    1237     if ( _ioc_read( mode,               // mode for IOC driver
     1125    if ( _ioc_read( 0,                  // channel
     1126                    mode,               // mode for IOC driver
    12381127                    fat.fs_info_lba,    // sector index
    12391128                    fat.fat_cache,      // buffer address
    12401129                    1 ) )               // one sector
    12411130    {
    1242         _tty_get_lock( 0 );
    1243         _puts("\n[FAT ERROR] in _fat_init() cannot load FS_INFO Sector\n");
    1244         _tty_release_lock( 0 );
     1131        _printf("\n[FAT ERROR] in _fat_init() cannot load FS_INFO Sector\n");
    12451132        return -1;
    12461133    }
    … …  
    12511138
    12521139#if GIET_DEBUG_FAT
    1253 _tty_get_lock( 0 );
    1254 _puts("\n[FAT DEBUG] Number of Free Clusters = ");
    1255 _putd(fat.number_free_cluster);
    1256 _puts("\n");
    1257 _puts("\n[FAT DEBUG] Last known cluster allocated = ");
    1258 _putd(fat.last_cluster_allocated);
    1259 _puts("\n");
    1260 _puts("\n[FAT DEBUG] FS_INFO Sector Loaded\n");
    1261 _tty_release_lock( 0 );
    1262 #endif
    1263 
    1264 
    1265 #if GIET_DEBUG_FAT
    1266 _tty_get_lock( 0 );
    1267 _puts("\n[FAT DEBUG] Exit _fat_init()\n");
    1268 _tty_release_lock( 0 );
     1140_printf("\n[FAT DEBUG] Processor[%d,%d,%d] exit _fat_init() / "
     1141        "free clusters = %x / last allocated cluster = %x\n",
     1142        fat.number_free_cluster, fat.last_cluster_allocated );
    12691143#endif
    12701144
    … …  
    12751149void _fat_print()
    12761150{
    1277     _puts("\n################################ FAT32 ###############################"); 
    1278     _puts("\nFAT initialised                "); _putx( fat.initialised );
    1279     _puts("\nSector Size  (bytes)           "); _putx( fat.sector_size );
    1280     _puts("\nSectors per cluster            "); _putx( fat.sectors_per_cluster );
    1281     _puts("\nPartition size (sectors)       "); _putx( fat.partition_sectors );
    1282     _puts("\nPartition first lba            "); _putx( fat.partition_lba );
    1283     _puts("\nData region first lba          "); _putx( fat.data_lba );
    1284     _puts("\nNumber of sectors for one FAT  "); _putx( fat.fat_sectors );
    1285     _puts("\n######################################################################\n");
     1151    _printf("\n########################## FAT32 ###########################"); 
     1152    _printf("\nFAT initialised                %d", fat.initialised );
     1153    _printf("\nSector Size  (bytes)           %x", fat.sector_size );
     1154    _printf("\nSectors per cluster            %x", fat.sectors_per_cluster );
     1155    _printf("\nPartition size (sectors)       %x", fat.partition_sectors );
     1156    _printf("\nPartition first lba            %x", fat.partition_lba );
     1157    _printf("\nData region first lba          %x", fat.data_lba );
     1158    _printf("\nNumber of sectors for one FAT  %x", fat.fat_sectors );
     1159    _printf("\n############################################################\n");
    12861160}
    12871161
    … …  
    12941168// a new file is created and introduced in the directory.
    12951169// Finally, it sets a new open file in the file descriptors array.
     1170// The same file can be open several times by differents taks.
    12961171///////////////////////////////////////////////////////////////////////////////
    12971172// Returns file descriptor index if success, returns -1 if error.
    … …  
    13111186   
    13121187#if GIET_DEBUG_FAT
    1313 _tty_get_lock( 0 );
    1314 _puts("\n[FAT DEBUG] enter _fat_open() for file ");
    1315 _puts( pathname );
    1316 _puts("\n");
    1317 _tty_release_lock( 0 );
    1318 #endif
    1319 
    1320     // check FAT initialised
     1188unsigned int procid  = _get_procid();
     1189unsigned int cid     = procid / NB_PROCS_MAX;
     1190unsigned int lpid    = procid % NB_PROCS_MAX;
     1191unsigned int x       = cid >> Y_WIDTH;
     1192unsigned int y       = cid & ((1<<Y_WIDTH) - 1);
     1193
     1194_printf("\n[FAT DEBUG] Processor[%d,%d,%d] enters _fat_open() for file %s\n",
     1195        x, y, lpid, pathname );
     1196#endif
     1197
     1198    // checking arguments
     1199    if ( creat )
     1200    {
     1201        _printf("[FAT ERROR] in _fat_open() : create not supported yet\n");
     1202        return -1;
     1203    }
     1204
     1205    // takes the FAT lock for exclusive access
     1206    _get_lock( &fat.lock );
     1207
     1208#if GIET_DEBUG_FAT
     1209_printf("\n[FAT DEBUG] Processor[%d,%d,%d] takes the FAT lock\n",
     1210        x, y, lpid );
     1211#endif
     1212
     1213    // FAT initialisation if required
    13211214    if( fat.initialised != FAT_INITIALISED )
    13221215    {
    13231216        if ( _fat_init( mode ) )
    13241217        {
    1325             _puts("[FAT ERROR] Cannot initialize FAT descriptor from Boot Sector\n");
    1326             _exit();
    1327         }
    1328 
    1329 #if GIET_DEBUG_FAT
    1330 _tty_get_lock( 0 );
    1331 _puts("\n[FAT DEBUG] FAT initialisation completed at cycle ");
    1332 _putd(_get_proctime());
    1333 _puts("\n");
     1218            _printf("[FAT ERROR] in _fat_open() : Cannot initialize FAT descriptor\n");
     1219
     1220            // release FAT lock
     1221            _release_lock( &fat.lock );
     1222
     1223            return -1;
     1224        }
     1225
     1226#if GIET_DEBUG_FAT
     1227_printf("\n[FAT DEBUG] Processor[%d,%d,%d] initialises FAT descriptor\n",
     1228        x, y, lpid );
    13341229_fat_print();
    1335 _tty_release_lock( 0 );
    1336 #endif
     1230#endif
     1231
    13371232    }
    13381233 
    … …  
    13501245
    13511246#if GIET_DEBUG_FAT
    1352 _tty_get_lock( 0 );
    1353 _puts("\n[FAT DEBUG] _fat_open : search dir/file : ");
    1354 _puts( name );
    1355 _puts("\n");
    1356 _tty_release_lock( 0 );
     1247_printf("\n[FAT DEBUG] Processor[%d,%d,%d] search dir/file : %s\n",
     1248        x, y, lpid, name );
    13571249#endif
    13581250
    … …  
    13731265        else if ( cluster == END_OF_CHAIN_CLUSTER )
    13741266        {
    1375             _tty_get_lock( 0 );
    1376             _puts("\n[FAT ERROR] in _fat_open() for file ");
    1377             _puts( pathname );
    1378             _puts(" : cannot found name ");
    1379             _puts( name );
    1380             _puts("\n");
    1381             _tty_release_lock( 0 );
     1267            _printf("\n[FAT ERROR] in _fat_open() cannot found %s\n", name );
     1268
     1269            // release FAT lock
     1270            _release_lock( &fat.lock );
     1271
    13821272            return -1;
    13831273        }
    13841274    }
    1385 
    1386 #if GIET_DEBUG_FAT
    1387 _tty_get_lock( 0 );
    1388 _puts("\n[FAT DEBUG] File ");
    1389 _puts( pathname );
    1390 _puts(" found\n");
    1391 _tty_release_lock( 0 );
    1392 #endif
    13931275
    13941276    // check the next value for cluster index found
    … …  
    14141296
    14151297#if GIET_DEBUG_FAT
    1416 _tty_get_lock( 0 );
    1417 _puts("\n[FAT DEBUG] file  ");
    1418 _puts( pathname );
    1419 _puts(" open with fd_id = ");
    1420 _putd( fd_id );
    1421 _puts("\n");
    1422 _tty_release_lock( 0 );
    1423 #endif
     1298_printf("\n[FAT DEBUG] Processor[%d,%d,%d] open file %s with fd = %d\n",
     1299        x, y, lpid, pathname, fd_id );
     1300#endif
     1301
     1302            // release FAT lock
     1303            _release_lock( &fat.lock );
    14241304
    14251305            return fd_id;
    … …  
    14271307        else
    14281308        {
    1429             _tty_get_lock( 0 );
    1430             _puts("\n[FAT ERROR] in _fat_open() for file ");
    1431             _puts( pathname );
    1432             _puts(" : file descriptor array full\n ");
    1433             _tty_release_lock( 0 );
     1309            _printf("\n[FAT ERROR] in _fat_open() for file %s : fd array full\n",
     1310                    pathname );
     1311
     1312            // release FAT lock
     1313            _release_lock( &fat.lock );
     1314
    14341315            return -1;
    14351316        }
    … …  
    14371318    else
    14381319    {
    1439         _tty_get_lock( 0 );
    1440         _puts("\n[FAT ERROR] in _fat_open() for file ");
    1441         _puts( pathname );
    1442         _puts(" : file found, but bad cluster\n");
    1443         _tty_release_lock( 0 );
     1320        _printf("\n[FAT ERROR] in _fat_open() for file %s : bad cluster\n",
     1321                pathname );
     1322
     1323        // release FAT lock
     1324        _release_lock( &fat.lock );
     1325
    14441326        return -1;
    14451327    }
    … …  
    14611343
    14621344#if GIET_DEBUG_FAT
    1463 _tty_get_lock( 0 );
    1464 _puts("\n[FAT DEBUG] Enter _fat_read() for file ");
    1465 _puts( fat.fd[fd_id].name );
    1466 _puts("\n - buffer base     = ");
    1467 _putx( (unsigned int)buffer );
    1468 _puts("\n - skipped sectors = ");
    1469 _putd( offset );
    1470 _puts("\n - read sectors    = ");
    1471 _putd( count );
    1472 _tty_release_lock( 0 );
     1345unsigned int procid  = _get_procid();
     1346unsigned int cid     = procid / NB_PROCS_MAX;
     1347unsigned int lpid    = procid % NB_PROCS_MAX;
     1348unsigned int x       = cid >> Y_WIDTH;
     1349unsigned int y       = cid & ((1<<Y_WIDTH) - 1);
     1350
     1351_printf("\n[FAT DEBUG] Processor[%d,%d,%d] enters _fat_read() for file %s\n",
     1352        " - buffer vbase    = %x\n"
     1353        " - skipped sectors = %x\n"
     1354        " - read sectors    = %x\n",
     1355        x, y, lpid, fat.fd[fd_id].name, (unsigned int)buffer, offset, count );
    14731356#endif
    14741357
    … …  
    14901373    if ( fd_id >= GIET_OPEN_FILES_MAX )
    14911374    {
    1492         _tty_get_lock( 0 );
    1493         _puts("\n[FAT ERROR] in _fat_read() : illegal file descriptor index\n");
    1494         _tty_release_lock( 0 );
     1375        _printf("\n[FAT ERROR] in _fat_read() : illegal file descriptor index\n");
    14951376        return -1;
    14961377    }
    14971378    if ( fat.fd[fd_id].used != 1 )
    14981379    {
    1499         _tty_get_lock( 0 );
    1500         _puts("\n[FAT ERROR] in _fat_read() : file not open\n");
    1501         _tty_release_lock( 0 );
     1380        _printf("\n[FAT ERROR] in _fat_read() : file not open\n");
    15021381        return -1;
    15031382    }
    15041383    if ( ((unsigned int)buffer & 0x1FF) != 0 )
    15051384    {
    1506         _tty_get_lock( 0 );
    1507         _puts("\n[FAT ERROR] in _fat_read() : memory buffer not sector aligned\n");
    1508         _tty_release_lock( 0 );
     1385        _printf("\n[FAT ERROR] in _fat_read() : memory buffer not sector aligned\n");
    15091386        return -1;
    15101387    }
    15111388    if ( offset >= file_sectors )
    15121389    {
    1513         _tty_get_lock( 0 );
    1514         _puts("\n[FAT ERROR] offset larger than number of sectors in file\n");
    1515         _puts(" - offset       = ");
    1516         _putd( offset );
    1517         _puts(" - file_sectors = ");
    1518         _putd( file_sectors );
    1519         _tty_release_lock( 0 );
     1390        _printf("\n[FAT ERROR] offset larger than number of sectors\n");
    15201391        return -1;
    15211392    }
    … …  
    15331404
    15341405#if GIET_DEBUG_FAT
    1535 _tty_get_lock( 0 );
    1536 _puts("\n - first cluster   = ");
    1537 _putd( cluster );   
    1538 _puts("\n - skiped clusters = ");
    1539 _putd( clusters_to_skip );   
    1540 _puts("\n");
    1541 _tty_release_lock( 0 );
     1406_printf(" - first cluster   = %x\n"
     1407        " - skiped clusters = %x\n",
     1408        cluster, clusters_to_skip );   
    15421409#endif
    15431410
    … …  
    15681435
    15691436#if GIET_DEBUG_FAT
    1570 _tty_get_lock( 0 );
    1571 _puts("\n[FAT DEBUG] _fat_read() IOC request : buf = ");
    1572 _putx( (unsigned int)dst );
    1573 _puts(" / lba = ");
    1574 _putd( lba );
    1575 _puts(" / sectors = ");
    1576 _putd( iter_sectors );
    1577 _puts("\n"); 
    1578 _tty_release_lock( 0 );
    1579 #endif
    1580 
    1581         if( _ioc_read( mode,              // mode for IOC driver
     1437_printf("\n[FAT DEBUG] Processor[%d,%d,%d] makes an IOC read :"
     1438        " buf = %x / lba = %x / sectors = %d\n",
     1439        x, y, lpid, (unsigned int)dst, lba, iter_sectors );
     1440#endif
     1441
     1442        if( _ioc_read( 0,                 // channel
     1443                       mode,              // mode for IOC driver
    15821444                       lba,               // first sector index
    15831445                       dst,               // buffer address
    15841446                       iter_sectors ) )   // number of sectors
    15851447        {
    1586             _tty_get_lock( 0 );
    1587             _puts("\n[FAT ERROR] in _fat_read() cannot load block ");
    1588             _putd( lba );
    1589             _puts("\n");
    1590             _tty_release_lock( 0 );
     1448            _printf("\n[FAT ERROR] in _fat_read() cannot load block %x\n", lba );
    15911449            return -1;
    15921450        }
    … …  
    16531511
    16541512#if GIET_DEBUG_FAT
    1655 _tty_get_lock( 0 );
    1656 _puts("\n[FAT DEBUG] Enter _fat_write() for file ");
    1657 _puts( fat.fd[fd_id].name );
    1658 _puts("\n - buffer base     = ");
    1659 _putx( (unsigned int)buffer );
    1660 _puts("\n - skipped sectors = ");
    1661 _putd( offset );
    1662 _puts("\n - write sectors    = ");
    1663 _putd( count );
    1664 _puts("\n - file size (sectors)  = ");
    1665 _putd( file_sectors );
    1666 _puts("\n - need allocate = ");
    1667  allocate ? _puts( "True" ) : _puts( "False");
    1668 _tty_release_lock( 0 );
     1513unsigned int procid  = _get_procid();
     1514unsigned int cid     = procid / NB_PROCS_MAX;
     1515unsigned int lpid    = procid % NB_PROCS_MAX;
     1516unsigned int x       = cid >> Y_WIDTH;
     1517unsigned int y       = cid & ((1<<Y_WIDTH) - 1);
     1518
     1519_printf("\n[FAT DEBUG] Processor[%d,%d,%d] enters _fat_write() for file %s\n",
     1520        " - buffer vbase    = %x\n"
     1521        " - skipped sectors = %x\n"
     1522        " - write sectors   = %x\n"
     1523        " - file sectors    = %x\n"
     1524        " - need allocate   = %d\n",
     1525        x, y, lpid, fat.fd[fd_id].name, (unsigned int)buffer,
     1526        offset, count, file_sectors, allocate );
    16691527#endif
    16701528
    … …  
    16721530    if ( fd_id >= GIET_OPEN_FILES_MAX )
    16731531    {
    1674         _tty_get_lock( 0 );
    1675         _puts("\n[FAT ERROR] in _fat_write() : illegal file descriptor index\n");
    1676         _tty_release_lock( 0 );
     1532        _printf("\n[FAT ERROR] in _fat_write() : illegal file descriptor index\n");
    16771533        return -1;
    16781534    }
    16791535    if ( fat.fd[fd_id].used != 1 )
    16801536    {
    1681         _tty_get_lock( 0 );
    1682         _puts("\n[FAT ERROR] in _fat_write() : file not open\n");
    1683         _tty_release_lock( 0 );
     1537        _printf("\n[FAT ERROR] in _fat_write() : file not open\n");
    16841538        return -1;
    16851539    }
    16861540    if ( ((unsigned int)buffer & 0x1FF) != 0 )
    16871541    {
    1688         _tty_get_lock( 0 );
    1689         _puts("\n[FAT ERROR] in _fat_write() : memory buffer not sector aligned\n");
    1690         _tty_release_lock( 0 );
     1542        _printf("\n[FAT ERROR] in _fat_write() : memory buffer not sector aligned\n");
    16911543        return -1;
    16921544    }
    … …  
    16961548        if ( _fat_allocate( fd_id, (required_cluster - current_cluster) ) < 0 )
    16971549        {
    1698             _tty_get_lock( 0 );
    1699             _puts("\n[FAT ERROR] in _fat_write() : fat_allocate for file ");
    1700             _putd( fd_id );
    1701             _puts(" failed\n");
    1702             _tty_release_lock( 0 );
     1550            _printf("\n[FAT ERROR] in _fat_write() : fat_allocate failed\n");
    17031551            return -1;
    17041552        }
    … …  
    17131561
    17141562#if GIET_DEBUG_FAT
    1715 _tty_get_lock( 0 );
    1716 _puts("\n - first cluster   = ");
    1717 _putd( cluster );   
    1718 _puts("\n - skiped clusters = ");
    1719 _putd( clusters_to_skip );   
    1720 _puts("\n");
    1721 _tty_release_lock( 0 );
     1563_printf(" - first cluster   = %x\n"
     1564        " - skiped clusters = %x\n",
     1565        cluster, clusters_to_skip );   
    17221566#endif
    17231567
    … …  
    17481592
    17491593#if GIET_DEBUG_FAT
    1750 _tty_get_lock( 0 );
    1751 _puts("\n[FAT DEBUG] _fat_write() IOC request : buf = ");
    1752 _putx( (unsigned int)src );
    1753 _puts(" / lba = ");
    1754 _putd( lba );
    1755 _puts(" / sectors = ");
    1756 _putd( iter_sectors );
    1757 _puts("\n"); 
    1758 _tty_release_lock( 0 );
    1759 #endif
    1760 
    1761         if( _ioc_write( mode,              // mode for IOC driver
     1594_printf("\n[FAT DEBUG] Processor[%d,%d,%d] makes an IOC write : "
     1595        "buf = %x / lba = %x / sectors = %x\n",
     1596        x, y, lpid, (unsigned int)src, lba, iter_sectors );
     1597#endif
     1598
     1599        if( _ioc_write( 0,                 // channel
     1600                        mode,              // mode for IOC driver
    17621601                        lba,               // first sector index
    1763                         src,               // buffer address
     1602                        src,               // source buffer address
    17641603                        iter_sectors ) )   // number of sectors
    17651604        {
    1766             _tty_get_lock( 0 );
    1767             _puts("\n[FAT ERROR] in _fat_write() cannot write block ");
    1768             _putd( lba );
    1769             _puts("\n");
    1770             _tty_release_lock( 0 );
     1605            _printf("\n[FAT ERROR] in _fat_write() cannot write block %x\n", lba );
    17711606            return -1;
    17721607        }
    … …  
    17921627    if ( update_entry(fd_id, DIR_FILE_SIZE, fat.fd[fd_id].file_size) )
    17931628    {
    1794             _tty_get_lock( 0 );
    1795             _puts("\n[FAT ERROR] in _fat_write() update entry for file ");
    1796             _putd( fd_id );
    1797             _puts(" failed\n");
    1798             _tty_release_lock( 0 );
     1629            _printf("\n[FAT ERROR] in _fat_write() update entry failed\n");
    17991630            return -1;
    18001631    }
    … …  
    18261657    else
    18271658    {
    1828         _tty_get_lock( 0 );
    1829         _puts("\n[FAT ERROR] in _fat_fstat() : illegal file descriptor index\n");
    1830         _tty_release_lock( 0 );
     1659        _printf("\n[FAT ERROR] in _fat_fstat() : illegal file descriptor index\n");
    18311660        return -1;
    18321661    }
    … …  
    18471676    else
    18481677    {
    1849         _tty_get_lock( 0 );
    1850         _puts("\n[FAT ERROR] in _fat_close() : illegal file descriptor index\n");
    1851         _tty_release_lock( 0 );
     1678        _printf("\n[FAT ERROR] in _fat_close() : illegal file descriptor index\n");
    18521679        return -1;
    18531680    }
    … …  
    18631690                    unsigned int flags )     // unused: TODO
    18641691{
    1865     return _fat_open( IOC_KERNEL_MODE,       // we KERNEL_MODE, because
     1692    return _fat_open( IOC_KERNEL_MODE,       // we use KERNEL_MODE, because
    18661693                      pathname,              // we need to write into FAT cache
    1867                       0 );       
     1694                      0 );                   // no creation if not found
    18681695}
    18691696
    … …  
    19091736                     unsigned int whence )
    19101737{
    1911     _tty_get_lock( 0 );
    1912     _puts("[GIET ERROR] _fat_user_lseek function not implemented\n");
    1913     _tty_release_lock( 0 );
     1738    _printf("[GIET ERROR] _fat_user_lseek() not implemented\n");
    19141739    _exit();
    19151740    return 0;

  • soft/giet_vm/giet_fat32/fat32.h

    r291 r295  
    143143    unsigned int    cluster_size;            // sector_size * sector_per_cluster (bytes)
    144144    unsigned int    fat_sectors;             // number of sectors occupied by one FAT copy
    145     unsigned int    partition_sectors;       // total number of sectors (RESVD + FAT + DATA)
     145    unsigned int    partition_sectors;       // total number of sectors (RESVD+FAT+DATA)
    146146    unsigned int    partition_lba;           // lba of first partiton sector
    147147    unsigned int    data_lba;                // lba of first data sector 
    … …  
    150150    unsigned int    number_free_cluster;     // number of free clusters
    151151    unsigned int    fs_info_lba;             // lba of fs_info
     152    unsigned int    lock;                    // lock protecting exclusive access
    152153} fat32_fs_t;
    153154/***************************************************************************************/
Note: See TracChangeset for help on using the changeset viewer.