flsocket.c

DOC文件系统驱动源代码

/*
 * $Log:   V:/Flite/archives/TrueFFS5/Src/FLSOCKET.C_V  $
 * 
 *    Rev 1.11   Apr 15 2002 07:37:04   oris
 * Added support for VERIFY_ERASED_SECTOR compilation flag.
 * 
 *    Rev 1.10   Jan 17 2002 23:02:12   oris
 * Removed SINGLE_BUFFER compilation flag
 * Made sure buffers are allocated when VERIFY_VOLUME and  MTD_RECONSTRUCT_BBT are defined
 * Set socket verify write mode according to environment variable
 * Verify write buffers are allocated according to define and not runtime  variable.
 * Added flReadBackBufferOf returning pointer to the readback buffer.
 * 
 *    Rev 1.9   Nov 21 2001 11:38:42   oris
 * Changed FL_WITH_VERIFY_WRITE and FL_WITHOUT_VERIFY_WRITE to FL_ON and  FL_OFF.
 * 
 *    Rev 1.8   Nov 08 2001 10:49:30   oris
 * Added run-time contorll over verify write mode buffers.
 * 
 *    Rev 1.7   Jul 13 2001 01:05:36   oris
 * Add allocation for read back buffer.
 * 
 *    Rev 1.6   May 16 2001 21:19:16   oris
 * Added the FL_ prefix to the following defines: ON , OFF, MALLOC and FREE.
 * 
 *    Rev 1.5   Apr 10 2001 16:42:16   oris
 * Bug fix - DiskOnChip socket routines clashed with pccards socket 
 * routines. Moved all DiskOnChip socket routines to docsoc.c.
 * 
 *    Rev 1.4   Apr 09 2001 15:09:38   oris
 * End with an empty line.
 * 
 *    Rev 1.3   Apr 01 2001 07:55:04   oris
 * copywrite notice.
 * Removed defaultSocketParams routine due to a conflict in windows CE.
 * Aliggned left all # directives.
 * 
 *    Rev 1.2   Feb 14 2001 01:58:46   oris
 * Changed defaultUpdateSocketParameters prototype.
 *
 *    Rev 1.1   Feb 12 2001 12:14:06   oris
 * Added support for updateSocketParams (retreave FLSocket record)
 *
 *    Rev 1.0   Feb 04 2001 14:17:16   oris
 * Initial revision.
 *
 */

/***********************************************************************************/
/*                        M-Systems Confidential                                   */
/*           Copyright (C) M-Systems Flash Disk Pioneers Ltd. 1995-2001            */
/*                         All Rights Reserved                                     */
/***********************************************************************************/
/*                            NOTICE OF M-SYSTEMS OEM                              */
/*                           SOFTWARE LICENSE AGREEMENT                            */
/*                                                                                 */
/*      THE USE OF THIS SOFTWARE IS GOVERNED BY A SEPARATE LICENSE                 */
/*      AGREEMENT BETWEEN THE OEM AND M-SYSTEMS. REFER TO THAT AGREEMENT           */
/*      FOR THE SPECIFIC TERMS AND CONDITIONS OF USE,                              */
/*      OR CONTACT M-SYSTEMS FOR LICENSE ASSISTANCE:                               */
/*      E-MAIL = [e-mail]                                                    */
/***********************************************************************************/


#include "flsocket.h"

byte noOfSockets = 0;        /* No. of drives actually registered */

static FLSocket vols[SOCKETS];

#ifdef FL_MALLOC
static FLBuffer *volBuffers[SOCKETS];
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASE) || defined(MTD_RECONSTRUCT_BBT) || defined(VERIFY_VOLUME) || defined(VERIFY_ERASED_SECTOR))
static byte* readBackBuffer[SOCKETS];
#endif /* VERIFY_WRITE || VERIFY_ERASE || VERIFY_VOLUME || MTD_RECONSTRUCT_BBT || VERIFY_ERASED_SECTOR */

#else
static FLBuffer volBuffers[SOCKETS];
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASE) || defined(MTD_RECONSTRUCT_BBT) || defined(VERIFY_VOLUME) || defined(VERIFY_ERASED_SECTOR))
static byte readBackBuffer[SOCKETS][READ_BACK_BUFFER_SIZE];
#endif /* VERIFY_WRITE || VERIFY_ERASE || VERIFY_VOLUME || MTD_RECONSTRUCT_BBT || VERIFY_ERASED_SECTOR */
#endif /* FL_MALLOC */

