doc_api.c

在8051单片机应用系统中使用DiskOnChip_805

    {
        mapWin(address);          /* select flash device */

        writeCommand(AREA_A,address);

        lenWrite = MIN(len,PAGE_SIZE);
        modes = (lenWrite != PAGE_SIZE) ? (modes & ~EDC_FLAG) : modes;

#ifdef EDC_MODE
        if( modes & EDC_FLAG )
        {
            eccONwrite();                /* ECC ON for write */
        }
#endif /* EDC_MODE */

        if( !(docInfo.flags & BIG_PAGE) )            /* 2M on INLV=1 */
        {
            /* write up to two pages separately */
            toFirstPage  = MIN(lenWrite,CHIP_PAGE_SIZE);
            toSecondPage = lenWrite - toFirstPage;
            writeFlash(buf, toFirstPage);     /* starting page .. */

            if( lenWrite > CHIP_PAGE_SIZE )
            {
                if( writeExecute() != flOK )       /* done with 1st page */
                {
                    return( flWriteFault );
                }

                writeCommand(AREA_A,address + toFirstPage);
                writeFlash(buf + toFirstPage, toSecondPage);  /* user data */
            }
        }
        else                                     /* 4M or 8M */
        {
            writeFlash(buf, lenWrite);               /* user data */
        }

#ifdef EDC_MODE
        if( modes & EDC_FLAG )
        {
            writeSignals(ECC_IO | CE);            /* disable flash access */
            if( docInfo.flags & MDOC_ASIC )
            {
                for(i=0;( i < 3 ); i++ )   /* perform 3 writes to NOP register */
                {
                    docWrite8bitReg(NNop,0); /* to create clock data thru pipeline */
                }
            }
            else
            {
                writeFlash((byte *)zeroes3, 3); /* 3 dummy zero-writes to clock data thru pipeline */
            }
            writeSignals(FLASH_IO | ECC_IO | CE);  /* enable flash access */

            for(i=0;( i < SYNDROM_BYTES );i++)
            {
                syndromEDC[i]=syndrom[i] = docRead8bitReg(Nsyndrom+i);
            }

            eccOFF();                           /* ECC OFF */
            writeFlash((byte *)syndrom, SYNDROM_BYTES+2);
        }
#endif /* EDC_MODE */

        if( writeExecute() != flOK )        /* abort if write failure */
        {
            return( flWriteFault );
        }

#ifdef DOC_VERIFY_WRITE
        /* Read back after write and verify */
        status = DOC_ReadOnePage( address >> PAGE_BITS, (byte *)readback, lenWrite, modes );
        if( status != flOK )
        {
            return( flWriteFault );
        }
        if( memcmp( (void *)buf, (void *)readback, lenWrite ) != 0 )
        {
            return( flWriteFault );
        }
#endif /* DOC_VERIFY_WRITE */
    }
    return( flOK );
} /* DOC_WriteOnePage */

#ifdef ACCESS_DOC_EXTRA
/*----------------------------------------------------------------------*
 *  writeDocExtra - Write signature to spare area of flash page.	*
 *									*
 * Parameters:								*
 * 	blockNo	: block to write to.   			*
 *	sbuffer	: buffer to write from.					*
 *	len	: number of bytes to write.              		*
 *									*
 * Returns:                                                          	*
 *	FLStatus	: 0 on success, otherwise failed.		*
 *----------------------------------------------------------------------*/
