/* tffsDrv.c - TrueFFS interface for VxWorks *//* Copyright 1984-2002 Wind River Systems, Inc. */#include "copyright_wrs.h"/*  * FAT-FTL Lite Software Development Kit * Copyright (C) M-Systems Ltd. 1995-1997	 *//*modification history--------------------01l,19jun02,nrv  SPR#78569/35046, only set readyChanged bit if R/W error.                 Added NULL check to Rd/Wrt, corrected formatting.01k,15oct01,nrv  documenting PHYSICAL_WRITE and PHYSICAL_ERASE as per SPR                 2320001j,22aug01,dgp  correct typo in library description per SPR 2871301i,11dec98,yp   added function tffsDevOptionsSet() to disable FAT monitoring01h,09mar98,kbw  making man page edits to fix problems found by QE01h,26jan98,kbw  making man page edits01g,18dec97,yp   more doc fixups01f,16dec97,yp   documentation and cleanup.01e,16dec97,hdn  supported a return value of DEFRAGMENT_VOLUME.01d,15dec97,hdn  added four new functions to tffsRawio().01c,05dec97,hdn  added tffsRawio().01b,07nov97,hdn  cleaned up.01a,25aug97,and  written by Andray in M-Systems*//*DESCRIPTIONThis module defines the routines that VxWorks uses to create a TrueFFSblock device.  Using this block device, dosFs can access a board-residentflash memory array or a flash memory card (in the PCMCIA slot) just as if it was a standard disk drive.  Also defined in this file are functions that you can use to format the flash medium, as well as well as functions that handle the low-level I/O to the device.To include TrueFFS for Tornado in a VxWorks image, you must edit your BSP'sconfig.h and define INCLUDE_TFFS, or, for some hardware, INCLUDE_PCMCIA. Ifyou define INCLUDE_TFFS, this configures usrRoot() to call tffsDrv().  If youdefined INCLUDE_PCMCIA, the call to tffsDrv() is made from pccardTffsEnabler().The call to tffsDrv() sets up the structures, global variables, and mutual exclusion semaphore needed to manage TrueFFS.  This call to tffsDrv() also registers socket component drivers for each flash device found attached to the target. These socket component drivers are not quite block devices, but they are an essential layer within TrueFFS.  Their function is to manage the hardwareinterface to the flash device, and they are intelligent enough to handle formatting and raw I/O requests to the flash device.  The other two layers within TrueFFS are known as the translation layer and the MTD (the Memory Technology Driver).  The translation layer of TrueFFS implements the error recover and wear-leveling features of TrueFFS.  The MTD implements the low-level programming (map, read, write, and erase) of the flash medium.  To implement the socket layer, each BSP that supports TrueFFS includes a sysTffs.c file.  This file contains the code that defines the socket component driver.  This file also contains a set of defines that you can use to configure which translation layer modules and MTDs are included in TrueFFS.Which translation layer modules and MTDs you should include depends onwhich types of flash devices you need to support.  Currently, there are three basic flash memory technologies, NAND-based, NOR-based, and SSFDC.Within sysTffs.c, define:.IP "INCLUDE_TL_NFTL" To include the NAND-based translation layer module..IP "INCLUDE_TL_FTL"To include the NOR-based translation layer module..IP "INCLUDE_TL_SSFDC" To include the SSFDC-appropriate translation layer module. .LPTo support these different technologies, TrueFFS ships with three differentimplementations of the translation layer.  Optionally, TrueFFS can includeall three modules.  TrueFFS later binds the appropriate translation layer module to the flash device when it registers a socket component driver forthe device.  Within these three basic flash device categories there are still other differences (largely manufacturer-specific).  These differences have no impact on the translation layer.  However, they do make a difference for the MTD.  Thus, TrueFFS ships with eight different MTDs that can support a variety of flash devices from Intel, Sharp, Samsung, National, Toshiba, AMD, and Fujitsu.  Within sysTffs.c, define:.IP "INCLUDE_MTD_I28F016"For Intel 28f016 flash devices..IP "INCLUDE_MTD_I28F008"For Intel 28f008 flash devices..IP "INCLUDE_MTD_I28F008_BAJA"For Intel 28f008 flash devices on the Heurikon Baja 4000..IP "INCLUDE_MTD_AMD"For AMD, Fujitsu: 29F0{40,80,16} 8-bit flash devices..IP "INCLUDE_MTD_CDSN"For Toshiba, Samsung: NAND CDSN flash devices..IP "INCLUDE_MTD_DOC2"For Toshiba, Samsung: NAND DOC flash devices..IP "INCLUDE_MTD_CFISCS"For CFI/SCS flash devices..IP "INCLUDE_MTD_WAMD"For AMD, Fujitsu 29F0{40,80,16} 16-bit flash devices..LPThe socket component driver and the MTDs are provided in source form.  If you need to write your own socket driver or MTD, use these working driversas a model for your own.EXTERNALLY CALLABLE ROUTINESMost of the routines defined in this file are accessible through the I/Osystem only.  However, four routines are callable externally.  Theseare: tffsDrv(), tffsDevCreate(), tffsDevFormat(), and tffsRawio().The first routine called from this library must be tffsDrv().  Call this routine exactly once.  Normally, this is handled automatically for you from within usrRoot(), if INCLUDE_TFFS is defined, or from within pccardTffsEnabler(), if INCLUDE_PCMCIA is defined.  Internally, this call to tffsDrv() registers socket component drivers for all the flash devices connected to your system.  After registering a socketcomponent driver for the device, TrueFFS can support calls to tffsDevFormat() or tffsRawio().  However, before you can mount dosFs on the flash device, you must call tffsDevCreate().  This call creates a block device on top of the socket component driver, but does not mount dosFs on the device.  Because mounting dosFs on the device is what you will want to do most of the time, the sysTffs.c file defines a helper function, usrTffsConfig().  Internally, this function calls tffsDevCreate() and then does everything necessary (such as calling the dosFsDevInit() routine) to mount dosFs on the resulting block device.LOW LEVEL I/ONormally, you should handle your I/O to the flash device using dosFs.  However, there are situations when that level of indirection is a problem.To handle such situations, this library defines tffsRawio().  Using this function, you can bypass both dosFs and the TrueFFS translation servicesto program the flash medium directly.  However, you should not try to program the flash device directly unless you are intimately familiar with the physical limits of your flash device as well as with how TrueFFS formats the flash medium.  Otherwise you risk not only corrupting the medium entirely but permanently damaging the flash device.If all you need to do is write a boot image to the flash device, usethe tffsBootImagePut() utility instead of tffsRawio().  This function provides safer access to the flash medium.  IOCTLThis driver responds to all ioctl codes by setting a global error flag.Do not attempt to format a flash drive using ioctl calls. INCLUDE FILES: tffsDrv.h, fatlite.h*//* includes */#include "tffsDrv.h"#include "fatlite.h"/* defines *//* externs *//* globals */#if     (POLLING_INTERVAL > 0)SEM_ID    flPollSemId;#endif  /* (POLLING_INTERVAL > 0) *//* locals */LOCAL BOOL tffsDrvInstalled = FALSE;		/* TRUE, if installed */LOCAL BOOL tffsDrvStatus = ERROR;		/* OK, if succeeded */LOCAL TFFS_DEV * tffsBlkDevs[DRIVES] = {NULL};	/* FLite block Devices *//* forward declarations */LOCAL void   tffsSetFromBPB	(BLK_DEV *pBlkDev, BPB *pBPB);LOCAL STATUS tffsIoctl		(TFFS_DEV * pTffsDev, int function, int arg);LOCAL STATUS tffsBlkRd		(TFFS_DEV * pTffsDev, int startBlk, 				 int numBlks, char * pBuffer);LOCAL STATUS tffsBlkWrt		(TFFS_DEV * pTffsDev, int startBlk, 				 int numBlks, char * pBuffer);#if     (POLLING_INTERVAL > 0)LOCAL FLStatus flPollSemCreate (void);#endif /* (POLLING_INTERVAL > 0) *//********************************************************************************* tffsDrv - initialize the TrueFFS system** This routine sets up the structures, the global variables, and the mutual * exclusion semaphore needed to manage TrueFFS. This call also registers * socket component drivers for all the flash devices attached to your target.  ** Because tffsDrv() is the call that initializes the TrueFFS system, this* function must be called (exactly once) before calling any other TrueFFS* utilities, such as tffsDevFormat() or tffsDevCreate().  Typically, the call* to tffsDrv() is handled for you automatically.  If you defined INCLUDE_TFFS* in your BSP's config.h, the call to tffsDrv() is made from usrRoot().  If* your BSP's config.h defines INCLUDE_PCMCIA, the call to tffsDrv() is made* from pccardTffsEnabler().* * RETURNS: OK, or ERROR if it fails.*/STATUS tffsDrv (void)    {    if (!tffsDrvInstalled)	{        /* FLite initialization:                                  */        /*      - register all the components and initialize them */        /*      - create socket polling task                      */        /*      - create task for background FLite operations      */#if     (POLLING_INTERVAL > 0)        /* Create Synchronisation semaphore */        if (flPollSemCreate() != flOK)            return (ERROR);#endif /* (POLLING_INTERVAL > 0) */        tffsDrvStatus = (flInit() == flOK) ? OK : ERROR;	tffsDrvInstalled = TRUE;#if     (POLLING_INTERVAL > 0)	if (tffsDrvStatus == flOK)	    semGive (flPollSemId);#endif /* (POLLING_INTERVAL > 0) */	}    return (tffsDrvStatus);    }/********************************************************************************* tffsDevCreate - create a TrueFFS block device suitable for use with dosFs** This routine creates a TFFS block device on top of a flash device. It takes * as arguments a drive number, determined from the order in which the socket* components were registered, and a flag integer that indicates whether the * medium is removable or not. A zero indicates a non removable medium. A one * indicates a removable medium.  If you intend to mount dosFs on this block * device, you probably do not want to call tffsDevCreate(), but should * call usrTffsConfig() instead.  Internally, usrTffsConfig() * calls tffsDevCreate() for you.  It then does everything necessary (such as * calling the dosFsDevInit() routine) to mount dosFs on the just created * block device.  ** RETURNS: BLK_DEV pointer, or NULL if it failed.*/BLK_DEV * tffsDevCreate     (    int tffsDriveNo,			/* TFFS drive number (0 - DRIVES-1) */    int removableMediaFlag		/* 0 - nonremovable flash media */    )    {    FAST TFFS_DEV  *pTffsDev;           /* ptr to created TFFS_DEV struct */    FAST BLK_DEV   *pBlkDev;            /* ptr to BLK_DEV struct          */    FLStatus        status = flOK;    BPB             bpb;    IOreq           ioreq;    if (tffsDriveNo >= DRIVES)        return (NULL);    ioreq.irHandle = tffsDriveNo;    /* create and initialize BLK_DEV structure */    pTffsDev = (TFFS_DEV *) malloc (sizeof (TFFS_DEV));    if (pTffsDev == NULL)        return (NULL);    status = flMountVolume(&ioreq);    if (status == flOK)        {        ioreq.irData = &bpb;        status = flGetBPB(&ioreq);        if (status == flOK)            {            pBlkDev = &pTffsDev->tffsBlkdev;            tffsSetFromBPB (pBlkDev, &bpb);            if (removableMediaFlag)                pBlkDev->bd_removable  = TRUE;    /* removable                */            else                pBlkDev->bd_removable  = FALSE;   /* not removable            */            pBlkDev->bd_retry        = 1;         /* retry count              */            pBlkDev->bd_mode         = O_RDWR;    /* initial mode for device  */            pBlkDev->bd_readyChanged = TRUE;      /* new ready status         */            pBlkDev->bd_blkRd        = tffsBlkRd; /* read block function      */            pBlkDev->bd_blkWrt       = tffsBlkWrt;/* write block function     */            pBlkDev->bd_ioctl        = tffsIoctl; /* ioctl function           */            pBlkDev->bd_reset        = NULL;      /* no reset function        */            pBlkDev->bd_statusChk    = NULL;      /* no check-status function */            pTffsDev->tffsDriveNo    = tffsDriveNo;            }        else	    ;        }    if (status != flOK)        return (NULL);    /* remember that we have created FLite device */    tffsBlkDevs[tffsDriveNo] = pTffsDev;    return (&pTffsDev->tffsBlkdev);    }/********************************************************************************* tffsDevOptionsSet - set TrueFFS volume options** This routine is intended to set various TrueFFS volume options. At present* it only disables FAT monitoring. If VxWorks long file names are to be used* with TrueFFS, FAT monitoring must be turned off.** RETURNS: OK, or ERROR if it failed.*/STATUS tffsDevOptionsSet    (    TFFS_DEV * pTffsDev                /* pointer to device descriptor */    )    {    FLStatus        status;    IOreq           ioreq;    /* Note : it is expected that as more volume option that would      *        need to get set via this routine are detected a second     *        parameter will be added to indicate the option that needs     *        to get set.     */    if ((pTffsDev == NULL) || (pTffsDev->tffsDriveNo >= DRIVES))        return (ERROR);    ioreq.irHandle = pTffsDev->tffsDriveNo;    /* disable FAT monitoring for TrueFFS volumes */    status = flDontMonitorFAT(&ioreq);    return ((status == flOK) ? OK : ERROR);    }/********************************************************************************* tffsIoctl - handle IOCTL calls to TFFS driver** This routine handles IOCTL calls to TrueFFS driver. Currently it sets a global* error flag and exits. The ioctl FIODISKFORMAT should not be used with TrueFFS* devices. Use tffsDevFormat() to format TrueFFS drives.** RETURNS: ERROR always.** ERRNO: S_ioLib_UNKNOWN_REQUEST**/LOCAL STATUS tffsIoctl     (    TFFS_DEV * pTffsDev,		/* pointer to device descriptor */    int function,			/* function code */    int arg				/* some argument */    )    {    errnoSet (S_ioLib_UNKNOWN_REQUEST);    return (ERROR);    }/********************************************************************************* tffsBlkRd - reads sequence of blocks from TFFS device** This routine reads a sequence of blocks from TrueFFS formatted device.** RETURNS: OK, or ERROR if it failed.** NOMANUAL*/LOCAL STATUS tffsBlkRd     (    FAST TFFS_DEV * pTffsDev,		/* pointer to device descriptor */    int startBlk,			/* starting block number to read */    int numBlks,			/* number of blocks to read */    char * pBuffer			/* pointer to buffer to receive data */    )    {    FLStatus    status = flOK;    IOreq       ioreq;    BPB         bpb;    if ( (NULL == pTffsDev) || (NULL == pBuffer) ||         (pTffsDev->tffsDriveNo >= DRIVES) )        {        return (ERROR);