/*----------------------------------------------------------------------*/
/*                        f l S o c k e t N o O f                       */
/*                                                                      */
/* Gets the volume no. connected to a socket                            */
/*                                                                      */
/* Parameters:                                                          */
/*        vol                : Pointer identifying drive                */
/*                                                                      */
/* Returns:                                                             */
/*         volume no. of socket                                         */
/*----------------------------------------------------------------------*/

unsigned flSocketNoOf(const FLSocket vol)
{
  return vol.volNo;
}


/*----------------------------------------------------------------------*/
/*                        f l S o c k e t O f                           */
/*                                                                      */
/* Gets the socket connected to a volume no.                            */
/*                                                                      */
/* Parameters:                                                          */
/*        volNo                : Volume no. for which to get socket     */
/*                                                                      */
/* Returns:                                                             */
/*         socket of volume no.                                         */
/*----------------------------------------------------------------------*/

FLSocket *flSocketOf(unsigned volNo)
{
  return &vols[volNo];
}


/*----------------------------------------------------------------------*/
/*                        f l B u f f e r O f                           */
/*                                                                      */
/* Gets the buffer connected to a volume no.                            */
/*                                                                      */
/* Parameters:                                                          */
/*        volNo                : Volume no. for which to get socket     */
/*                                                                      */
/* Returns:                                                             */
/*         buffer of volume no.                                         */
/*----------------------------------------------------------------------*/

FLBuffer *flBufferOf(unsigned volNo)
{
#ifdef FL_MALLOC
  return volBuffers[volNo];
#else
  return &volBuffers[volNo];
#endif
}

#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASE) || defined(MTD_RECONSTRUCT_BBT) || defined(VERIFY_VOLUME) || defined (VERIFY_ERASED_SECTOR))
/*----------------------------------------------------------------------*/
/*                        f l R e a d B a c k B u f f e r O f           */
/*                                                                      */
/* Gets the read back buffer connected to a volume no.                  */
/*                                                                      */
/* Parameters:                                                          */
/*        volNo                : Volume no. for which to get socket     */
/*                                                                      */
/* Returns:                                                             */
/*         buffer of volume no.                                         */
/*----------------------------------------------------------------------*/

byte * flReadBackBufferOf(unsigned volNo)
{
#ifdef FL_MALLOC
  return readBackBuffer[volNo];
#else
  return &(readBackBuffer[volNo][0]);
#endif
}
#endif /* VERIFY_WRITE || VERIFY_ERASE || VERIFY_VOLUME || MTD_RECONSTRUCT_BBT || VERIFY_ERASED_SECTOR */

/*----------------------------------------------------------------------*/
/*                      f l W r i t e P r o t e c t e d                 */
/*                                                                      */
/* Returns the write-protect state of the media                         */
/*                                                                      */
/* Parameters:                                                          */
/*        vol                : Pointer identifying drive                */
/*                                                                      */
/* Returns:                                                             */
/*        0 = not write-protected, other = write-protected              */
/*----------------------------------------------------------------------*/

FLBoolean flWriteProtected(FLSocket vol)
{
  return vol.writeProtected(&vol);
}


#ifndef FIXED_MEDIA

/*----------------------------------------------------------------------*/
/*                    f l R e s e t C a r d C h a n g e d               */
/*                                                                      */
/* Acknowledges a media-change condition and turns off the condition.   */
/*                                                                      */
/* Parameters:                                                          */
/*        vol                : Pointer identifying drive                */
/*                                                                      */
/*----------------------------------------------------------------------*/

void flResetCardChanged(FLSocket vol)
{
  if (vol.getAndClearCardChangeIndicator)
      vol.getAndClearCardChangeIndicator(&vol);  /* turn off the indicator */

  vol.cardChanged = FALSE;
}


/*----------------------------------------------------------------------*/
/*                        f l M e d i a C h e c k                       */
/*                                                                      */
/* Checks the presence and change status of the media                   */
/*                                                                      */
/* Parameters:                                                          */
/*        vol                : Pointer identifying drive                */
/*                                                                      */
/* Returns:                                                             */
/*         flOK                ->        Media present and not changed  */
/*        driveNotReady   ->        Media not present                   */
/*        diskChange        ->        Media present but changed         */
/*----------------------------------------------------------------------*/

FLStatus flMediaCheck(FLSocket vol)