fmd.c

Windows CE 6.0 BSP for VOIP sample phone. Intel PXA270 platform.

    }

    // Done
    rc = TRUE;

cleanUp:
    return rc;
}

//------------------------------------------------------------------------------
//
//  Function:  FMD_WriteSector
//
//  Write the content of the sector.
//

BOOL FMD_WriteSector(SECTOR_ADDR sector, UCHAR *pBuffer,
        SectorInfo *pSectorInfo, DWORD sectors)
{
    BOOL rc = FALSE;
    IOreq ioreq;
    FLStatus flstatus;

    // There isn't clear semantic how to write more than one sector
    if (sectors > 1 || !g_fmd.pMDOCInfo)
        goto cleanUp;

    // Write data
    if (pBuffer)
    {
        ioreq.irHandle = g_fmd.pMDOCInfo->handle;
        ioreq.irData = pBuffer;
        ioreq.irSectorNo = sector;
        ioreq.irSectorCount = 1;
        flstatus = flAbsWrite(&ioreq);
        if (flstatus != flOK)
        {
            OALMSG(OAL_WARN, (L"FMD_WriteSector: Error %d in call to "
                        L"flAbsWrite\r\n", flstatus));
            goto cleanUp;
        }
    }

    // Done
    rc = TRUE;

cleanUp:
    return rc;
}

//------------------------------------------------------------------------------
//
//  Function: FMD_GetBlockStatus
//
DWORD FMD_GetBlockStatus(BLOCK_ID blockId)
{
    return BLOCK_STATUS_UNKNOWN;
}

//------------------------------------------------------------------------------
//
//  Function: FMD_SetBlockStatus
//
BOOL FMD_SetBlockStatus(BLOCK_ID blockId, DWORD status)
{
    return FALSE;
}

//------------------------------------------------------------------------------
//
//  Function:  FMD_EraseBlock
//
//  Erase the given block. This function is used by bootpart to
//  do low-level formatting of the flash. We are reporting the
//  flash type as NOR, which prevents bootpart from verifying
//  the erase results.
//
BOOL FMD_EraseBlock(BLOCK_ID blockId)
{
    return TRUE;
}

//------------------------------------------------------------------------------
//
//  Function:  FMD_PowerUp
//
VOID FMD_PowerUp()
{
}

//------------------------------------------------------------------------------
//
//  Function:  FMD_PowerDown
//
VOID FMD_PowerDown(VOID)
{
}

static int GetSplRedundancyFactor()
{
    if (!g_fmd.pMDOCInfo)
        return 2;
    
    switch (g_fmd.pMDOCInfo->mdocType)
    {
        case FL_DOC_H1:
            return 8;
        case FL_MDOC512_G3:     
        case FL_MDOC_G4:        
            return 2;
    }
    return 2;
}

static BOOL handleLogicalFormat(DWORD  partition)
{
    IOreq ioreq;
    FLStatus flStatus;
    LogicalPartitionParams partitionParams = STD_LOG_PARTITION_PARAMS;
    FATFormatParams fatParams = STD_FAT_FORMAT_PARAMS;
    BOOL rc = FALSE;
    
    /* First mount the partition */
    ioreq.irHandle = partition;
    flStatus = flAbsMountVolume(&ioreq);
    if (flStatus != flOK)
    {
        OALMSG(OAL_WARN, (L" handleLogicalFormat: Error %d in flAbsMountVolume "
                    L"(1)\r\n", flStatus));
        return FALSE;
    }

    /* Create a single logical partition on the media */
    ioreq.irHandle = partition;
    ioreq.irCount = 1; /*Create a single logical partition*/
    ioreq.irFlags = 0; /*Must be 0*/
    ioreq.irData = &partitionParams;
    flStatus = flCreateLogicalPartitions(&ioreq);
    if (flStatus != flOK)
    {
        OALMSG(OAL_INFO, (L"handleLogicalFormat: flCreateLogicalPartitions "
                    L"failed, status=%d\r\n", flStatus));
       goto Exit;
    }
    
    OALMSG(OAL_INFO, (L"handleLogicalFormat: Successfully created logical "
                L"partition.\r\n")); 

#if 0
    /* Format the partition */
    ioreq.irHandle =partition;
    fatParams.noOfFATs = 2;
    fatParams.flags = FL_TFAT_MODE;
    ioreq.irData = &fatParams;
    flStatus = flFormatFS(&ioreq);
    if (flStatus != flOK)
    {
        OALMSG(OAL_INFO, (L"handleLogicalFormat: flFormatFS failed, "
                    L"status=%d\r\n", flStatus));
        goto Exit;
    }

    OALMSG(OAL_INFO, (L"handleLogicalFormat: Successfully created logical "
                L"TFAT partition.\r\n", flStatus)); 
#endif
    rc = TRUE;
    
Exit:
    ioreq.irHandle = partition;
    flDismountVolume(&ioreq);
    return rc;
}          

