fmd.h

windows mobile 6.13 dnldr下载源码

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Module Name:    FMD.H

Abstract:       FLASH Media Driver Interface for Windows CE

Notes:          The following module defines the required entry points for
                creating a new FLASH Media Driver (FMD) for Windows CE.  The
                FMD is called by the FLASH Abstraction Layer (FAL) and is
                responsible for directly writing to the underlying FLASH hardware
                (i.e. NAND/NOR chip).  In turn, the FAL handles all of the necessary
                wear-leveling of the device.  Practically, this means that the FMD
                is NEVER asked to read/write an invalid page or block.

                The FMD is responsible for:
                    * reading from the FLASH media
                    * writing to the FLASH media
                    * erasing FLASH media blocks
                    * performing error correcting-codes (ECC) on data stored on the
                      FLASH media (if necessary)

Environment:    As noted, this media driver works on behalf of the FAL to directly
                access the underlying FLASH hardware.  Consquently, this module
                needs to be linked with FAL.LIB to produce the device driver
                named FLASHDRV.DLL.

-----------------------------------------------------------------------------*/

#ifndef _FMD_H_
#define _FMD_H_

#include "syslib.h"

//#define RUN_IN_WINDOWS_MOBILE

// FMD IOCTL definitions.
//

#ifdef RUN_IN_WINDOWS_MOBILE
#define IOCTL_FMD_SET_XIPMODE   IOCTL_DISK_USER(0)
#define IOCTL_FMD_LOCK_BLOCKS   IOCTL_DISK_USER(1)
#define IOCTL_FMD_UNLOCK_BLOCKS IOCTL_DISK_USER(2)
#define IOCTL_FMD_GET_INTERFACE IOCTL_DISK_USER(3)
#define IOCTL_FMD_GET_XIPMODE   IOCTL_DISK_USER(4)
#else
#define IOCTL_FMD_SET_XIPMODE   (0)
#define IOCTL_FMD_LOCK_BLOCKS   (1)
#define IOCTL_FMD_UNLOCK_BLOCKS (2)
#define IOCTL_FMD_GET_INTERFACE (3)
#define IOCTL_FMD_GET_XIPMODE   (4)
#endif

// FMD block status definitions.
#define BLOCK_STATUS_UNKNOWN    0x01
#define BLOCK_STATUS_BAD        0x02
#define BLOCK_STATUS_READONLY   0x04
#define BLOCK_STATUS_RESERVED   0x08
#define BLOCK_STATUS_XIP        0x10
// FMD OEM reserved area bitfield.
#define OEM_BLOCK_RESERVED      0x01
#define OEM_BLOCK_READONLY      0x02


#define INVALID_BLOCK_ID        0xFFFFFFFF
#define INVALID_SECTOR_ADDR     0xFFFFFFFF


//--------------------------- Structure Definitions -----------------------------

typedef enum  _FLASH_TYPE { NAND, NOR } FLASH_TYPE;

typedef DWORD  SECTOR_ADDR;
typedef PDWORD PSECTOR_ADDR;

typedef DWORD  BLOCK_ID;
typedef PDWORD PBLOCK_ID;

typedef struct _FlashInfo
{
    FLASH_TYPE  flashType;
    DWORD       dwNumBlocks;
    DWORD       dwBytesPerBlock;
    WORD        wSectorsPerBlock;
    WORD        wDataBytesPerSector;

}FlashInfo, *PFlashInfo;


typedef struct _SectorInfo
{
    DWORD dwReserved1;              // Reserved - used by FAL
    BYTE  bOEMReserved;             // For use by OEM
    BYTE  bBadBlock;                // Indicates if block is BAD
    WORD  wReserved2;               // Reserved - used by FAL

}SectorInfo, *PSectorInfo;

typedef struct _BlockLockInfo
{
    BLOCK_ID StartBlock;
    ULONG    NumBlocks;
}BlockLockInfo, *PBlockLockInfo;


typedef PVOID  (*PFN_INIT)(void);
typedef BOOL  (*PFN_DEINIT)(PVOID);
typedef BOOL  (*PFN_GETINFO)(PFlashInfo pFlashInfo);
typedef DWORD (*PFN_GETBLOCKSTATUS)(BLOCK_ID blockID);
typedef BOOL (*PFN_SETBLOCKSTATUS)(BLOCK_ID blockID, DWORD dwStatus);
typedef BOOL  (*PFN_READSECTOR)(SECTOR_ADDR startSectorAddr, LPBYTE pSectorBuff, PSectorInfo pSectorInfoBuff, DWORD dwNumSectors);
typedef BOOL  (*PFN_WRITESECTOR)(SECTOR_ADDR startSectorAddr, LPBYTE pSectorBuff, PSectorInfo pSectorInfoBuff, DWORD dwNumSectors);
typedef BOOL  (*PFN_ERASEBLOCK)(BLOCK_ID blockID);
typedef VOID  (*PFN_POWERUP)(VOID);
typedef VOID  (*PFN_POWERDOWN)(VOID);
typedef VOID (*PFN_GETPHYSSECTORADDR)(DWORD dwSector, PSECTOR_ADDR pStartSectorAddr);


