Contiki 2.6

ctrl_access.c

Go to the documentation of this file.
00001 /* This file has been prepared for Doxygen automatic documentation generation.*/
00002 /*! \file ctrl_access.c *********************************************************************
00003  *
00004  * \brief
00005  *      This file contains the interface :
00006  *         - between USB <-> MEMORY
00007  *      OR
00008  *         - between USB <- Access Memory Ctrl -> Memory
00009  *
00010  *      This interface may be controled by a "Access Memory Control" for :
00011  *         - include a management of write protect global or specific
00012  *         - include a management of access password
00013  *
00014  * \addtogroup usbstick
00015  *
00016  * \author
00017  *      Atmel Corporation: http://www.atmel.com \n
00018  *      Support email: avr@atmel.com
00019  ******************************************************************************/
00020 /* 
00021    Copyright (c) 2004  ATMEL Corporation
00022    All rights reserved.
00023 
00024    Redistribution and use in source and binary forms, with or without
00025    modification, are permitted provided that the following conditions are met:
00026 
00027    * Redistributions of source code must retain the above copyright
00028      notice, this list of conditions and the following disclaimer.
00029    * Redistributions in binary form must reproduce the above copyright
00030      notice, this list of conditions and the following disclaimer in
00031      the documentation and/or other materials provided with the
00032      distribution.
00033    * Neither the name of the copyright holders nor the names of
00034      contributors may be used to endorse or promote products derived
00035      from this software without specific prior written permission.
00036 
00037   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00038   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00039   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00040   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
00041   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
00042   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
00043   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
00044   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
00045   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
00046   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00047   POSSIBILITY OF SUCH DAMAGE.
00048 */
00049 
00050 /**
00051  \addtogroup usbstorage
00052  @{
00053 */
00054 
00055 
00056 //_____ I N C L U D E S ____________________________________________________
00057 
00058 #include "config.h"
00059 #include "storage/ctrl_access.h"
00060 #include "avr_flash.h"
00061 
00062 
00063 //_____ D E F I N I T I O N S ______________________________________________
00064 
00065 #if (ACCESS_MEM_TO_MEM == ENABLED)
00066    #include "modules/file_system/fat.h"
00067    U8 buf_sector[FS_SIZE_OF_SECTOR];
00068 #endif
00069 
00070 
00071 //! Computed the maximum of static lun (don't add the lun of Mass Storage in mode USB Host)
00072 // FYC: Memory = Logical Unit
00073 
00074 
00075 
00076                // CHECK FOR LUN DEFINE
00077 #ifndef  LUN_0
00078    #  error LUN_0 must be defined with ENABLE or DISABLE in conf_access.h
00079 #endif
00080 #ifndef  LUN_1
00081    #  error LUN_1 must be defined with ENABLE or DISABLE in conf_access.h
00082 #endif
00083 #ifndef  LUN_2
00084    #  error LUN_2 must be defined with ENABLE or DISABLE in conf_access.h
00085 #endif
00086 #ifndef  LUN_3
00087    #  error LUN_3 must be defined with ENABLE or DISABLE in conf_access.h
00088 #endif
00089 #ifndef  LUN_4
00090    #  error LUN_4 must be defined with ENABLE or DISABLE in conf_access.h
00091 #endif
00092 #ifndef  LUN_5
00093    #  error LUN_5 must be defined with ENABLE or DISABLE in conf_access.h
00094 #endif
00095 #ifndef  LUN_6
00096    #  error LUN_6 must be defined with ENABLE or DISABLE in conf_access.h
00097 #endif
00098 #ifndef  LUN_7
00099    #  error LUN_7 must be defined with ENABLE or DISABLE in conf_access.h
00100 #endif
00101 #ifndef  LUN_USB
00102    #  error LUN_USB must be defined with ENABLE or DISABLE in conf_access.h
00103 #endif
00104 
00105 
00106 
00107 #if (LUN_0 == ENABLE)
00108    #define     LUN_0_EN   1
00109    U8 FLASH  lun0_name[]=LUN_0_NAME;
00110    #else
00111    #define   LUN_0_EN   0
00112 #endif
00113 #if (LUN_1 == ENABLE)
00114    #define     LUN_1_EN   1
00115    U8 FLASH  lun1_name[]=LUN_1_NAME;
00116    #else
00117    #define     LUN_1_EN   0
00118 #endif
00119 #if (LUN_2 == ENABLE)
00120    #define     LUN_2_EN   1
00121    U8 FLASH  lun2_name[]=LUN_2_NAME;
00122    #else
00123    #define     LUN_2_EN   0
00124 #endif
00125 #if (LUN_3 == ENABLE)
00126    #define     LUN_3_EN   1
00127    U8 FLASH  lun3_name[]=LUN_3_NAME;
00128    #else
00129    #define     LUN_3_EN   0
00130 #endif
00131 #if (LUN_4 == ENABLE)
00132    #define     LUN_4_EN   1
00133    U8 FLASH  lun4_name[]=LUN_4_NAME;
00134    #else
00135    #define     LUN_4_EN   0
00136 #endif
00137 #if (LUN_5 == ENABLE)
00138    #define     LUN_5_EN   1
00139    U8 FLASH  lun5_name[]=LUN_5_NAME;
00140    #else
00141    #define     LUN_5_EN   0
00142 #endif
00143 #if (LUN_6 == ENABLE)
00144    #define     LUN_6_EN   1
00145    U8 FLASH  lun6_name[]=LUN_6_NAME;
00146    #else
00147    #define     LUN_6_EN   0
00148 #endif
00149 #if (LUN_7 == ENABLE)
00150    #define     LUN_7_EN   1
00151    U8 FLASH  lun7_name[]=LUN_7_NAME;
00152    #else
00153    #define     LUN_7_EN   0
00154 #endif
00155 #if (LUN_USB == ENABLE)
00156    #define     LUN_USB_EN   1
00157    U8 FLASH  lunusb_name[]=LUN_USB_NAME;
00158    #else
00159    #define     LUN_USB_EN   0
00160 #endif
00161 
00162 
00163 #define  LUN_ID_0        (0)
00164 #define  LUN_ID_1        (LUN_0_EN)
00165 #define  LUN_ID_2        (LUN_0_EN+LUN_1_EN)
00166 #define  LUN_ID_3        (LUN_0_EN+LUN_1_EN+LUN_2_EN)
00167 #define  LUN_ID_4        (LUN_0_EN+LUN_1_EN+LUN_2_EN+LUN_3_EN)
00168 #define  LUN_ID_5        (LUN_0_EN+LUN_1_EN+LUN_2_EN+LUN_3_EN+LUN_4_EN)
00169 #define  LUN_ID_6        (LUN_0_EN+LUN_1_EN+LUN_2_EN+LUN_3_EN+LUN_4_EN+LUN_5_EN)
00170 #define  LUN_ID_7        (LUN_0_EN+LUN_1_EN+LUN_2_EN+LUN_3_EN+LUN_4_EN+LUN_5_EN+LUN_6_EN)
00171 #define  MAX_LUN         (LUN_0_EN+LUN_1_EN+LUN_2_EN+LUN_3_EN+LUN_4_EN+LUN_5_EN+LUN_6_EN+LUN_7_EN)
00172 #define  LUN_ID_USB      (MAX_LUN)
00173 
00174 // Check configuration
00175 #if (MAX_LUN == 0)
00176    #error No memory is active in conf_access.h
00177 #endif
00178 
00179 // Write protect variable
00180 #if (GLOBAL_WR_PROTECT == ENABLED)
00181    static U8 g_u8_wr_protect;
00182 #endif
00183 
00184 
00185 //_____ D E F I N I T I O N S __ F O N C T I O N S _________________________
00186 
00187 
00188 //! This fonction return the number of logical unit
00189 //!
00190 //! @return U8   number of logical unit in the system
00191 //!
00192 U8    get_nb_lun()
00193 {
00194 #if   (MEM_USB == ENABLED)
00195    return   (MAX_LUN + Host_getlun());
00196 #else
00197    return   MAX_LUN;
00198 #endif
00199 }
00200 
00201 
00202 //! This fonction return the current logical unit
00203 //!
00204 //! @return U8   number of logical unit in the system
00205 //!
00206 U8    get_cur_lun()
00207 {
00208    return   0; //TODO
00209 }
00210 
00211 
00212 //! This fonction test the state of memory, and start the initialisation of the memory
00213 //!
00214 //! MORE (see SPC-3 §5.2.4) : The TEST UNIT READY command allows an application client
00215 //! to poll a logical unit until it is ready without the need to allocate space for returned data.
00216 //! The TEST UNIT READY command may be used to check the media status of logical units with removable media.
00217 //!
00218 //! @param lun        Logical unit number
00219 //!
00220 //! @return                Ctrl_status
00221 //!   It is ready    ->    CTRL_GOOD
00222 //!   Memory unplug  ->    CTRL_NO_PRESENT
00223 //!   Not initialize ->    CTRL_BUSY
00224 //!
00225 Ctrl_status mem_test_unit_ready( U8 lun )
00226 {
00227    switch( lun )
00228    {
00229 #     if (LUN_0 == ENABLE)
00230       case LUN_ID_0:
00231          return Lun_0_test_unit_ready();
00232          break;
00233 #     endif
00234 #     if (LUN_1 == ENABLE)
00235       case LUN_ID_1:
00236          return Lun_1_test_unit_ready();
00237          break;
00238 #     endif
00239 #     if (LUN_2 == ENABLE)
00240       case LUN_ID_2:
00241          return Lun_2_test_unit_ready();
00242          break;
00243 #     endif
00244 #     if (LUN_3 == ENABLE)
00245       case LUN_ID_3:
00246          return Lun_3_test_unit_ready();
00247          break;
00248 #     endif
00249 #     if (LUN_4 == ENABLE)
00250       case LUN_ID_4:
00251          return Lun_4_test_unit_ready();
00252          break;
00253 #     endif
00254 #     if (LUN_5 == ENABLE)
00255       case LUN_ID_5:
00256          return Lun_5_test_unit_ready();
00257          break;
00258 #     endif
00259 #     if (LUN_6 == ENABLE)
00260       case LUN_ID_6:
00261          return Lun_6_test_unit_ready();
00262          break;
00263 #     endif
00264 #     if (LUN_7 == ENABLE)
00265       case LUN_ID_7:
00266          return Lun_7_test_unit_ready();
00267          break;
00268 #     endif
00269 #     if (LUN_USB == ENABLE)
00270       default:
00271          return Lun_usb_test_unit_ready(lun - LUN_ID_USB);
00272          break;
00273 #     endif
00274    }
00275    return   CTRL_FAIL;
00276 }
00277 
00278 //! This fonction return the capacity of the memory
00279 //!
00280 //! @param lun        Logical unit number
00281 //! @param u32_nb_sector The sector to query
00282 //!
00283 //! @return *u16_nb_sector number of sector (sector = 512B)
00284 //! @return                Ctrl_status
00285 //!   It is ready    ->    CTRL_GOOD
00286 //!   Memory unplug  ->    CTRL_NO_PRESENT
00287 //!
00288 Ctrl_status mem_read_capacity( U8 lun , U32 _MEM_TYPE_SLOW_ *u32_nb_sector )
00289 {
00290    switch( lun )
00291    {
00292 #     if (LUN_0 == ENABLE)
00293       case LUN_ID_0:
00294          return Lun_0_read_capacity( u32_nb_sector );
00295          break;
00296 #     endif
00297 #     if (LUN_1 == ENABLE)
00298       case LUN_ID_1:
00299          return Lun_1_read_capacity( u32_nb_sector );
00300          break;
00301 #     endif
00302 #     if (LUN_2 == ENABLE)
00303       case LUN_ID_2:
00304          return Lun_2_read_capacity( u32_nb_sector );
00305          break;
00306 #     endif
00307 #     if (LUN_3 == ENABLE)
00308       case LUN_ID_3:
00309          return Lun_3_read_capacity( u32_nb_sector );
00310          break;
00311 #     endif
00312 #     if (LUN_4 == ENABLE)
00313       case LUN_ID_4:
00314          return Lun_4_read_capacity( u32_nb_sector );
00315          break;
00316 #     endif
00317 #     if (LUN_5 == ENABLE)
00318       case LUN_ID_5:
00319          return Lun_5_read_capacity( u32_nb_sector );
00320          break;
00321 #     endif
00322 #     if (LUN_6 == ENABLE)
00323       case LUN_ID_6:
00324          return Lun_6_read_capacity( u32_nb_sector );
00325          break;
00326 #     endif
00327 #     if (LUN_7 == ENABLE)
00328       case LUN_ID_7:
00329          return Lun_7_read_capacity( u32_nb_sector );
00330          break;
00331 #     endif
00332 #     if (LUN_USB == ENABLE)
00333       default:
00334          return Lun_usb_read_capacity( lun - LUN_ID_USB,u32_nb_sector );
00335          break;
00336 #     endif
00337    }
00338    return   CTRL_FAIL;
00339 }
00340 
00341 //! This fonction return is the write protected mode
00342 //!
00343 //! @param lun        Logical unit number
00344 //!
00345 //! Only used by memory removal with a HARDWARE SPECIFIC write protected detection
00346 //! !!! The customer must be unplug the card for change this write protected mode.
00347 //!
00348 //! @return TRUE  -> the memory is protected
00349 //!
00350 Bool  mem_wr_protect( U8 lun )
00351 {
00352    switch( lun )
00353    {
00354 #     if (LUN_0 == ENABLE)
00355       case LUN_ID_0:
00356          return Lun_0_wr_protect();
00357          break;
00358 #     endif
00359 #     if (LUN_1 == ENABLE)
00360       case LUN_ID_1:
00361          return Lun_1_wr_protect();
00362          break;
00363 #     endif
00364 #     if (LUN_2 == ENABLE)
00365       case LUN_ID_2:
00366          return Lun_2_wr_protect();
00367          break;
00368 #     endif
00369 #     if (LUN_3 == ENABLE)
00370       case LUN_ID_3:
00371          return Lun_3_wr_protect();
00372          break;
00373 #     endif
00374 #     if (LUN_4 == ENABLE)
00375       case LUN_ID_4:
00376          return Lun_4_wr_protect();
00377          break;
00378 #     endif
00379 #     if (LUN_5 == ENABLE)
00380       case LUN_ID_5:
00381          return Lun_5_wr_protect();
00382          break;
00383 #     endif
00384 #     if (LUN_6 == ENABLE)
00385       case LUN_ID_6:
00386          return Lun_6_wr_protect();
00387          break;
00388 #     endif
00389 #     if (LUN_7 == ENABLE)
00390       case LUN_ID_7:
00391          return Lun_7_wr_protect();
00392          break;
00393 #     endif
00394 #     if (LUN_USB == ENABLE)
00395       default:
00396          return Lun_usb_wr_protect(lun - LUN_ID_USB);
00397          break;
00398 #     endif
00399    }
00400    return   CTRL_FAIL;
00401 }
00402 
00403 
00404 //! This fonction inform about the memory type
00405 //!
00406 //! @param lun        Logical unit number
00407 //!
00408 //! @return TRUE  -> The memory is removal
00409 //!
00410 Bool  mem_removal( U8 lun )
00411 {
00412    switch( lun )
00413    {
00414 #     if (LUN_0 == ENABLE)
00415       case LUN_ID_0:
00416          return Lun_0_removal();
00417          break;
00418 #     endif
00419 #     if (LUN_1 == ENABLE)
00420       case LUN_ID_1:
00421          return Lun_1_removal();
00422          break;
00423 #     endif
00424 #     if (LUN_2 == ENABLE)
00425       case LUN_ID_2:
00426          return Lun_2_removal();
00427          break;
00428 #     endif
00429 #     if (LUN_3 == ENABLE)
00430       case LUN_ID_3:
00431          return Lun_3_removal();
00432          break;
00433 #     endif
00434 #     if (LUN_4 == ENABLE)
00435       case LUN_ID_4:
00436          return Lun_4_removal();
00437          break;
00438 #     endif
00439 #     if (LUN_5 == ENABLE)
00440       case LUN_ID_5:
00441          return Lun_5_removal();
00442          break;
00443 #     endif
00444 #     if (LUN_6 == ENABLE)
00445       case LUN_ID_6:
00446          return Lun_6_removal();
00447          break;
00448 #     endif
00449 #     if (LUN_7 == ENABLE)
00450       case LUN_ID_7:
00451          return Lun_7_removal();
00452          break;
00453 #     endif
00454 #     if (LUN_USB == ENABLE)
00455       default:
00456          return Lun_usb_removal();
00457          break;
00458 #     endif
00459    }
00460    return   CTRL_FAIL;
00461 }
00462 
00463 //! This fonction returns a pointer to the LUN name
00464 //!
00465 //! @param lun        Logical unit number
00466 //!
00467 //! @return pointer to code string
00468 //!
00469 #if 0         //not used anywhere and the FLASH attribute causes a compilation warning - dak
00470 U8 FLASH*  mem_name( U8 lun )
00471 {
00472    switch( lun )
00473    {
00474 #     if (LUN_0 == ENABLE)
00475       case LUN_ID_0:
00476          return (U8 FLASH*)lun0_name;
00477          break;
00478 #     endif
00479 #     if (LUN_1 == ENABLE)
00480       case LUN_ID_1:
00481          return (U8 FLASH*)lun1_name;
00482          break;
00483 #     endif
00484 #     if (LUN_2 == ENABLE)
00485       case LUN_ID_2:
00486          return (U8 FLASH*)lun2_name;
00487          break;
00488 #     endif
00489 #     if (LUN_3 == ENABLE)
00490       case LUN_ID_3:
00491          return (U8 FLASH*)lun3_name;
00492          break;
00493 #     endif
00494 #     if (LUN_4 == ENABLE)
00495       case LUN_ID_4:
00496          return (U8 FLASH*)lun4_name;
00497          break;
00498 #     endif
00499 #     if (LUN_5 == ENABLE)
00500       case LUN_ID_5:
00501          return (U8 FLASH*)lun5_name;
00502          break;
00503 #     endif
00504 #     if (LUN_6 == ENABLE)
00505       case LUN_ID_6:
00506          return (U8 FLASH*)lun6_name;
00507          break;
00508 #     endif
00509 #     if (LUN_7 == ENABLE)
00510       case LUN_ID_7:
00511          return (U8 FLASH*)lun7_name;
00512          break;
00513 #     endif
00514 #     if (LUN_USB == ENABLE)
00515       default:
00516          return (U8 FLASH*)lunusb_name;
00517          break;
00518 #     endif
00519    }
00520    return 0;   // Remove compiler warning
00521 }
00522 #endif /* 0 */
00523 
00524 //************************************************************************************
00525 //!----------- Listing of READ/WRITE interface with MODE ACCESS REGISTER -------------
00526 //************************************************************************************
00527 
00528 
00529 //! This fonction tranfer a data from memory to usb
00530 //!
00531 //! @param lun          Logical unit number
00532 //! @param addr         Sector address to start read (sector = 512B)
00533 //! @param nb_sector    Number of sectors to transfer
00534 //!
00535 //! @return                Ctrl_status
00536 //!   It is ready    ->    CTRL_GOOD
00537 //!   A error occur  ->    CTRL_FAIL
00538 //!   Memory unplug  ->    CTRL_NO_PRESENT
00539 //!
00540 Ctrl_status    memory_2_usb( U8 lun , U32 addr , U16 nb_sector )
00541 {
00542    Ctrl_status status=0;
00543 
00544    switch( lun )
00545    {
00546 #     if (LUN_0 == ENABLE)
00547       case LUN_ID_0:
00548          status = Lun_0_read_10(addr , nb_sector);
00549          if (CTRL_GOOD == status)
00550          {
00551             status = Lun_0_usb_read();
00552          }
00553          break;
00554 #     endif
00555 #     if (LUN_1 == ENABLE)
00556       case LUN_ID_1:
00557          status = Lun_1_read_10(addr , nb_sector);
00558          if (CTRL_GOOD == status)
00559          {
00560             status = Lun_1_usb_read();
00561          }
00562          break;
00563 #     endif
00564 #     if (LUN_2 == ENABLE)
00565       case LUN_ID_2:
00566          status = Lun_2_read_10(addr , nb_sector);
00567          if (CTRL_GOOD == status)
00568          {
00569             status = Lun_2_usb_read();
00570          }
00571          break;
00572 #     endif
00573 #     if (LUN_3 == ENABLE)
00574       case LUN_ID_3:
00575          status = Lun_3_read_10(addr , nb_sector);
00576          if (CTRL_GOOD == status)
00577          {
00578             status = Lun_3_usb_read();
00579          }
00580          break;
00581 #     endif
00582 #     if (LUN_4 == ENABLE)
00583       case LUN_ID_4:
00584          status = Lun_4_read_10(addr , nb_sector);
00585          if (CTRL_GOOD == status)
00586          {
00587             status = Lun_4_usb_read();
00588          }
00589          break;
00590 #     endif
00591 #     if (LUN_5 == ENABLE)
00592       case LUN_ID_5:
00593          status = Lun_5_read_10(addr , nb_sector);
00594          if (CTRL_GOOD == status)
00595          {
00596             status = Lun_5_usb_read();
00597          }
00598          break;
00599 #     endif
00600 #     if (LUN_6 == ENABLE)
00601       case LUN_ID_6:
00602          status = Lun_6_read_10(addr , nb_sector);
00603          if (CTRL_GOOD == status)
00604          {
00605             status = Lun_6_usb_read();
00606          }
00607          break;
00608 #     endif
00609 #     if (LUN_7 == ENABLE)
00610       case LUN_ID_7:
00611          status = Lun_7_read_10(addr , nb_sector);
00612          if (CTRL_GOOD == status)
00613          {
00614             status = Lun_7_usb_read();
00615          }
00616          break;
00617 #     endif
00618    }
00619    return   status;
00620 }
00621 
00622 //! This fonction trabsfer a data from usb to memory
00623 //!
00624 //! @param lun          Logical unit number
00625 //! @param addr         Sector address to start write (sector = 512B)
00626 //! @param nb_sector    Number of sectors to transfer
00627 //!
00628 //! @return                Ctrl_status
00629 //!   It is ready    ->    CTRL_GOOD
00630 //!   A error occur  ->    CTRL_FAIL
00631 //!   Memory unplug  ->    CTRL_NO_PRESENT
00632 //!
00633 Ctrl_status    usb_2_memory( U8 lun , U32 addr , U16 nb_sector )
00634 {
00635    Ctrl_status status=0;
00636 
00637    switch( lun )
00638    {
00639 #     if (LUN_0 == ENABLE)
00640       case LUN_ID_0:
00641          status = Lun_0_write_10(addr , nb_sector);
00642          if (CTRL_GOOD == status)
00643          {
00644             status = Lun_0_usb_write();
00645          }
00646          break;
00647 #     endif
00648 #     if (LUN_1 == ENABLE)
00649       case LUN_ID_1:
00650          status = Lun_1_write_10(addr , nb_sector);
00651          if (CTRL_GOOD == status)
00652          {
00653             status = Lun_1_usb_write();
00654          }
00655          break;
00656 #     endif
00657 #     if (LUN_2 == ENABLE)
00658       case LUN_ID_2:
00659          status = Lun_2_write_10(addr , nb_sector);
00660          if (CTRL_GOOD == status)
00661          {
00662             status = Lun_2_usb_write();
00663          }
00664          break;
00665 #     endif
00666 #     if (LUN_3 == ENABLE)
00667       case LUN_ID_3:
00668          status = Lun_3_write_10(addr , nb_sector);
00669          if (CTRL_GOOD == status)
00670          {
00671             status = Lun_3_usb_write();
00672          }
00673          break;
00674 #     endif
00675 #     if (LUN_4 == ENABLE)
00676       case LUN_ID_4:
00677          status = Lun_4_write_10(addr , nb_sector);
00678          if (CTRL_GOOD == status)
00679          {
00680             status = Lun_4_usb_write();
00681          }
00682          break;
00683 #     endif
00684 #     if (LUN_5 == ENABLE)
00685       case LUN_ID_5:
00686          status = Lun_5_write_10(addr , nb_sector);
00687          if (CTRL_GOOD == status)
00688          {
00689             status = Lun_5_usb_write();
00690          }
00691          break;
00692 #     endif
00693 #     if (LUN_6 == ENABLE)
00694       case LUN_ID_6:
00695          status = Lun_6_write_10(addr , nb_sector);
00696          if (CTRL_GOOD == status)
00697          {
00698             status = Lun_6_usb_write();
00699          }
00700          break;
00701 #     endif
00702 #     if (LUN_7 == ENABLE)
00703       case LUN_ID_7:
00704          status = Lun_7_write_10(addr , nb_sector);
00705          if (CTRL_GOOD == status)
00706          {
00707             status = Lun_7_usb_write();
00708          }
00709          break;
00710 #     endif
00711    }
00712    return   status;
00713 }
00714 
00715 //! Interface for RAM
00716 #if (ACCESS_MEM_TO_RAM == ENABLED)
00717 
00718 //! This fonction tranfer one sector data from memory to ram
00719 //!
00720 //! @param lun          Logical unit number
00721 //! @param addr         Sector address to start read (sector = 512B)
00722 //! @param ram          Adresse of ram buffer (only xdata)
00723 //!
00724 //! @return TRUE  -> The memory is removal
00725 //!
00726 Ctrl_status    memory_2_ram( U8 lun , const U32 _MEM_TYPE_SLOW_ *addr , U8 _MEM_TYPE_SLOW_ *ram )
00727 {
00728 
00729    Ctrl_status status;
00730 
00731    switch( lun )
00732    {
00733 #     if (LUN_0 == ENABLE)
00734       case LUN_ID_0:
00735          status = Lun_0_mem_2_ram(*addr , ram);
00736          if (CTRL_GOOD == status)
00737          {
00738             status = Lun_0_mem_2_ram_read();
00739          }
00740          break;
00741 #     endif
00742 #     if (LUN_1 == ENABLE)
00743       case LUN_ID_1:
00744          status = Lun_1_mem_2_ram(*addr , ram);
00745          if (CTRL_GOOD == status)
00746          {
00747             status = Lun_1_mem_2_ram_read();
00748          }
00749          break;
00750 #     endif
00751 #     if (LUN_2 == ENABLE)
00752       case LUN_ID_2:
00753          status = Lun_2_mem_2_ram(*addr , ram);
00754          if (CTRL_GOOD == status)
00755          {
00756             status = Lun_2_mem_2_ram_read();
00757          }
00758          break;
00759 #     endif
00760 #     if (LUN_3 == ENABLE)
00761       case LUN_ID_3:
00762          status = Lun_3_mem_2_ram(*addr , ram);
00763          if (CTRL_GOOD == status)
00764          {
00765             status = Lun_3_mem_2_ram_read();
00766          }
00767          break;
00768 #     endif
00769 #     if (LUN_4 == ENABLE)
00770       case LUN_ID_4:
00771          status = Lun_4_mem_2_ram(*addr , ram);
00772          if (CTRL_GOOD == status)
00773          {
00774             status = Lun_4_mem_2_ram_read();
00775          }
00776          break;
00777 #     endif
00778 #     if (LUN_5 == ENABLE)
00779       case LUN_ID_5:
00780          status = Lun_5_mem_2_ram(*addr , ram);
00781          if (CTRL_GOOD == status)
00782          {
00783             status = Lun_5_mem_2_ram_read();
00784          }
00785          break;
00786 #     endif
00787 #     if (LUN_6 == ENABLE)
00788       case LUN_ID_6:
00789          status = Lun_6_mem_2_ram(*addr , ram);
00790          if (CTRL_GOOD == status)
00791          {
00792             status = Lun_6_mem_2_ram_read();
00793          }
00794          break;
00795 #     endif
00796 #     if (LUN_7 == ENABLE)
00797       case LUN_ID_7:
00798          status = Lun_7_mem_2_ram(*addr , ram);
00799          if (CTRL_GOOD == status)
00800          {
00801             status = Lun_7_mem_2_ram_read();
00802          }
00803          break;
00804 #     endif
00805 #     if (LUN_USB == ENABLE)
00806       default:
00807          return  Lun_usb_mem_2_ram(*addr , ram);
00808 #     endif
00809    }
00810    return   status;
00811 }
00812 #endif // ACCESS_MEM_TO_RAM == ENABLED
00813 
00814 
00815 
00816 #if (ACCESS_MEM_TO_RAM==ENABLE)
00817 
00818 //! This fonction trabsfer a data from ram to memory
00819 //!
00820 //! @param lun          Logical unit number
00821 //! @param addr         Sector address to start write (sector = 512B)
00822 //! @param ram          Adresse of ram buffer (only xdata)
00823 //!
00824 //! @return TRUE  -> The memory is removal
00825 //!
00826 Ctrl_status    ram_2_memory( U8 lun , const U32 _MEM_TYPE_SLOW_ *addr , U8 _MEM_TYPE_SLOW_ * ram )
00827 {
00828    Ctrl_status status;
00829 
00830    switch( lun )
00831    {
00832 #     if (LUN_0 == ENABLE)
00833       case LUN_ID_0:
00834          status = Lun_0_ram_2_mem(*addr , ram);
00835          if (CTRL_GOOD == status)
00836          {
00837             status = Lun_0_ram_2_mem_write();
00838          }
00839          break;
00840 #     endif
00841 #     if (LUN_1 == ENABLE)
00842       case LUN_ID_1:
00843          status = Lun_1_ram_2_mem(*addr , ram);
00844          if (CTRL_GOOD == status)
00845          {
00846             status = Lun_1_ram_2_mem_write();
00847          }
00848          break;
00849 #     endif
00850 #     if (LUN_2 == ENABLE)
00851       case LUN_ID_2:
00852          status = Lun_2_ram_2_mem(*addr , ram);
00853          if (CTRL_GOOD == status)
00854          {
00855             status = Lun_2_ram_2_mem_write();
00856          }
00857          break;
00858 #     endif
00859 #     if (LUN_3 == ENABLE)
00860       case LUN_ID_3:
00861          status = Lun_3_ram_2_mem(*addr , ram);
00862          if (CTRL_GOOD == status)
00863          {
00864             status = Lun_3_ram_2_mem_write();
00865          }
00866          break;
00867 #     endif
00868 #     if (LUN_4 == ENABLE)
00869       case LUN_ID_4:
00870          status = Lun_4_ram_2_mem(*addr , ram);
00871          if (CTRL_GOOD == status)
00872          {
00873             status = Lun_4_ram_2_mem_write();
00874          }
00875          break;
00876 #     endif
00877 #     if (LUN_5 == ENABLE)
00878       case LUN_ID_5:
00879          status = Lun_5_ram_2_mem(*addr , ram);
00880          if (CTRL_GOOD == status)
00881          {
00882             status = Lun_5_ram_2_mem_write();
00883          }
00884          break;
00885 #     endif
00886 #     if (LUN_6 == ENABLE)
00887       case LUN_ID_6:
00888          status = Lun_6_ram_2_mem(*addr , ram);
00889          if (CTRL_GOOD == status)
00890          {
00891             status = Lun_6_ram_2_mem_write();
00892          }
00893          break;
00894 #     endif
00895  #     if (LUN_7 == ENABLE)
00896       case LUN_ID_7:
00897          status = Lun_7_ram_2_mem(*addr , ram);
00898          if (CTRL_GOOD == status)
00899          {
00900             status = Lun_7_ram_2_mem_write();
00901          }
00902          break;
00903 #     endif
00904 #     if (LUN_USB == ENABLE)
00905       default:
00906          return  Lun_usb_ram_2_mem(*addr , ram);
00907          break;
00908 #     endif
00909    }
00910    return   status;
00911 }
00912 #endif   // ACCESS_RAM_TO_MEM == ENABLED
00913 
00914 
00915 
00916 //! Interface for streaming interface
00917 #if (ACCESS_STREAM == ENABLED)
00918 
00919 
00920 
00921 // Interface for transfer MEM to MEM
00922 #     if (ACCESS_MEM_TO_MEM == ENABLED)
00923 //! This fonction copy a data from memory to other memory
00924 //!
00925 //! @param src_lun The LUN of the source
00926 //! @param src_addr The address of the source
00927 //! @param dest_lun The LUN of the destination
00928 //! @param dest_addr The address of the destination
00929 //! @param nb_sector    Number of sectors to transfer
00930 //!
00931 U8    stream_mem_to_mem( U8 src_lun , U32 src_addr , U8 dest_lun , U32 dest_addr , U16 nb_sector )
00932 {
00933    while(nb_sector)
00934    {
00935       memory_2_ram( src_lun , &src_addr , buf_sector );
00936       ram_2_memory( dest_lun , &dest_addr , buf_sector );
00937       src_addr++;
00938       dest_addr++;
00939       nb_sector--;
00940    }
00941    return CTRL_GOOD;
00942 }
00943 #     endif   // ACCESS_MEM_TO_MEM == ENABLED
00944 
00945 
00946 
00947 
00948 //! Returns the state on a data transfer
00949 //!
00950 //! @param Id           transfer id
00951 //!
00952 //! @return the state of the transfer
00953 //!          CTRL_GOOD              It is finish
00954 //!          CTRL_BUSY              It is running
00955 //!          CTRL_FAIL              It is fail
00956 //!
00957 Ctrl_status stream_state( U8 Id )
00958 {
00959 
00960    return CTRL_GOOD;
00961 }
00962 
00963 //! Stop the data transfer
00964 //!
00965 //! @param Id  Transfer id
00966 //!
00967 //! @return the number of sector remainder
00968 //!
00969 U16 stream_stop( U8 Id )
00970 {
00971    return 0;
00972 }
00973 
00974 #endif   // ACCESS_STREAM == ENABLED
00975 
00976 /** @} */