BOOL WriteMDOCLDR(UINT8 *pData)
{
    BOOL rc = FALSE;
    FLStatus flstatus;
    IOreq ioreq;
    
    // Now write the IPL.
    ioreq.irHandle =0;
    ioreq.irCount = 0;
    ioreq.irData = pData;
    ioreq.irLength = 0x800;
    ioreq.irFlags = FL_IPL_DOWNLOAD;
    flstatus = flWriteIPL(&ioreq);
    if (flstatus != flOK)
    {
        OALMSG(OAL_INFO, (L"OEMWriteFlash: Error %d in bdkWriteIPL\r\n",
                    flstatus));
        goto cleanUp;
    }
    
    rc = TRUE;

cleanUp:
    return rc;
}


//------------------------------------------------------------------------------
//
//  Function:  FMD_OEMIoControl
//
//  Report additional MDOC specific information and use the TFFS SDK
//  to format the DiskOnChip.
//

BOOL FMD_OEMIoControl(DWORD code, UCHAR *pInBuffer, DWORD inSize,
        UCHAR *pOutBuffer, DWORD outSize, DWORD *pOutSize)
{
    BOOL rc = FALSE;
    PhysicalInfo pi;
    VolumeInfoRecord vir;
    IOreq ioreq;
    FLStatus flstatus;
    FormatParams3 fp = STD_FORMAT_PARAMS3;
    BDTLPartitionFormatParams3 bdpPart[3] = {   STD_BDTL_PARAMS3,
                                                STD_BDTL_PARAMS3,
                                                STD_BDTL_PARAMS3 };
    BinaryPartitionFormatParams3 bdkBinPart[1] = { STD_BINARY_PARAMS3 };
    int i; 

    switch (code)
    {
        
    case IOCTL_FMD_LOCK_BLOCKS:
        // Lock DiskOnChip
        OALMSG(OAL_INFO, (L"FMD_OEMIoControl: IOCTL_FMD_LOCK_BLOCKS \r\n"));
        if (!RemoveProtectionKey())
            break;

        rc = TRUE;
        break;

    case IOCTL_FMD_UNLOCK_BLOCKS:
        // Unlock DiskOnChip
        OALMSG(OAL_INFO, (L"FMD_OEMIoControl: IOCTL_FMD_UNLOCK_BLOCKS \r\n"));
        if (!InsertProtectionKey()) 
            break;
        rc = TRUE;
        break;

    case IOCTL_DOC_MOUNT:
        // Mount MDOC volume.
        OALMSG(OAL_INFO, (L"FMD_OEMIoControl: IOCTL_DOC_MOUNT\r\n"));

        if (!MountMDOC())
            break;

        // Get physical data.
        ioreq.irData = π
        flstatus = flGetPhysicalInfo(&ioreq);
        if (flstatus != flOK) {
            OALMSG(OAL_WARN, (L"FMD_OEMIoControl: Error %d in flGetPhysicalInfo\r\n", flstatus));
            break;
        }

        ioreq.irData = &vir;
        flstatus = flVolumeInfo(&ioreq);
        if (flstatus != flOK) {
            OALMSG(OAL_WARN, (L"FMD_OEMIoControl: Error %d in flVolumeInfo\r\n", flstatus));
            break;
        }
        
        flstatus = flSectorsInVolume(&ioreq);
        if (flstatus != flOK) {
            OALMSG(OAL_WARN, (L"FMD_OEMIoControl: Error %d in flSectorsInVolume\r\n", flstatus));
            break;
        }

        OALMSG(OAL_INFO, (L"\r\n M-System DiskOnChip specific information\r\n"));
        OALMSG(OAL_INFO, (L" MDOC - physical size: 0x%x\r\n", vir.physicalSize));
        OALMSG(OAL_INFO, (L" MDOC - physical unit size: 0x%x\r\n", vir.physicalUnitSize));
        OALMSG(OAL_INFO, (L" MDOC - boot area size: 0x%x\r\n", vir.bootAreaSize));
        OALMSG(OAL_INFO, (L" MDOC - # logical sectors in volume: 0x%x\r\n", ioreq.irLength));
        rc = TRUE;
        break;

    case IOCTL_DOC_FORMAT_LEAVE:
        OALMSG(OAL_INFO, (L"FMD_OEMIoControl: IOCTL_DOC_FORMAT_LEAVE not supported\r\n"));
        rc = FALSE;
        break;
        
    case IOCTL_DOC_FORMAT_COMP:
        OALMSG(OAL_INFO, (L"FMD_OEMIoControl: IOCTL_DOC_FORMAT_COMP\r\n"));
        
        ioreq.irHandle = 0;
        ioreq.irData = &fp;
        ioreq.irFlags = TL_NORMAL_FORMAT;

        // Dismount all partitions before format
        for (i=0; i<FL_MAX_TL_PARTITIONS; i++)
        {
            flstatus = flOK;
            ioreq.irHandle = i << 4;
            while (flstatus == flOK)
            {
                flstatus = flDismountVolume(&ioreq);
            }
        }

        ioreq.irHandle = 0;
        
        // First Disk partitition used for Eboot CFG
        bdpPart[0].length = BSP_MDOC_EBOOT_CFG_PARTITION_SIZE;
        bdpPart[0].protectionType = PROTECTABLE; // | WRITE_PROTECTED;

        // Second Disk partitition used for NK Image
        bdpPart[1].length = BSP_MDOC_NK_PARTITION_SIZE;
        bdpPart[0].protectionType = PROTECTABLE;// | WRITE_PROTECTED;
        
        // Third Disk partitition used for User partition
        
        fp.noOfBDTLPartitions = 3;
        fp.BDTLPartitionInfo = &bdpPart[0]; 

        // First binary partition used for bootloader.
        bdkBinPart[0].flags = TL_SPL_FORMAT;    
        bdkBinPart[0].length = GetSplRedundancyFactor()*BSP_MDOC_EBOOT_PARTITION_SIZE;
        bdkBinPart[0].sign[0]='B';
        bdkBinPart[0].sign[1]='I';
        bdkBinPart[0].sign[2]='P';
        bdkBinPart[0].sign[3]='O';
        bdkBinPart[0].protectionType = PROTECTABLE;// | WRITE_PROTECTED;

        fp.binaryPartitionInfo = &bdkBinPart[0];
        fp.noOfBinaryPartitions = 1;

        OALMSG(OAL_INFO, (L" FMD_OEMIoControl: "
                    L"Physical MDOC format (1 BIN 2 BDTL partitions)\r\n"));

        flstatus = flFlashFormat(&ioreq);
        if (flstatus != flOK)
        {
            KITLOutputDebugString("FMD_OEMIoControl: Error %d in flFlashFormat\r\n", flstatus);
            break;
        }

        if (!MountMDOC())
            break;

        KITLOutputDebugString("\r\nFMD_OEMIoControl: Successfully formatted MDOC.\r\n");
        rc = TRUE;
        
        break;
    
    case IOCTL_DOC_ERASE_BD:
        OALMSG(OAL_INFO, (L"FMD_OEMIoControl: IOCTL_DOC_ERASE_BD\r\n"));

        // Dismount the partition before format
        flstatus = flOK;
        ioreq.irHandle = g_fmd.pMDOCInfo->handle;
        while (flstatus == flOK)
            flstatus = flDismountVolume(&ioreq);

        // Erase the partition
        ioreq.irHandle = g_fmd.pMDOCInfo->handle;
        ioreq.irData = NULL;
        ioreq.irFlags = 0;
        ioreq.irLength = 0;
        ioreq.irPath = NULL;
        flstatus = flEraseBD(&ioreq);
        if (flstatus != flOK)
        {
            OALMSG(OAL_WARN, (L" FMD_OEMIoControl: Error %d in flEraseBD\r\n",
                        flstatus));
            break;
        }

        // Mount the volume
        if (!MountMDOC())
            break;
        
        rc = TRUE;
        break;

    case IOCTL_DOC_WRITE_MDOCLDR:
        OALMSG(OAL_INFO, (L"FMD_OEMIoControl: IOCTL_DOC_WRITE_MDOCLDR\r\n"));
        rc = WriteMDOCLDR(pInBuffer);
        break;

    case IOCTL_DOC_GET_RESERVED_TABLE:
        OALMSG(OAL_INFO, (L"FMD_OEMIoControl: IOCTL_DOC_GET_RESERVED_TABLE not implemented.\r\n"));
        rc = FALSE;
        break;
        
    case IOCTL_DOC_READ_RESERVED:
        OALMSG(OAL_INFO, (L"FMD_OEMIoControl: IOCTL_DOC_READ_RESERVED not implemented\r\n"));
        rc = FALSE;
        break;
        
    case IOCTL_DOC_GET_UNIQUE_ID:
        OALMSG(OAL_INFO, (L"FMD_OEMIoControl: IOCTL_DOC_GET_UNIQUE_ID\r\n"));

        if (NULL == pOutBuffer || outSize != 16)
        {
            OALMSG(OAL_WARN, (L"FMD_OEMIoControl: IOCTL_DOC_GET_UNIQUE_ID: Invalid out buffer\r\n"));
            break;
        }

        ioreq.irHandle = 0; // socket: 0, Partition 0;
        ioreq.irData = pOutBuffer;
        ioreq.irFlags = 0;
        ioreq.irLength = 0;
        ioreq.irPath = NULL;
        flstatus = flGetUniqueID(&ioreq);
        if (flstatus != flOK)
        {
            OALMSG(OAL_WARN, (L" FMD_OEMIoControl: Error %d in flGetUniqueID\r\n", flstatus));
            KITLOutputDebugString(" FMD_OEMIoControl: Error %d in flGetUniqueID\r\n", flstatus);
            break;
        }
     
        rc = TRUE;
        break;

    default:
        OALMSG(OAL_INFO, (L"FMD_OEMIoControl: Unknown IOCTL code %d\r\n", code-(IOCTL_DISK_USER(0))));
        break;
    }
                
    return rc;
}

//------------------------------------------------------------------------------