FLStatus writeDocExtra( dword blockNo, byte *sbuffer, word len )
{
#ifdef DOC_VERIFY_WRITE
    byte        readback[2*EXTRA_LEN];
    FLStatus    status;
#endif /* DOC_VERIFY_WRITE */
    dword       address;
    word        offset;

    if( blockNo >= docInfo.noOfBlocks )
    {
        return( flOutOfMedia );                      /* out of media */
    }

    len = MIN( len, SIGNATURE_LEN );

    address = ( blockNo << docInfo.erasableBlockBits ) + DOC_SIGN_OFFSET;
    offset = address & ((EXTRA_LEN * 2) - 1);

    if( !(docInfo.flags & BIG_PAGE) )       /* 2M - read extra of second page */
    {
        if( offset < EXTRA_LEN )        /* First half of extra area  */
        {
            address += CHIP_PAGE_SIZE;    /* ... assigned to 2nd page  */
        }
        else                            /* Second half of extra area */
        {
            address -= EXTRA_LEN;         /* ... assigned to 1st page  */
        }
    }

    mapWin(address);                  /* select flash device */

    writeCommand(AREA_C,address);
    writeFlash(sbuffer, len);            /* user data */

    if( writeExecute() != flOK )         /* abort if write failure */
    {
        return( flWriteFault );
    }
    writeSignals(FLASH_IO | WP);
#ifdef DOC_VERIFY_WRITE
    /* Read back after write and verify */
    status = readDocExtra( blockNo, (byte *)readback, len );
    if( status != flOK )
    {
        return( flWriteFault );
    }
    if( memcmp( (void *)sbuffer, (void *)readback, len ) != 0 )
    {
        return( flWriteFault );
    }
#endif /* DOC_VERIFY_WRITE */
    return( flOK );
}
#endif /* ACCESS_DOC_EXTRA */

/*
* 函数名称: DOC_Erase
* 功能描述: 擦除 DOC
* 输入参数: blockNo:       要擦除的连续块的起始块号（有效范围：[0, docInfo.noOfBlocks-1]）
*           blocksToErase: 要擦除的连续块的数量
* 输出参数: 无
* 返 回 值: flOK         — 成功，无错误
*           flOutOfMedia — 块号超出 DOC 容量范围
*           flWriteFault — 擦除 DOC 出错
* 说    明: 
*/
FLStatus DOC_Erase( dword blockNo, word blocksToErase )
{
    FLStatus    status = flOK;
    dword       pageNo;
    word        i;
    dword       address = blockNo << docInfo.erasableBlockBits;

    if( (blockNo + (dword)blocksToErase) > docInfo.noOfBlocks )
    {
        return( flOutOfMedia );                      /* out of media */
    }

    mapWin(address);          /* select flash device */

    for(i=0;( i < blocksToErase ); i++, blockNo++ )
    {
        pageNo = blockNo * docInfo.pagesPerBlock;

        command(RESET_FLASH);   /* Toshiba 8 Mb */
        waitForReady();

        command(SETUP_ERASE);

        writeSignals(FLASH_IO | ALE | CE);

        docWrite8bitReg(Nio,(byte)pageNo);
        docWrite8bitReg(Nio,(byte)(pageNo >> 8));
        if( docInfo.flags & BIG_ADDR )
        {
            docWrite8bitReg(Nio,(byte)(pageNo >> 16));
        }
        if( docInfo.flags & MDOC_ASIC )
        {
            docWrite8bitReg(NWritePipeTerm,0);
        }

        writeSignals(FLASH_IO       | CE);

        command(CONFIRM_ERASE);
        waitForReady();

        if ( readStatus() & FAIL )       /* erase operation failed */
        {
            status = flWriteFault;
            command(RESET_FLASH);        /* reset flash device and abort */
            waitForReady();
            break;
        }
    }       /* block loop */

    writeSignals(FLASH_IO | WP);
    return( status );
} /* DOC_Erase */

#ifndef DOC_IS_FIXED
/*-------------------------------------------------------------------
 * DeviceInit - Define DiskOnChip flash type and capacity
 *
 * Note: The DiskOnChip location must be set before in 'docWin'
 *
 * Parameters: None
 *
 * Return:     flOK                - success
 *             flUnknownMedia      - Failed in Flash chips recognition
 *-------------------------------------------------------------------*/
