652 lines
29 KiB
C
652 lines
29 KiB
C
|
|
/*
|
|
* $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 = info@m-sys.com */
|
|
/***********************************************************************************/
|
|
|
|
|
|
#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)
|
|
{
|
|
if (!vol.cardDetected(&vol)) {
|
|
vol.cardChanged = TRUE;
|
|
return flDriveNotReady;
|
|
}
|
|
|
|
if (vol.getAndClearCardChangeIndicator &&
|
|
vol.getAndClearCardChangeIndicator(&vol))
|
|
vol.cardChanged = TRUE;
|
|
|
|
return vol.cardChanged ? flDiskChange : flOK;
|
|
}
|
|
|
|
#endif
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l G e t M a p p i n g C o n t e x t */
|
|
/* */
|
|
/* Returns the currently mapped window page (in 4KB units) */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* */
|
|
/* Returns: */
|
|
/* unsigned int : Current mapped page no. */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
unsigned flGetMappingContext(FLSocket vol)
|
|
{
|
|
return vol.window.currentPage;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l M a p */
|
|
/* */
|
|
/* Maps the window to a specified card address and returns a pointer to */
|
|
/* that location (some offset within the window). */
|
|
/* */
|
|
/* NOTE: Addresses over 128M are attribute memory. On PCMCIA adapters, */
|
|
/* subtract 128M from the address and map to attribute memory. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* address : Byte-address on card. NOT necessarily on a */
|
|
/* full-window boundary. */
|
|
/* If above 128MB, address is in attribute space. */
|
|
/* */
|
|
/* Returns: */
|
|
/* Pointer to a location within the window mapping the address. */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
void FAR0 *flMap(FLSocket vol, CardAddress address)
|
|
{
|
|
unsigned pageToMap;
|
|
|
|
if (vol.window.currentPage == UNDEFINED_MAPPING)
|
|
vol.setWindow(&vol);
|
|
pageToMap = (unsigned) ((address & -vol.window.size) >> 12);
|
|
|
|
if (vol.window.currentPage != pageToMap) {
|
|
vol.setMappingContext(&vol, pageToMap);
|
|
vol.window.currentPage = pageToMap;
|
|
vol.remapped = TRUE; /* indicate remapping done */
|
|
}
|
|
|
|
return addToFarPointer(vol.window.base,address & (vol.window.size - 1));
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l S e t W i n d o w B u s W i d t h */
|
|
/* */
|
|
/* Requests to set the window bus width to 8 or 16 bits. */
|
|
/* Whether the request is filled depends on hardware capabilities. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* width : Requested bus width */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
void flSetWindowBusWidth(FLSocket vol, unsigned width)
|
|
{
|
|
vol.window.busWidth = width;
|
|
vol.window.currentPage = UNDEFINED_MAPPING; /* force remapping */
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l S e t W i n d o w S p e e d */
|
|
/* */
|
|
/* Requests to set the window speed to a specified value. */
|
|
/* The window speed is set to a speed equal or slower than requested, */
|
|
/* if possible in hardware. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* nsec : Requested window speed in nanosec. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
void flSetWindowSpeed(FLSocket vol, unsigned nsec)
|
|
{
|
|
vol.window.speed = nsec;
|
|
vol.window.currentPage = UNDEFINED_MAPPING; /* force remapping */
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l S e t W i n d o w S i z e */
|
|
/* */
|
|
/* Requests to set the window size to a specified value (power of 2). */
|
|
/* The window size is set to a size equal or greater than requested, */
|
|
/* if possible in hardware. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* sizeIn4KBUnits : Requested window size in 4 KByte units. */
|
|
/* MUST be a power of 2. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
void flSetWindowSize(FLSocket vol, unsigned sizeIn4KBunits)
|
|
{
|
|
vol.window.size = (long) (sizeIn4KBunits) * 0x1000L;
|
|
/* Size may not be possible. Actual size will be set by 'setWindow' */
|
|
vol.window.base = physicalToPointer((long) vol.window.baseAddress << 12,
|
|
vol.window.size,vol.volNo);
|
|
vol.window.currentPage = UNDEFINED_MAPPING; /* force remapping */
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l S o c k e t S e t B u s y */
|
|
/* */
|
|
/* Notifies the start and end of a file-system operation. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* state : FL_ON (1) = operation entry */
|
|
/* FL_OFF(0) = operation exit */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
void flSocketSetBusy(FLSocket vol, FLBoolean state)
|
|
{
|
|
if (state == FL_OFF)
|
|
{
|
|
#if POLLING_INTERVAL == 0
|
|
/* If we are not polling, activate the interval routine before exit */
|
|
flIntervalRoutine(&vol);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
/* Set verify write operation to this socket */
|
|
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
|
|
if(flVerifyWrite[vol.volNo][vol.curPartition] == FL_ON)
|
|
{
|
|
vol.verifyWrite = FL_ON;
|
|
}
|
|
else
|
|
{
|
|
vol.verifyWrite = FL_OFF;
|
|
}
|
|
#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
|
|
vol.window.currentPage = UNDEFINED_MAPPING; /* don't assume mapping still valid */
|
|
#ifdef FIXED_MEDIA
|
|
vol.remapped = TRUE;
|
|
#endif /* FIXED_MEDIA */
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l N e e d V c c */
|
|
/* */
|
|
/* Turns on Vcc, if not on already */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, failed otherwise */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
void flNeedVcc(FLSocket vol)
|
|
{
|
|
vol.VccUsers++;
|
|
if (vol.VccState == PowerOff) {
|
|
vol.VccOn(&vol);
|
|
if (vol.powerOnCallback)
|
|
vol.powerOnCallback(vol.flash);
|
|
}
|
|
vol.VccState = PowerOn;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l D o n t N e e d V c c */
|
|
/* */
|
|
/* Notifies that Vcc is no longer needed, allowing it to be turned off. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
void flDontNeedVcc(FLSocket vol)
|
|
{
|
|
if (vol.VccUsers > 0)
|
|
vol.VccUsers--;
|
|
}
|
|
|
|
#ifdef SOCKET_12_VOLTS
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l N e e d V p p */
|
|
/* */
|
|
/* Turns on Vpp, if not on already */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, failed otherwise */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
FLStatus flNeedVpp(FLSocket vol)
|
|
{
|
|
vol.VppUsers++;
|
|
if (vol.VppState == PowerOff)
|
|
checkStatus(vol.VppOn(&vol));
|
|
vol.VppState = PowerOn;
|
|
|
|
return flOK;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l D o n t N e e d V p p */
|
|
/* */
|
|
/* Notifies that Vpp is no longer needed, allowing it to be turned off. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
void flDontNeedVpp(FLSocket vol)
|
|
{
|
|
if (vol.VppUsers > 0)
|
|
vol.VppUsers--;
|
|
}
|
|
|
|
#endif /* SOCKET_12_VOLTS */
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l S e t P o w e r O n C a l l b a c k */
|
|
/* */
|
|
/* Sets a routine address to call when powering on the socket. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* routine : Routine to call when turning on power */
|
|
/* flash : Flash object of routine */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
void flSetPowerOnCallback(FLSocket vol, void (*routine)(void *flash), void *flash)
|
|
{
|
|
vol.powerOnCallback = routine;
|
|
vol.flash = flash;
|
|
}
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l I n t e r v a l R o u t i n e */
|
|
/* */
|
|
/* Performs periodic socket actions: Checks card presence, and handles */
|
|
/* the Vcc & Vpp turn off mechanisms. */
|
|
/* */
|
|
/* The routine may be called from the interval timer or sunchronously. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
void flIntervalRoutine(FLSocket vol)
|
|
{
|
|
#ifndef FIXED_MEDIA
|
|
if (vol.getAndClearCardChangeIndicator == NULL &&
|
|
!vol.cardChanged)
|
|
if (!vol.cardDetected(&vol)) /* Check that the card is still there */
|
|
vol.cardChanged = TRUE;
|
|
#endif
|
|
|
|
if (vol.VppUsers == 0) {
|
|
if (vol.VppState == PowerOn)
|
|
vol.VppState = PowerGoingOff;
|
|
else if (vol.VppState == PowerGoingOff) {
|
|
vol.VppState = PowerOff;
|
|
#ifdef SOCKET_12_VOLTS
|
|
vol.VppOff(&vol);
|
|
#endif
|
|
}
|
|
if (vol.VccUsers == 0) {
|
|
if (vol.VccState == PowerOn)
|
|
vol.VccState = PowerGoingOff;
|
|
else if (vol.VccState == PowerGoingOff) {
|
|
vol.VccState = PowerOff;
|
|
vol.VccOff(&vol);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* u d a t e S o c k e t P a r a m e t e r s */
|
|
/* */
|
|
/* Pass socket parameters to the socket interface layer. */
|
|
/* This function should be called after the socket parameters (like */
|
|
/* size and base) are known. If these parameters are known at */
|
|
/* registration time then there is no need to use this function, and */
|
|
/* the parameters can be passed to the registration routine. */
|
|
/* The structure passed in irData is specific for each socket interface.*/
|
|
/* */
|
|
/* Note : When using DiskOnChip this routine returns the socekt */
|
|
/* parameters instead of initialiaing them. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* params : Record returning (or sending) the flsocket record */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success */
|
|
/*----------------------------------------------------------------------*/
|
|
FLStatus updateSocketParameters(FLSocket vol, void FAR1 *params)
|
|
{
|
|
if (vol.updateSocketParams)
|
|
vol.updateSocketParams(&vol, params);
|
|
|
|
return flOK;
|
|
}
|
|
|
|
|
|
#ifdef EXIT
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l E x i t S o c k e t */
|
|
/* */
|
|
/* Reset the socket and free resources that were allocated for this */
|
|
/* socket. */
|
|
/* This function is called when FLite exits. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
void flExitSocket(FLSocket vol)
|
|
{
|
|
flMap(&vol, 0); /* reset the mapping register */
|
|
flDontNeedVcc(&vol);
|
|
flSocketSetBusy(&vol,FL_OFF);
|
|
vol.freeSocket(&vol); /* free allocated resources */
|
|
#ifdef FL_MALLOC
|
|
FL_FREE(volBuffers[vol.volNo]);
|
|
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASE) || defined(MTD_RECONSTRUCT_BBT) || defined(VERIFY_VOLUME) || defined(VERIFY_ERASED_SECTOR))
|
|
FL_FREE(readBackBuffer[vol.volNo]);
|
|
#endif /* VERIFY_WRITE || VERIFY_ERASE || VERIFY_VOLUME || MTD_RECONSTRUCT_BBT || VERIFY_ERASED_SECTOR */
|
|
#endif /* FL_MALLOC */
|
|
}
|
|
#endif /* EXIT */
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
/* f l I n i t S o c k e t s */
|
|
/* */
|
|
/* First call to this module: Initializes the controller and all sockets */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, failed otherwise */
|
|
/*---_-------------------------------------------------------------------*/
|
|
|
|
FLStatus flInitSockets(void)
|
|
{
|
|
unsigned volNo;
|
|
FLSocket vol = vols;
|
|
|
|
for (volNo = 0; volNo < noOfSockets; volNo++, pVol++) {
|
|
flSetWindowSpeed(&vol, 250);
|
|
flSetWindowBusWidth(&vol, 16);
|
|
flSetWindowSize(&vol, 2); /* make it 8 KBytes */
|
|
|
|
vol.cardChanged = FALSE;
|
|
|
|
#ifdef FL_MALLOC
|
|
/* allocate buffer for this socket */
|
|
volBuffers[volNo] = (FLBuffer *)FL_MALLOC(sizeof(FLBuffer));
|
|
if (volBuffers[volNo] == NULL) {
|
|
DEBUG_PRINT(("Debug: failed allocating sector buffer.\r\n"));
|
|
return flNotEnoughMemory;
|
|
}
|
|
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASE) || defined(MTD_RECONSTRUCT_BBT) || defined(VERIFY_VOLUME) || defined(VERIFY_ERASED_SECTOR))
|
|
/* allocate read back buffer for this socket */
|
|
readBackBuffer[volNo] = (byte *)FL_MALLOC(READ_BACK_BUFFER_SIZE);
|
|
if (readBackBuffer[volNo] == NULL) {
|
|
DEBUG_PRINT(("Debug: failed allocating readBack buffer.\r\n"));
|
|
return flNotEnoughMemory;
|
|
}
|
|
#endif /* VERIFY_WRITE || VERIFY_ERASE || MTD_READ_BBT || VERIFY_VOLUME || VERIFY_ERASED_SECTOR */
|
|
#endif /* FL_MALLOC */
|
|
|
|
checkStatus(vol.initSocket(&vol));
|
|
|
|
#ifdef SOCKET_12_VOLTS
|
|
vol.VppOff(&vol);
|
|
vol.VppState = PowerOff;
|
|
vol.VppUsers = 0;
|
|
#endif
|
|
vol.VccOff(&vol);
|
|
vol.VccState = PowerOff;
|
|
vol.VccUsers = 0;
|
|
}
|
|
|
|
return flOK;
|
|
}
|