typedef struct _FMDInterface
{
    DWORD cbSize;
    PFN_INIT pInit;
    PFN_DEINIT pDeInit;
    PFN_GETINFO pGetInfo;
    PFN_GETBLOCKSTATUS pGetBlockStatus;
    PFN_SETBLOCKSTATUS pSetBlockStatus;
    PFN_READSECTOR pReadSector;
    PFN_WRITESECTOR pWriteSector;
    PFN_ERASEBLOCK pEraseBlock;
    PFN_POWERUP pPowerUp;
    PFN_POWERDOWN pPowerDown;
    PFN_GETPHYSSECTORADDR pGetPhysSectorAddr;
} FMDInterface, *PFMDInterface;


//------------------------------- Public Interface (used by the FAL) ------------------------------
PVOID  FMD_Init(void);
BOOL  FMD_Deinit(PVOID);
BOOL  FMD_GetInfo(PFlashInfo pFlashInfo);
DWORD FMD_GetBlockStatus(BLOCK_ID blockID);
BOOL FMD_SetBlockStatus(BLOCK_ID blockID, DWORD dwStatus);

BOOL  FMD_ReadSector (SECTOR_ADDR startSectorAddr, LPBYTE pSectorBuff, PSectorInfo pSectorInfoBuff, DWORD dwNumSectors);
BOOL  FMD_WriteSector(SECTOR_ADDR startSectorAddr, LPBYTE pSectorBuff, PSectorInfo pSectorInfoBuff, DWORD dwNumSectors);

BOOL  FMD_EraseBlock(BLOCK_ID blockID);

VOID  FMD_PowerUp(VOID);
VOID  FMD_PowerDown(VOID);

BOOL  FMD_OEMIoControl(DWORD dwIoControlCode, PBYTE pInBuf, DWORD nInBufSize,
                       PBYTE pOutBuf, DWORD nOutBufSize, PDWORD pBytesReturned);

BOOL CheckMT29FBadBlock(BLOCK_ID blockID);

BOOL ReplaceBadBlockSign(void);

BOOL CreateNv(void);
BOOL InitNv(void);
BOOL ReplaceNvBlock(DWORD dwBlock);
BOOL WriteNv(DWORD dwAddress, PBYTE pDatabuf, DWORD dwLength, PDWORD pBytesReturned);
BOOL ReadNv(DWORD dwAddress, PBYTE pDatabuf, DWORD dwLength, PDWORD pBytesReturned);
BOOL CheckNV(void);

//---------------------------------------- Helper Functions ----------------------------------------

#define MIN(a, b)   (a)<(b)?(a):(b)
#define MAX(a, b)   (a)>(b)?(a):(b)

/* NV项参数的定义 */

/* 定义NV项所占据的空间 */
#define NV_START_BLOCK      4   /* NV项起始的Block */
#define NV_MAX_BLOCK        12  /* NV项所占最多的Block数 */
#define NV_BLOCK_NUM        4   /* NV项所占的Block数 */

/* 定义NV项参数 */
#define PARA_START_ADDR                         0x80000
#define PARA_MAX_LENGTH                         0x40000


#define NV_HKADC_ADDR                           PARA_START_ADDR
#define NV_HKADC_LENGTH                         FLASH_SECTOR_SIZE
#define NV_BTMAC_ADDR                           (NV_HKADC_ADDR + NV_HKADC_LENGTH)
#define NV_BTMAC_LENGTH                         FLASH_SECTOR_SIZE
#define NV_SYSTEMFLAG_ADDR                      (NV_BTMAC_ADDR + NV_BTMAC_LENGTH)
#define NV_SYSTEMFLAG_LENGTH                    FLASH_SECTOR_SIZE
#define NV_MODEMFLAG_ADDR                       (NV_SYSTEMFLAG_ADDR + NV_SYSTEMFLAG_LENGTH)
#define NV_MODEMFLAG_LENGTH                     FLASH_SECTOR_SIZE
#define NV_PRODUCTIONPARAM_ADDR                 (NV_MODEMFLAG_ADDR + NV_MODEMFLAG_LENGTH)
#define NV_PRODUCTIONPARAM_LENGTH               FLASH_SECTOR_SIZE
#define NV_CUSTOMERPARAM_ADDR                   (NV_PRODUCTIONPARAM_ADDR + NV_PRODUCTIONPARAM_LENGTH)
#define NV_CUSTOMERPARAM_LENGTH                 FLASH_SECTOR_SIZE
#define NV_REBOOTFLAG_ADDR                      (NV_CUSTOMERPARAM_ADDR + NV_CUSTOMERPARAM_LENGTH)
#define NV_REBOOTFLAG_LENGTH                    FLASH_SECTOR_SIZE
#define NV_VERSIONFLAG_ADDR                     (NV_REBOOTFLAG_ADDR + NV_REBOOTFLAG_LENGTH)
#define NV_VERSIONFLAG_LENGTH                   FLASH_SECTOR_SIZE
#define NV_TESTMODE_ADDR                        (NV_VERSIONFLAG_ADDR + NV_VERSIONFLAG_LENGTH)
#define NV_TESTMODE_LENGTH                      FLASH_SECTOR_SIZE
#define NV_BDADDRFLAG_ADDR                      NV_TESTMODE_ADDR + NV_TESTMODE_LENGTH
#define NV_BDADDR_LENGTH                        FLASH_SECTOR_SIZE
#define NV_LTKFLAG_ADDR                         NV_BDADDRFLAG_ADDR + NV_BDADDR_LENGTH
#define NV_LTKADDR_LENGTH                       FLASH_SECTOR_SIZE