FLStatus DeviceInit( void )
{
    word    size;
    byte    floor, dev, maxDev = MAX_FLASH_DEVICES_DOC;

    for(docInfo.noOfChips=0,floor=0;( floor < MAX_DEVICE_FLOOR );floor++)
    {
        selectFloor(floor);
        for(dev=0;( dev < maxDev );dev++,docInfo.noOfChips++)
        {
            if( readFlashID(floor,dev) != flOK ) /* Flash Identification error */
            {
                break;
            }
            if( (floor == 0) && (dev == 0) )
            {
                if( docInfo.flags & MDOC_ASIC )     /* Correct 'flags' value */
                {
                    maxDev = MAX_FLASH_DEVICES_MDOC;
                }
                else
                {
                    maxDev = MAX_FLASH_DEVICES_DOC;
                }
            }
        }
        if( floor == 0 )
        {
            docInfo.floorSize = (dword)dev * docInfo.chipSize;
        }
        if( dev == 0 )                      /* Empty floor was found */
        {
            break;
        }
    }

    if( docInfo.noOfChips == 0 )                /* No Flashes */
    {
        return( flUnknownMedia );
    }

    for(docInfo.erasableBlockBits=0, size=1L;( size < docInfo.erasableBlockSize );
        docInfo.erasableBlockBits++, size <<= 1);
    docInfo.noOfBlocks = ((dword)(docInfo.noOfChips) * docInfo.chipSize) >> docInfo.erasableBlockBits;

    return( flOK );
}
#endif /* DOC_IS_FIXED */

/*
* 函数名称: DOC_Init
* 功能描述: 对 DOC 及有关的数据结构进行初始化
* 输入参数: docWindow: DOC 窗口（大小为 8KB）在 MCU 数据存储器中的起始地址（有效范围：[0, 0xE000]）
* 输出参数: 无
* 返 回 值: flOK           — Success
*           flUnknownMedia — Failed in Flash chips recognition
*           flDOCNotFound  — The DiskOnChip ASIC was not found
* 说    明: 
*/
FLStatus DOC_Init( word docWindow )
{
#ifndef DOC_IS_FIXED
    byte    chipId;
    byte    toggle1;
    byte    toggle2;

/*  docInfo.noOfPages = 0L; */
    docInfo.flags = 0;                         /* init 'flags' value */

    /* Find DiskOnChip ASIC in the specified memory address of docWindow */

    /* Find Bios Expansion 55 AA signature */
    docWin = (byte *)docWindow;

    /* set ASIC to RESET MODE */
    setAsicMode(ASIC_RESET_MODE);
    /* set ASIC to NORMAL MODE */
    setAsicMode(ASIC_NORMAL_MODE);
    /* read ASIC ID code */
    chipId = docRead8bitReg(NchipId);

    if( (chipId == CHIP_ID_MDOC) || (chipId == CHIP_ID_DOC) )
    {
        if( chipId == CHIP_ID_MDOC )
        {
            docInfo.flags |= MDOC_ASIC;
            ECCstatus = NECCstatus_MDOC;
        }
        else
        {
            ECCstatus = NECCstatus_DOC;
        }

        toggle1 = docRead8bitReg(ECCstatus);
        toggle2 = toggle1 ^ docRead8bitReg(ECCstatus);
        if( (toggle2 & TOGGLE) != 0 )
        {
            if( DeviceInit() != flOK )             /* No Flashes */
            {
                return( flUnknownMedia );
            }

            docInfo.noOfPages = ( docInfo.noOfBlocks << docInfo.erasableBlockBits ) >> PAGE_BITS;
            return( flOK );
        }
    }

    return( flDOCNotFound );  /* DiskOnChip 2000 memory window not found */

#else  /* DOC_IS_FIXED */
    docWin = (byte *)docWindow;

    Nio = Nio_DOC;
    ECCstatus = NECCstatus_DOC;

    docInfo.flags               = BIG_PAGE | FULL_PAGE;
/*  docInfo.noOfChips           = 2;         */
/*  docInfo.pageSize            = PAGE_SIZE; */
/*  docInfo.erasableBlockSize   = 8192,      */
    docInfo.erasableBlockBits   = 13,
    docInfo.pagesPerBlock       = 16;
    docInfo.chipSize            = 8388608L;
    docInfo.noOfBlocks          = 2048L;
    docInfo.noOfPages           = 32768L;
    docInfo.floorSize           = 16777216L;

    /* set ASIC to NORMAL MODE */
    setAsicMode(ASIC_NORMAL_MODE);

    return( flOK );
#endif /* DOC_IS_FIXED */
} /* DOC_Init */