Ignore:
Timestamp:
Nov 3, 2014, 10:53:00 AM (10 years ago)
Author:
alain
Message:

Introducing dynamic allocation of peripheral channel(TTY, NIC, TIM, CMA)
Removint the ICU driver : ICU component not supported anymore.
Removing the FBF driver.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/giet_drivers/sdc_driver.c

    r320 r437  
    1818
    1919///////////////////////////////////////////////////////////////////////////////
    20 //      _sdc_enable()
    2120// This function enables SD Card select signal
    2221///////////////////////////////////////////////////////////////////////////////
    … …  
    2726
    2827///////////////////////////////////////////////////////////////////////////////
    29 //      _sdc_enable()
    3028// This function disables SD Card select signal
    3129///////////////////////////////////////////////////////////////////////////////
    … …  
    3634
    3735///////////////////////////////////////////////////////////////////////////////
    38 //      _sdc_gen_tick()
    3936// This function writes on the SPI tx register to generate SD card clock ticks
    4037// - tick_count: number of ticks to generate (1 tick -> 8 clocks)
    … …  
    4744
    4845///////////////////////////////////////////////////////////////////////////////
    49 //      _sdc_lseek()
    5046// This function changes the SD card access pointer position in terms of
    5147// blocks
    … …  
    5854
    5955///////////////////////////////////////////////////////////////////////////////
    60 //      _sdc_receive_char()
    6156// This function gets a byte from the SD card
    6257///////////////////////////////////////////////////////////////////////////////
    … …  
    6964
    7065///////////////////////////////////////////////////////////////////////////////
    71 //      _sdc_wait_response()
    7266// This function returns when a valid response from the SD card is received or
    7367// a timeout has been triggered
    … …  
    9488
    9589///////////////////////////////////////////////////////////////////////////////
    96 //      _sdc_wait_data_block()
    9790// This function returns when a data block from the SD card is received (data
    9891// block start marker received).
    … …  
    10598
    10699///////////////////////////////////////////////////////////////////////////////
    107 //      _sdc_send_command()
    108100// This function sends a command to the SD card
    109101// - index: CMD index
    … …  
    153145
    154146///////////////////////////////////////////////////////////////////////////////
    155 //      _sdc_open()
    156147// This function initializes the SD card (reset procedure)
    157148// - channel: channel index (only channel 0 is supported)
    … …  
    182173        if ( sdcard_rsp != 0x01 )
    183174        {
    184                 _printf("[SDC ERROR] card CMD0 failed\n");
     175                _puts("[SDC ERROR] card CMD0 failed\n");
    185176                return sdcard_rsp;
    186177        }
    … …  
    198189        if (!SDCARD_CHECK_R1_VALID(sdcard_rsp))
    199190    {
    200                 _printf("[SDC ERROR] card CMD8 failed\n");
     191                _puts("[SDC ERROR] card CMD8 failed\n");
    201192                return sdcard_rsp;
    202193        }
    … …  
    211202        {
    212203                        // voltage mismatch
    213                         _printf("[SDC ERROR] card CMD8 mismatch : ersp = %x\n");
     204                        _puts("[SDC ERROR] card CMD8 mismatch : ersp = %x\n");
    214205                        return sdcard_rsp;
    215206                }
    216                 _printf("[SDC WARNING] v2 or later ");
     207                _puts("[SDC WARNING] v2 or later ");
    217208                sdcard.sdhc = 1;
    218209        }
    … …  
    220211    {
    221212                // other error
    222                 _printf("[SDC ERROR] card CMD8 error\n");
     213                _puts("[SDC ERROR] card CMD8 error\n");
    223214                return sdcard_rsp;
    224215        }
    … …  
    251242        if (sdcard_rsp)
    252243    {
    253                 _printf("[SDC ERROR] ACMD41 failed\n");
     244                _puts("[SDC ERROR] ACMD41 failed\n");
    254245                return sdcard_rsp;
    255246        }
    … …  
    265256                if (sdcard_rsp)
    266257        {
    267                         _printf("[SDC ERROR] CMD58 failed\n");
     258                        _puts("[SDC ERROR] CMD58 failed\n");
    268259                        return sdcard_rsp;
    269260                }
    … …  
    274265                if (ersp & 0x40000000)
    275266        {
    276                         _printf(" SDHC ");
     267                        _puts(" SDHC ");
    277268                }
    278269        else
    … …  
    282273                _sdc_disable();
    283274        }
    284         _printf("card detected\n");
     275        _puts("card detected\n");
    285276        return 0;
    286277}
    287278
    288279///////////////////////////////////////////////////////////////////////////////
    289 //      _sdc_set_block_size()
    290 // This function sets the block size in bytes of the SD card
     280// This function sets the block size in the SD card.
    291281// - len: block size in bytes (only 512 bytes supported)
    292282// Returns 0 if success, other value if failure
    … …  
    330320}
    331321
    332 ///////////////////////////////////////////////////////////////////////////////
    333 //      _sdc_init()
    334 // This function initializes the SPI controller and call sdc_open to
    335 // initializes SD card
    336 // - channel: channel to initialize (only channel 0 supported)
    337 // Returns 0 if success, other value if failure
    338 ///////////////////////////////////////////////////////////////////////////////
     322/////////////////////////////////////////////////////////////////////////////////
     323//           Extern functions
     324/////////////////////////////////////////////////////////////////////////////////
     325
     326////////////////////////
    339327unsigned int _sdc_init()
    340328{
    … …  
    358346    while(1)
    359347    {
    360         _printf("[SDC WARNING] Trying to initialize SD card...\n");
     348        _puts("[SDC WARNING] Trying to initialize SD card...\n");
    361349
    362350        sdcard_rsp = _sdc_open( 0 );  // only channel 0
    363351        if (sdcard_rsp == 0)
    364352        {
    365             _printf("OK\n");
     353            _puts("OK\n");
    366354            break;
    367355        }
    368356
    369         _printf("KO\n");
     357        _puts("KO\n");
    370358
    371359        for (i = 0; i < 1000; i++);
    … …  
    373361        if (++iter >= SDCARD_RESET_ITER_MAX)
    374362        {
    375             _printf("\n[SDC ERROR] During SD card reset to IDLE state "
    376                     "/ card response = %x\n", sdcard_rsp );
     363            _puts("\n[SDC ERROR] During SD card reset / card response = ");
     364            _putx( sdcard_rsp );
     365            _puts("\n");
    377366            _exit();
    378367        }
    … …  
    383372    if (sdcard_rsp)
    384373    {
    385         _printf("[SDC ERROR] During SD card blocklen initialization\n");
     374        _puts("[SDC ERROR] During SD card blocklen initialization\n");
    386375        _exit();
    387376    }
    … …  
    397386    );
    398387
    399     _printf("[SDC WARNING] Finish SD card initialization\n\r");
     388    _puts("[SDC WARNING] Finish SD card initialization\n\r");
    400389
    401390    return 0;
    … …  
    403392
    404393
    405 ///////////////////////////////////////////////////////////////////////////////
    406 //     _sdc_read()
    407 // Transfer data from the block device to a memory buffer.
    408 // - mode     : BOOT / KERNEL / USER
    409 // - lba      : first block index on the block device
    410 // - buffer   : base address of the memory buffer (must be word aligned)
    411 // - count    : number of blocks to be transfered.
    412 // Returns 0 if success, > 0 if error.
    413 ///////////////////////////////////////////////////////////////////////////////
     394//////////////////////////////////////////
    414395unsigned int _sdc_read( unsigned int mode,
    415396                        unsigned int lba,
    … …  
    461442}
    462443
    463 ///////////////////////////////////////////////////////////////////////////////
    464 //     _sdc_write() (not supported for now)
    465 // Transfer data from memory buffer to SD card device.
    466 // - mode     : BOOT / KERNEL / USER
    467 // - lba      : destination first block index on the SD card
    468 // - buffer   : base address of the memory buffer (must be word aligned)
    469 // - count    : number of blocks to be transfered.
    470 // Returns 0 if success, > 0 if error.
    471 ///////////////////////////////////////////////////////////////////////////////
     444///////////////////////////////////////////
    472445unsigned int _sdc_write( unsigned int mode,
    473446                         unsigned int lba,
    … …  
    475448                         unsigned int count )
    476449{
    477         return 0;
    478 }
    479 
    480 ///////////////////////////////////////////////////////////////////////////////
    481 // Transfer data from memory buffer to SD card device.
    482 // - channel: channel index
    483 // - status: this pointer is used to transmit the status value to caller.
    484 // Returns 0 if success, > 0 if error.
    485 ///////////////////////////////////////////////////////////////////////////////
     450    _puts("[SDC ERROR] function _sdc_write() not iplemented yet\n");
     451    _exit();
     452
     453    return 0;  // to avoid a warning
     454}
     455
     456//////////////////////////////
    486457unsigned int _sdc_get_status()
    487458{
    488     _printf("[SDC ERROR] function _sdc_get_status() should not be called\n");
     459    _puts("[SDC ERROR] function _sdc_get_status() should not be called\n");
    489460    _exit();
    490461
    … …  
    492463}
    493464
    494 ///////////////////////////////////////////////////////////////////////////////
    495 // Returns the block size in bytes of the SD card
    496 ///////////////////////////////////////////////////////////////////////////////
     465//////////////////////////////////
    497466unsigned int _sdc_get_block_size()
    498467{
Note: See TracChangeset for help on using the changeset viewer.