#define NV_NEWIMG_ADDR                          NV_LTKFLAG_ADDR + NV_LTKADDR_LENGTH
#define NV_NEWIMG_LENGTH                        FLASH_SECTOR_SIZE

/*typedef struct
{
    ULONG  Signature;           // Config signature (used to validate).
    USHORT VerMajor;            // Config major version.
    USHORT VerMinor;            // Config minor version.
    ULONG  ConfigFlags;         // General bootloader flags.
    ULONG  IPAddr;              // Device static IP address.
    ULONG  CleanBoot;           // clean boot mode flags:0 is nomal other is clean mode.
    ULONG  fUpdateMode;         // Is the device in update mode?
    ULONG  SubnetMask;          // Device subnet mask.
    BYTE   BootDelay;           // Bootloader count-down delay.
    BYTE   LoadDeviceOrder;     // Search order for download devices.
    USHORT USBRNDISMAC[3];      // Crystal USB-RNDIS MAC address.
    ULONG  LaunchAddress;       // Kernel region launch address.
    ULONG  ModemFlag;            //modem adjust flag
} BOOT_CFG, *PBOOT_CFG;*/

typedef struct
{
    UINT8 ucUpdateMode;
    UINT8 ucCleanBoot;
    UINT8 ucRev1;
    UINT8 ucRev2;
}BOOT_FLAG, PBOOT_FLAG;

typedef struct _SYSTEM_FLAG_INFO{
    UINT32 m_cleanBootfg;                       //恢复出厂设置标志位
    UINT32 m_updatefg;                          //软件升级标志位
} SYSTEM_FLAG_INFO, *PSYSTEM_FLAG_INFO;

typedef struct _MODEM_FLAG_INFO{
    UINT32 m_modemfg;                           //校准通道标志位
} MODEM_FLAG_INFO, *PMODEM_FLAG_INFO;

typedef struct _HKADC_OFFSET_INFO{
    UINT32 m_calfg;                             //是否校准完成标志位
    int    m_Offset_1[2];                       //HKADC校准参数1
    int    m_Offset_2[2];                       //HKADC校准参数2
    int    m_Offset_3[2];                       //HKADC校准参数3
    int    m_Offset_4[2];                       //HKADC校准参数4
    int    m_Offset_5[2];                       //HKADC校准参数5
    int    m_Offset_6[2];                       //HKADC校准参数6
    int    m_Offset_7[2];                       //HKADC校准参数7
    int    m_ChargFg;                           //充电标志位
    int    m_Vbat;                              //电池电压
}HKADC_OFFSET_INFO,*PHKADC_OFFSET_INFO;

typedef struct
{
    char cFSN[64];      /* 工厂序列号 */
    char cMSN[64];      /* 制造商序列号 */
    long lFSNFlag;      /* FSN写入标识 */
    long lMSNFlag;      /* MSN写入标识 */
    long lCTFlag;       /* 校准完成标识 */
    long lFTFlag;       /* 终测完成标识 */
    long lBMMIFlag;     /* 板级MMI完成标识 */
    long lAMMIFlag;     /* 组装MMI完成标识 */
    long lMTFlag;       /* 整机测试完成标识 */
    long lIMEIFlag;     /* IMEI写入标识 */
} PRODUCTION_PARAM_STRU;

typedef struct  __bd_addr {
    union {
        struct {
            unsigned int LAP : 24;  // Lower address part
            unsigned int UAP : 8;   // Upper address part
        };
        unsigned int SAP;           // Significant address part
    };

    unsigned short NAP;             // Non-significant address part
} BD_ADDR;

typedef struct _TEST_MODULE_INFO{
    UINT32 m_TestModeFg;                       //测试模式标志位.Bit 0:USB Module
} TEST_MODULE_INFO, *PTEST_MODULE_INFO;

typedef struct _BT_ADDR_INFO{
    UINT32   uiBdrflag;                             /*蓝牙地址写入标志*/
    BD_ADDR  bdr;                                   /*NV项蓝牙地址*/
}BT_ADDR_INFO, *PBT_ADDR_INFO;

#define MAX_CUSTOM_BLOCK	800						/* 限制Custom最大为100MB，800*128KB */

typedef struct _NEW_IMG_INFO{
    DWORD   dwStartBlockAddress;                   /*客户定制映象起始地址*/
    DWORD   dwLength;                              /*客户定制映象长度*/
    DWORD   dwNewImgUpdataFlag;                    /*客户定制映象更新完成标志*/
    DWORD   dwNewImgLoadFlag;                      /*客户定制映象拷贝完成标志*/
}NEW_IMG_INFO, *PNEW_IMG_INFO;


#endif