Changeset 443


Ignore:
Timestamp:
Nov 3, 2014, 11:30:32 AM (10 years ago)
Author:
alain
Message:

euh...

File:
1 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/giet_fat32/fat32.c

    r429 r443  
    4141    unsigned int word;
    4242    unsigned int temp[9];
    43     unsigned int save_sr;  // for tty_get_lock()
    44  
    4543
    4644    temp[8] = 0;
    47 
    48     _tty_get_lock( 0, &save_sr );
    4945
    5046    _puts("\n*********************** fat_cache_lba = ");
    … …  
    8177    }
    8278    _puts("***************************************************************************\n");
    83 
    84     _tty_release_lock( 0, &save_sr );
    8579
    8680} // end display_fat_cache() 
    … …  
    197191unsigned int p       = procid & ((1<<P_WIDTH)-1);
    198192
    199 _printf("\n[FAT DEBUG] _get_next_cluster() : P[%d,%d,%d] enters for cluster %x\n",
    200         x, y, p, cluster );
     193_puts("\n[FAT DEBUG] _get_next_cluster() : P[");
     194_putd( x );
     195_puts(",");
     196_putd( y );
     197_puts(",");
     198_putd( p );
     199_puts("] enters for cluster ");
     200_putx( cluster );
     201_puts("\n");
    201202#endif
    202203
    … …  
    213214                       1 ) )              // one sector
    214215        {
    215             _printf("[FAT_ERROR] in get_next cluster_id() "
    216                     "cannot read block %x\n", lba );
     216            _puts("[FAT_ERROR] in get_next cluster_id() : cannot read block ");
     217            _putx( lba );
     218            _puts("\n");
    217219            return 1;
    218220        }
    … …  
    230232
    231233#if GIET_DEBUG_FAT
    232 _printf("\n[FAT DEBUG] _get_next_cluster() : P[%d,%d,%d] next cluster = %x\n",
    233         x, y, p, next );
     234_puts("\n[FAT DEBUG] _get_next_cluster() : P[");
     235_putd( x );
     236_puts(",");
     237_putd( y );
     238_puts(",");
     239_putd( p );
     240_puts("] next cluster = ");
     241_putx( next );
     242_puts("\n");
    234243#endif
    235244
    … …  
    503512                    1 ) )            // one sector
    504513    {
    505         _printf("[FAT ERROR] in update_entry() cannot read sector %x\n", lba );
     514        _puts("[FAT ERROR] in update_entry() cannot read sector ");
     515        _putx( lba );
     516        _puts("\n");
    506517        return 1;
    507518    }
    … …  
    532543            else if (ord == NO_MORE_ENTRY )            // end of directory : return
    533544            {
    534                 _printf("[FAT ERROR] in update_entry() : reaches end of directory\n");
     545                _puts("[FAT ERROR] in update_entry() : reaches end of directory\n");
    535546                return 1;
    536547            }
    … …  
    558569            else if (ord == NO_MORE_ENTRY )                        // end of directory : return
    559570            {
    560                 _printf("[FAT ERROR] in update_entry() reaches end of directory\n");
     571                _puts("[FAT ERROR] in update_entry() reaches end of directory\n");
    561572                return 1;
    562573            }
    … …  
    623634
    624635#if GIET_DEBUG_FAT
    625 _printf("\n[FAT DEBUG] _update_fs_info() : enters\n");
     636_puts("\n[FAT DEBUG] _update_fs_info() : enters\n");
    626637#endif
    627638
    … …  
    639650                        1 ) )              // one sector
    640651        {
    641             _printf("[FAT_ERROR] in _update_fat() cannot read block %x\n", lba );
     652            _puts("[FAT_ERROR] in _update_fat() cannot read block ");
     653            _putx( lba );
     654            _puts("\n");
    642655            return 1;
    643656        }
    … …  
    664677
    665678#if GIET_DEBUG_FAT
    666 _printf("\n[FAT DEBUG] _update_fat() : cluster = %x / value = %x\n",
    667         cluster, value );
     679_puts("\n[FAT DEBUG] _update_fat() : cluster = ");
     680_putx( cluster );
     681_puts(" / value = ");
     682_putx( value );
     683_puts("\n");
    668684#endif
    669685
    … …  
    680696                        1 ) )              // one sector
    681697        {
    682             _printf("[FAT_ERROR] in _update_fat() cannot read block %x\n");
     698            _puts("[FAT_ERROR] in _update_fat() cannot read block %x\n");
    683699            return 1;
    684700        }
    … …  
    694710
    695711//////////////////////////////////////////////////////////////////////////////////
    696 // This function allocate a count number of cluster to a file by calling the
     712// This function allocate count clusters to a file by calling the
    697713// _update_fat function that takes care to update the chaining of clusters.
    698714// return 0 if success, -1 if failure
    … …  
    709725    if ( _get_next_cluster( IOC_KERNEL_MODE, free_cluster ) != FREE_CLUSTER)
    710726    {
    711         _printf("\n[FAT ERROR] in _fat_allocate() : first free_cluster not free\n");
     727        _puts("\n[FAT ERROR] in _fat_allocate() : first free_cluster not free\n");
    712728        return -1;
    713729    }
    … …  
    715731    if ( count > fat.number_free_cluster )
    716732    {
    717         _printf("\n[FAT ERROR] in _fat_allocate() : Not enough free cluster(s)\n");
     733        _puts("\n[FAT ERROR] in _fat_allocate() : Not enough free cluster(s)\n");
    718734        return -1;
    719735    }
    720736
    721737#if GIET_DEBUG_FAT
    722 _printf("\n[FAT DEBUG] _fat_allocate() for file %d\n", fd_id );
     738_puts("\n[FAT DEBUG] _fat_allocate() for fd = ");
     739_putd( fd_id );
     740_puts("\n");
    723741#endif
    724742
    … …  
    729747    }while ( next_cluster < END_OF_CHAIN_CLUSTER );
    730748
    731     // Loop on the number of cluster needed to be allocated
     749    // Loop on the number of clusters to be allocated
    732750    while ( cluster_to_allocate > 0 )
    733751    {
    734752
    735753#if GIET_DEBUG_FAT
    736 _printf("\n[FAT DEBUG] cluster to update = %x / free cluster = %x / clusters required = %d\n",
    737         last_cluster_file, free_cluster, cluster_to_allocate );
     754_puts("\n[FAT DEBUG] cluster to update = ");
     755_putx( last_cluster_file );
     756_puts(" / free cluster = ");
     757_putx( free-cluster );
     758_puts(" / clusters required = ");
     759_putx( cluster_to allocate );
     760_puts("\n");
    738761#endif
    739762
    … …  
    742765        if ( _update_fat( last_cluster_file, free_cluster ) )
    743766        {
    744             _printf("\n[FAT ERROR] in _fat_allocate() : update fat failed\n");
     767            _puts("\n[FAT ERROR] in _fat_allocate() : update fat failed\n");
    745768            return -1;
    746769        }
    … …  
    757780            if ( _update_fat( last_cluster_file, END_OF_CHAIN_CLUSTER ) )
    758781            {
    759                 _printf("\n[FAT ERROR] in _fat_allocate() : update fat failed\n");
     782                _puts("\n[FAT ERROR] in _fat_allocate() : update fat failed\n");
    760783                return -1;
    761784            }
    … …  
    767790        if ( _get_next_cluster( IOC_KERNEL_MODE, free_cluster ) != FREE_CLUSTER)
    768791        {
    769             _printf("\n[FAT ERROR] in _fat_allocate() : free_cluster not free\n");
     792            _puts("\n[FAT ERROR] in _fat_allocate() : free_cluster not free\n");
    770793            return -1;
    771794        }
    … …  
    779802    if ( _update_fs_info() )
    780803    {
    781         _printf("\n[FAT ERROR] in _fat_allocate() : update fs_info failed\n");
     804        _puts("\n[FAT ERROR] in _fat_allocate() : update fs_info failed\n");
    782805        return -1;
    783806    }
    … …  
    824847unsigned int p       = procid & ((1<<P_WIDTH)-1);
    825848
    826 _printf("\n[FAT DEBUG] _scan_directory() : P[%d,%d,%d] enters for %s / is_sfn = %d\n",
    827         x, y, p, file_name, is_sfn );
     849_puts("\n[FAT DEBUG] _scan_directory() : P[");
     850_putd( x );
     851_puts(",");
     852_putd( y );
     853_puts(",");
     854_putd( p );
     855_puts("] enters for ")
     856_puts( file_name );
     857_puts(" / is_sfn = ");
     858_putd( is_sfn );
     859_puts("\n");
    828860#endif
    829861
    … …  
    840872                   1 ) )            // one sector
    841873    {
    842         _printf("[FAT ERROR] in _scan_directory() : cannot read sector %x\n", lba );
     874        _puts("[FAT ERROR] in _scan_directory() : cannot read sector ");
     875        _putx( lba );
     876        _puts("\n");
    843877        return -1;
    844878    }
    … …  
    878912                           1 ) )            // one sector
    879913            {
    880                 _printf("[FAT ERROR] in _scan_directory() : cannot read sector %x\n", lba );
     914                _puts("[FAT ERROR] in _scan_directory() : cannot read sector ");
     915                _putx( lba );
     916                _puts("\n");
    881917                return -1;
    882918            }
    … …  
    9721008
    9731009#if GIET_DEBUG_FAT
    974 _printf("\n[FAT DEBUG] _scan_directory() : P[%d,%d,%d] found %s / cluster = %x\n",
    975         x, y, p, file_name, searched_cluster );
     1010_puts("\n[FAT DEBUG] _scan_directory() : P[");
     1011_putd( x );
     1012_puts(",");
     1013_putd( y );
     1014_puts(",");
     1015_putd( p );
     1016_puts("] found ");
     1017_puts( file_name );
     1018_puts(" / cluster = ");
     1019_putx( searched_cluster );
     1020_puts("\n")
    9761021#endif
    9771022
    … …  
    9901035                        unsigned int    dir_cluster )
    9911036{
    992     _printf("\n[FAT ERROR] _fat_create() not implemented\n");
     1037    _puts("\n[FAT ERROR] _fat_create() not implemented\n");
    9931038    return 0;
    9941039}  //end _fat_create()
    … …  
    10141059unsigned int p       = procid & ((1<<P_WIDTH)-1);
    10151060
    1016 _printf("\n[FAT DEBUG] _fat_init() : P[%d,%d,%d] enters", x, y, p );
    1017 if ( mode == IOC_BOOT_MODE   ) _printf(" / IOC_BOOT_MODE\n");
    1018 if ( mode == IOC_KERNEL_MODE ) _printf(" / IOC_KERNEL_MODE\n");
    1019 if ( mode == IOC_USER_MODE   ) _printf(" / IOC_USER_MODE\n");
     1061_puts("\n[FAT DEBUG] _fat_init() : P[");
     1062_putd( x );
     1063_puts(",");
     1064_putd( y );
     1065_puts(",");
     1066_putd( p );
     1067_puts("] enters");
     1068if ( mode == IOC_BOOT_MODE   ) _puts(" / IOC_BOOT_MODE\n");
     1069if ( mode == IOC_KERNEL_MODE ) _puts(" / IOC_KERNEL_MODE\n");
     1070if ( mode == IOC_USER_MODE   ) _puts(" / IOC_USER_MODE\n");
    10201071#endif
    10211072   
    … …  
    10271078                    1 ) )                // one sector
    10281079    {
    1029         _printf("\n[FAT ERROR] in _fat_init() cannot load VBR\n");
     1080        _puts("\n[FAT ERROR] in _fat_init() cannot load VBR\n");
    10301081        return -1;
    10311082    }
    … …  
    10331084
    10341085#if GIET_DEBUG_FAT
    1035 _printf("\n[FAT DEBUG] _fat_init() : Boot Sector Loaded\n");
     1086_puts("\n[FAT DEBUG] _fat_init() : Boot Sector Loaded\n");
    10361087#endif
    10371088
    … …  
    10391090    if( _read_entry( BPB_BYTSPERSEC, fat.fat_cache, 1 ) != 512 )
    10401091    {
    1041         _printf("\n[FAT ERROR] The sector size must be 512 bytes\n");
     1092        _puts("\n[FAT ERROR] The sector size must be 512 bytes\n");
    10421093        return -1; 
    10431094    }
    10441095    if( _read_entry( BPB_NUMFATS, fat.fat_cache, 1 ) != 1 )
    10451096    {
    1046         _printf("\n[FAT ERROR] The number of FAT copies in FAT region must be 1\n");
     1097        _puts("\n[FAT ERROR] The number of FAT copies in FAT region must be 1\n");
    10471098        return -1; 
    10481099    }
    10491100    if( (_read_entry( BPB_FAT32_FATSZ32, fat.fat_cache, 1 ) & 0xF) != 0 )
    10501101    {
    1051         _printf("\n[FAT ERROR] The FAT region in FAT32 must be multiple of 32 sectors\n");
     1102        _puts("\n[FAT ERROR] The FAT region in FAT32 must be multiple of 32 sectors\n");
    10521103        return -1; 
    10531104    }
    10541105    if( _read_entry( BPB_FAT32_ROOTCLUS, fat.fat_cache, 1 ) != 2 )
    10551106    {
    1056         _printf("\n[FAT ERROR] The first cluster index must be 2\n");
     1107        _puts("\n[FAT ERROR] The first cluster index must be 2\n");
    10571108        return -1; 
    10581109    }
    … …  
    10741125
    10751126#if GIET_DEBUG_FAT
    1076 _printf("\n[FAT DEBUG] _fat_init() : FS_INFO Sector = %x\n", fat.fs_info_lba );
     1127_puts("\n[FAT DEBUG] _fat_init() : FS_INFO Sector = ");
     1128_putx( fat.fs_info_lba );
     1129_puts("\n");
    10771130#endif
    10781131
    … …  
    10841137                    1 ) )               // one sector
    10851138    {
    1086         _printf("\n[FAT ERROR] in _fat_init() cannot load FS_INFO Sector\n");
     1139        _puts("\n[FAT ERROR] in _fat_init() cannot load FS_INFO Sector\n");
    10871140        return -1;
    10881141    }
    … …  
    10941147
    10951148#if GIET_DEBUG_FAT
    1096 _printf("\n[FAT DEBUG] _fat_init() : P[%d,%d,%d] initialises FAT descriptor\n", x, y, p );
    10971149_fat_print();
    1098 _printf("\n[FAT DEBUG] _fat_init() : P[%d,%d,%d] exit\n", x, y, p );
     1150_puts("\n[FAT DEBUG] _fat_init() : P[");
     1151_putd( x );
     1152_puts(",");
     1153_putd( y );
     1154_puts(",");
     1155_putd( p );
     1156_puts("] exit\n");
    10991157#endif
    11001158
    … …  
    11051163void _fat_print()
    11061164{
    1107     _printf("\n########################## FAT32 ################################"); 
    1108     _printf("\nFAT initialised                  %x", fat.initialised );
    1109     _printf("\nSector Size  (bytes)             %x", fat.sector_size );
    1110     _printf("\nSectors per cluster              %x", fat.sectors_per_cluster );
    1111     _printf("\nFAT region first lba             %x", fat.fat_lba );
    1112     _printf("\nData region first lba            %x", fat.data_lba );
    1113     _printf("\nNumber of sectors for one FAT    %x", fat.fat_sectors );
    1114     _printf("\nNumber of free clusters          %x", fat.number_free_cluster );
    1115     _printf("\nLast allocated cluster           %x", fat.last_cluster_allocated );
    1116     _printf("\n#################################################################\n");
     1165    _puts("\n########################## FAT32 ################################"); 
     1166    _puts("\nFAT initialised                  "); _putx( fat.initialised );
     1167    _puts("\nSector Size  (bytes)             "); _putx( fat.sector_size );
     1168    _puts("\nSectors per cluster              "); _putx( fat.sectors_per_cluster );
     1169    _puts("\nFAT region first lba             "); _putx( fat.fat_lba );
     1170    _puts("\nData region first lba            "); _putx( fat.data_lba );
     1171    _puts("\nNumber of sectors for one FAT    "); _putx( fat.fat_sectors );
     1172    _puts("\nNumber of free clusters          "); _putx( fat.number_free_cluster );
     1173    _puts("\nLast allocated cluster           "); _putx( fat.last_cluster_allocated );
     1174    _puts("\n#################################################################\n");
    11171175}
    11181176
    … …  
    11481206unsigned int p       = procid & ((1<<P_WIDTH)-1);
    11491207
    1150 _printf("\n[FAT DEBUG] _fat_open() : P[%d,%d,%d] enters for path %s\n",
    1151         x, y, p, pathname );
     1208_puts("\n[FAT DEBUG] _fat_open() : P[");
     1209_putd( x );
     1210_puts(",");
     1211_putd( y );
     1212_puts(",");
     1213_putd( p );
     1214_puts("] enters for path ");
     1215_puts( pathname );
     1216_puts("\n");
    11521217#endif
    11531218
    … …  
    11551220    if ( creat )
    11561221    {
    1157         _printf("[FAT ERROR] in _fat_open() : create not supported yet\n");
     1222        _puts("[FAT ERROR] in _fat_open() : create not supported yet\n");
    11581223        return -1;
    11591224    }
    … …  
    11631228
    11641229#if GIET_DEBUG_FAT
    1165 _printf("\n[FAT DEBUG] _fat_open() : P[%d,%d,%d] takes the FAT lock\n",
    1166         x, y, p );
     1230_puts("\n[FAT DEBUG] _fat_open() : P[");
     1231_putd( x );
     1232_puts(",");
     1233_putd( y );
     1234_puts(",");
     1235_putd( p );
     1236_puts("] takes the FAT lock\n");
    11671237#endif
    11681238
    … …  
    11721242        if ( _fat_init( mode ) )
    11731243        {
    1174             _printf("[FAT ERROR] in _fat_open() : Cannot initialize FAT descriptor\n");
     1244            _puts("[FAT ERROR] in _fat_open() : Cannot initialize FAT descriptor\n");
    11751245            _release_lock( &fat.fat_lock );
    11761246            return -1;
    … …  
    11911261
    11921262#if GIET_DEBUG_FAT
    1193 _printf("\n[FAT DEBUG] _fat_open() : P[%d,%d,%d] search dir/file : %s\n",
    1194         x, y, p, name );
     1263_puts("\n[FAT DEBUG] _fat_open() : P[");
     1264_putd( x );
     1265_puts(",");
     1266_putd( y );
     1267_puts(",");
     1268_putd( p );
     1269_puts("] search dir/file ");
     1270_puts( name );
     1271_puts("\n");
    11951272#endif
    11961273
    … …  
    12111288        else if ( cluster == END_OF_CHAIN_CLUSTER )
    12121289        {
    1213             _printf("\n[FAT ERROR] in _fat_open() cannot found %s\n", name );
    1214 
    1215             // release FAT lock
     1290            _puts("\n[FAT ERROR] in _fat_open() cannot found ");
     1291            _puts( name );
     1292            _puts("\n");
    12161293            _release_lock( &fat.fat_lock );
    1217 
    12181294            return -1;
    12191295        }
    … …  
    12211297
    12221298#if GIET_DEBUG_FAT
    1223 _printf("\n[FAT DEBUG] _fat_open() : P[%d,%d,%d] found cluster index for file %s : %x\n",
    1224         x, y, p, pathname, cluster );
     1299_puts("\n[FAT DEBUG] _fat_open() : P[");
     1300_putd( x );
     1301_puts(",");
     1302_putd( y );
     1303_puts(",");
     1304_putd( p );
     1305_puts("] cluster index for file ");
     1306_puts( pathname );
     1307_puts(" = ");
     1308_putx( cluster );
     1309_puts("\n");
    12251310#endif
    12261311
    … …  
    12471332
    12481333#if GIET_DEBUG_FAT
    1249 _printf("\n[FAT DEBUG] _fat_open() : P[%d,%d,%d] exit : fd = %d for file %s\n",
    1250         x, y, p, fd_id, pathname );
     1334_puts("\n[FAT DEBUG] _fat_open() : P[");
     1335_putd( x );
     1336_puts(",");
     1337_putd( y );
     1338_puts(",");
     1339_putd( p );
     1340_puts("] exit : fd = ");
     1341_putd( fd_id );
     1342_puts(" for file ");
     1343_puts( pathname );
     1344_puts("\n");
    12511345#endif
    12521346
    … …  
    12581352        else
    12591353        {
    1260             _printf("\n[FAT ERROR] in _fat_open() for file %s : fd array full\n",
    1261                     pathname );
    1262 
    1263             // release FAT lock
     1354            _puts("\n[FAT ERROR] in _fat_open() for file ");
     1355            _puts( pathname );
     1356            _puts(" : fd array full\n");
    12641357            _release_lock( &fat.fat_lock );
    1265 
    12661358            return -1;
    12671359        }
    … …  
    12691361    else
    12701362    {
    1271         _printf("\n[FAT ERROR] in _fat_open() for file %s : bad cluster\n",
    1272                 pathname );
    1273 
    1274         // release FAT lock
     1363        _puts("\n[FAT ERROR] in _fat_open() for file ");
     1364        _puts( pathname );
     1365        _puts(" : bad cluster\n");
    12751366        _release_lock( &fat.fat_lock );
    1276 
    12771367        return -1;
    12781368    }
    … …  
    13041394    if ( fd_id >= GIET_OPEN_FILES_MAX )
    13051395    {
    1306         _printf("\n[FAT ERROR] in _fat_read() : illegal file descriptor index\n");
     1396        _puts("\n[FAT ERROR] in _fat_read() : illegal file descriptor index\n");
    13071397        return -1;
    13081398    }
    13091399    if ( fat.fd[fd_id].used != 1 )
    13101400    {
    1311         _printf("\n[FAT ERROR] in _fat_read() : file not open\n");
     1401        _puts("\n[FAT ERROR] in _fat_read() : file not open\n");
    13121402        return -1;
    13131403    }
    13141404    if ( ((unsigned int)buffer & 0x1FF) != 0 )
    13151405    {
    1316         _printf("\n[FAT ERROR] in _fat_read() : memory buffer not sector aligned\n");
     1406        _puts("\n[FAT ERROR] in _fat_read() : memory buffer not sector aligned\n");
    13171407        return -1;
    13181408    }
    … …  
    13251415    if ( offset >= file_sectors )
    13261416    {
    1327         _printf("\n[FAT ERROR] offset larger than number of sectors\n");
     1417        _puts("\n[FAT ERROR] offset larger than number of sectors\n");
    13281418        return -1;
    13291419    }
    … …  
    13451435unsigned int y       = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
    13461436unsigned int p       = procid & ((1<<P_WIDTH)-1);
    1347 _printf("\n[FAT DEBUG] _fat_read() : P[%d,%d,%d] enters for file %s\n"
    1348         " - buffer vbase    = %x\n"
    1349         " - skipped sectors = %x\n"
    1350         " - read sectors    = %x\n"
    1351         " - first cluster   = %x\n"
    1352         " - skiped clusters = %x\n",
    1353         x, y, p, fat.fd[fd_id].name,
    1354         (unsigned int)buffer, offset, count, cluster, clusters_to_skip );   
     1437_puts("\n[FAT DEBUG] _fat_read() : P[");
     1438_putd( x );
     1439_puts(",");
     1440_putd( y );
     1441_puts(",");
     1442_putd( p );
     1443_puts("] enters for file ");
     1444_puts( fat.fd[fd_id].name );
     1445_puts("\n - buffer vbase    = ");
     1446_putx( (unsigned int)buffer );
     1447_puts("\n - skipped sectors = ");
     1448_putx( offset );
     1449_puts("\n - read sectors    = ");
     1450_putx( count );
     1451_puts("\n - first cluster   = ");
     1452_putx( cluster );
     1453_puts("\n - skiped clusters = ");
     1454_putx( clusters_to_skip );   
     1455_puts("\n");
    13551456#endif
    13561457
    … …  
    13811482
    13821483#if GIET_DEBUG_FAT
    1383 _printf("\n[FAT DEBUG] _fat_read() : P[%d,%d,%d] makes an IOC read\n"
    1384         " - cluster = %x\n"
    1385         " - buf     = %x\n"
    1386         " - lba     = %x\n"
    1387         " - sectors = %d\n",
    1388         x, y, p, cluster, (unsigned int)dst, lba, iter_sectors );
     1484_puts("\n[FAT DEBUG] _fat_read() : P[");
     1485_putd( x );
     1486_puts(",");
     1487_putd( y );
     1488_puts(",");
     1489_putd( p );
     1490_puts("] makes an IOC read");
     1491_puts("\n - cluster = ");
     1492_putx( cluster );
     1493_puts("\n - buf     = ");
     1494_putx( (unsigned int)dst );
     1495_puts("\n - lba     = ");
     1496_putx( lba );
     1497_puts("\n - sectors = ");
     1498_putd( iter_sectors );
     1499_puts("\n");
    13891500#endif
    13901501
    … …  
    13951506                       iter_sectors ) )   // number of sectors
    13961507        {
    1397             _printf("\n[FAT ERROR] in _fat_read() cannot load block %x\n", lba );
     1508            _puts("\n[FAT ERROR] in _fat_read() cannot load block ");
     1509            _putx( lba );
     1510            _puts("\n");
    13981511            return -1;
    13991512        }
    … …  
    14641577unsigned int y       = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
    14651578unsigned int p       = procid & ((1<<P_WIDTH)-1);
    1466 
    1467 _printf("\n[FAT DEBUG] _fat_write() : P[%d,%d,%d] enters for file %s\n",
    1468         " - buffer vbase    = %x\n"
    1469         " - skipped sectors = %x\n"
    1470         " - write sectors   = %x\n"
    1471         " - file sectors    = %x\n"
    1472         " - need allocate   = %d\n",
    1473         x, y, p, fat.fd[fd_id].name, (unsigned int)buffer,
    1474         offset, count, file_sectors, allocate );
     1579_puts("\n[FAT DEBUG] _fat_write() : P[");
     1580_putd( x );
     1581_puts(",");
     1582_putd( y );
     1583_puts(",");
     1584_putd( p );
     1585_puts("] enters for file ");
     1586_puts( fat.fd[fd_id].name );
     1587_puts("\n - buffer vbase    = ");
     1588_putx( (unsigned int)buffer );
     1589_puts("\n - skipped sectors = ");
     1590_putx( offset );
     1591_puts("\n - write sectors   = ");
     1592_putx( count );
     1593_puts("\n - file sectors    = ");
     1594_putx( file_sectors );
     1595_puts("\n - need_allocate   = ");
     1596_putd( allocate );   
    14751597#endif
    14761598
    … …  
    14781600    if ( fd_id >= GIET_OPEN_FILES_MAX )
    14791601    {
    1480         _printf("\n[FAT ERROR] in _fat_write() : illegal file descriptor index\n");
     1602        _puts("\n[FAT ERROR] in _fat_write() : illegal file descriptor index\n");
    14811603        return -1;
    14821604    }
    14831605    if ( fat.fd[fd_id].used != 1 )
    14841606    {
    1485         _printf("\n[FAT ERROR] in _fat_write() : file not open\n");
     1607        _puts("\n[FAT ERROR] in _fat_write() : file not open\n");
    14861608        return -1;
    14871609    }
    14881610    if ( ((unsigned int)buffer & 0x1FF) != 0 )
    14891611    {
    1490         _printf("\n[FAT ERROR] in _fat_write() : memory buffer not sector aligned\n");
     1612        _puts("\n[FAT ERROR] in _fat_write() : memory buffer not sector aligned\n");
    14911613        return -1;
    14921614    }
    … …  
    14961618        if ( _fat_allocate( fd_id, (required_cluster - current_cluster) ) < 0 )
    14971619        {
    1498             _printf("\n[FAT ERROR] in _fat_write() : fat_allocate failed\n");
     1620            _puts("\n[FAT ERROR] in _fat_write() : fat_allocate failed\n");
    14991621            return -1;
    15001622        }
    … …  
    15091631
    15101632#if GIET_DEBUG_FAT
    1511 _printf(" - first cluster   = %x\n"
    1512         " - skiped clusters = %x\n",
    1513         cluster, clusters_to_skip );   
     1633_puts("\n - first cluster   = ");
     1634_putx( cluster );
     1635_puts("\n - skiped clusters = ");
     1636_putx( clusters_to_skip );   
     1637_puts("\n");
    15141638#endif
    15151639
    … …  
    15401664
    15411665#if GIET_DEBUG_FAT
    1542 _printf("\n[FAT DEBUG] _fat_write() : P[%d,%d,%d] makes an IOC write : "
    1543         "buf = %x / lba = %x / sectors = %x\n",
    1544         x, y, p, (unsigned int)src, lba, iter_sectors );
     1666_puts("\n[FAT DEBUG] _fat_write() : P[");
     1667_putd( x );
     1668_puts(",");
     1669_putd( y );
     1670_puts(",");
     1671_putd( p );
     1672_puts("] makes an IOC write");
     1673_puts("\n - cluster = ");
     1674_putx( cluster );
     1675_puts("\n - buf     = ");
     1676_putx( (unsigned int)src );
     1677_puts("\n - lba     = ");
     1678_putx( lba );
     1679_puts("\n - sectors = ");
     1680_putd( iter_sectors );
     1681_puts("\n");
    15451682#endif
    15461683
    … …  
    15511688                        iter_sectors ) )   // number of sectors
    15521689        {
    1553             _printf("\n[FAT ERROR] in _fat_write() cannot write block %x\n", lba );
     1690            _puts("\n[FAT ERROR] in _fat_write() cannot write block ");
     1691            _putx( lba );
     1692            _puts("\n");
    15541693            return -1;
    15551694        }
    … …  
    15751714    if ( update_entry(fd_id, DIR_FILE_SIZE, fat.fd[fd_id].file_size) )
    15761715    {
    1577             _printf("\n[FAT ERROR] in _fat_write() update entry failed\n");
     1716            _puts("\n[FAT ERROR] in _fat_write() update entry failed\n");
    15781717            return -1;
    15791718    }
    … …  
    16051744    else
    16061745    {
    1607         _printf("\n[FAT ERROR] in _fat_fstat() : illegal file descriptor index\n");
     1746        _puts("\n[FAT ERROR] in _fat_fstat() : illegal file descriptor index\n");
    16081747        return -1;
    16091748    }
    … …  
    16241763    else
    16251764    {
    1626         _printf("\n[FAT ERROR] in _fat_close() : illegal file descriptor index\n");
     1765        _puts("\n[FAT ERROR] in _fat_close() : illegal file descriptor index\n");
    16271766        return -1;
    16281767    }
    … …  
    16841823                     unsigned int whence )
    16851824{
    1686     _printf("[GIET ERROR] _fat_user_lseek() not implemented\n");
     1825    _puts("[GIET ERROR] _fat_user_lseek() not implemented\n");
    16871826    _exit();
    16881827    return 0;
Note: See TracChangeset for help on using the changeset viewer.