type.h

CF卡读卡程序

/*
; ***********************************************************************
; *             Intel Corporation                                       *
; *             Copyright (C) Intel Corporation 1994-97                 *
; *             All Rights Reserved.                                    *
; ***********************************************************************
; ***********************************************************************
;    INTEL OEM SOFTWARE LICENSE AGREEMENT
;
; BY USING THIS SOFTWARE, YOU ARE AGREEING TO BE BOUND BY THE TERMS OF THIS 
; AGREEMENT.  DO NOT USE THE SOFTWARE UNTIL YOU HAVE CAREFULLY READ AND AGREED 
; TO THE FOLLOWING TERMS AND CONDITIONS.  IF YOU DO NOT AGREE TO THE TERMS OF
; THIS AGREEMENT, PROMPTLY RETURN THE SOFTWARE PACKAGE AND ANY ACCOMPANYING
; ITEMS. YOU MUST BE AN ORIGINAL EQUIPMENT MANUFACTURER ("OEM") SYSTEM
; DEVELOPER TO ACQUIRE ANY RIGHTS IN THE SOFTWARE UNDER THIS LICENSE AGREEMENT.
;
; LICENSE: Intel Corporation ("Intel") grants you the non-exclusive and
; royalty-free right to use the enclosed software program ("Software") in
; source code form on the terms set forth below.  You will not use, copy,
; modify, rent, sell or transfer the Software or any portion thereof, except
; as provided in this Agreement.
;
; OEM System Developers may:
;
; 1. Copy the Software for support, backup or archival purposes;
; 2. Install or distribute the Software in object code form only;
; 3. Modify and/or use Software source code that Intel directly ships to you
;    as an OEM;
; 4. Allow authorized contractors ("Subcontractors") engaged by You for the
;    sole purpose of product development work to have access to the Software
;    solely for that purpose.  Subcontractors do NOT acquire any of the OEM
;    rights to the Software provided in this Agreement;
; 5. Install, use, modify, distribute, and/or make or have made derivative
;    works based on the Software ("Derivatives") subject to the terms and
;    conditions in this Agreement.
;
; RESTRICTIONS:
; YOU WILL NOT:
;
; 1.  Copy, disclose or distribute the Software, in whole or in part, except 
;     as provided for in this Agreement;
; 2.  Remove or modify the "Compatibility" module, if any,  in the Software or
;     in any Derivative work,
; 3.  Decompile or reverse engineer any Software  delivered in object code form.
; 
; TRANSFER:  Except as provided above, you may not transfer or disclose the
; Software to another party .
;
; OWNERSHIP AND COPYRIGHT OF SOFTWARE: Title to the Software and all copies
; thereof remain with Intel.  The Software is copyrighted and is protected by
; United States and international copyright laws.  You will not remove the
; copyright notice from the Software.  You agree to prevent any unauthorized
; copying of the Software.
;
; DERIVATIVE WORK: You will not be required to provide Intel with a copy of the
; source or object code for any Derivatives created by You.   You are authorized
; to use, market, sell, and/or distribute Derivatives, other than any source
; code for the Software, at your own risk and expense. Title to Derivatives,
; other than the portion of the Derivative consisting of any of the Software,
; shall remain with you.
;
; CONFIDENTIALITY: You will maintain the confidentiality of the source code for
; the Software with at least the same degree of care that you use to protect
; your own confidential and proprietary information, but with no less than a
; reasonable degree under the circumstances. Disclosure will only be made to
; Your employees on a need-to-know basis. Subject to the licenses granted
; hereunder, You agree to maintain the Software source code and all other
; proprietary information relating to the Software in confidence and shall not
; disclose to others any such source code or other Intel proprietary information
; relating to the Software. Any Subcontractors to whom you disclose the source
; code for the Software must sign a written confidentiality agreement which
; contains terms regarding the Software no less restrictive than those set forth
; in this Agreement.
;
; DUAL MEDIA SOFTWARE:  If the Software package contains multiple media, you
; may only use the medium appropriate for your system.
; 
; WARRANTY:  The Software is provided "AS IS". Intel warrants that the media on
; which the Software is furnished will be free from defects in material and
; workmanship for a period of one (1) year from the date of purchase.  Upon
; return of such defective media, Intel's entire liability and your exclusive
; remedy shall be the replacement of the Software.
; 
; THE ABOVE WARRANTIES ARE THE ONLY WARRANTIES OF ANY KIND GIVEN BY INTEL UNDER
; THIS AGREEMENT. INTEL SPECIFICALLY DISCLAIMS ANY OTHER WARRANTIES, EXPRESS OR
; IMPLIED, INCLUDING WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT OR FITNESS
; FOR ANY PARTICULAR PURPOSE.
;
; LIMITATION OF LIABILITY:    NEITHER INTEL NOR ITS VENDORS OR AGENTS SHALL BE
; LIABLE FOR ANY LOSS OF PROFITS, LOSS OF USE, LOSS OF DATA, INTERRUPTION OF
; BUSINESS, NOR FOR INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF
; ANY KIND WHETHER UNDER THIS AGREEMENT OR OTHERWISE, EVEN IF ADVISED OF THE
; POSSIBILITY OF SUCH DAMAGES.
;
; TERMINATION OF THIS LICENSE:  Intel reserves the right to conduct or have
; conducted audits to verify your compliance with this Agreement.  Intel may
; terminate this Agreement at any time if you are in breach of any of its terms
; and conditions.  Upon termination, you will immediately destroy, and certify
; in writing the destruction of, the Software or return all copies of the
; Software and documentation to Intel.
;
; U.S. GOVERNMENT RESTRICTED RIGHTS:  The Software and documentation were
; developed at private expense and are provided with "RESTRICTED RIGHTS".
; Use, duplication or disclosure by the Government is subject to restrictions
; as set forth in FAR52.227-14 and DFAR252.227-7013 et seq. or its successor.
;
; EXPORT LAWS:  You agree that the distribution and export/re-export of the
; Software is in compliance with the laws, regulations, orders or other
; restrictions of the U.S. Export Administration Regulations.
;
; APPLICABLE LAW:  This Agreement is governed by the laws of the State of
; Delaware and the United States, including patent and copyright laws.  Any
; claim arising out of this Agreement will be brought in Santa Clara County,
; California.
;*************************************************************************
*/


#ifndef TYPE_H
#define TYPE_H

#define FALSE                                   				0
#define TRUE                                    				1

#define ERR_NONE                                                0
#define ERR_READ                                                1
#define ERR_WRITE                                               2
#define ERR_PARAM                                               3
#define ERR_ERASE                                               4
#define ERR_JEDEC                                               5
#define ERR_WRITE_PROTECT                                       6
#define ERR_BUSY                                                7
#define ERR_DETECT                                              8
#define ERR_LOCK                                                9
#define ERR_CFG													10
#define ERR_NOT_FOUND                                           0xFFFF

#define SWAP              FALSE /* if processor requires data swapping set 
                                   to true */

#define FALCON            FALSE /* if want to use 28F016SA chips set to true */

#define SEGMENTED         TRUE  /* If the machine is a segmented architecture
                                   set to true if using segmented architecture 
                                   you can use pcic.asm as reference to link, 
                                   otherwise use arch.c as reference */

#define ERASE_BACKGROUND  FALSE /* set to true if want to use erase_suspend
                                   and erase_resume, otherwise erase occurs
                                   in foreground */


#define SRAM_MEDIA        FALSE /* set to true if want to support SRAM */

/*****-----------------------------------------------------------------*****/
/*****       Set these correctly or virtually NOTHING will work!       *****/
/*****-----------------------------------------------------------------*****/

#define SMARTSLIDE TRUE    /* Defines whether or not the SlideMemoryWindow */
/* is smart enough to decide if the window has moved. If it is not, then   */
/* we need to do this calculation (and lose a DWORD worth of global mem)   */
/* so that it dosen't take all day when we change positions. If the         */
/* SlideMemoryWindow function is very fast, or efficient, leave it on.     */
/* If you need that DWORD worth of RAM free, then leave this on. Otherwise,*/
/* turn it off so that it will only call the function when it is needed,   */
/* speeding things up. (This does increase code size, however, by a        */
/* significant amount as a result of inlining the checks.)                 */

#define WINDOWED   TRUE    /* Defines if the system we are running on      */
/* accesses the card through a window that needs moving, or is a system    */
/* that maps in the entire card at once, therefore removing the need for   */
/* a SlideMemoryWindow function call. With this TRUE, it will call the     */
/* SlideMemoryWindow function every time the program needs to change the   */
/* position of a pointer drastically (i.e. not plus 1).                    */



/**************************************************************************
 * PORTING DEFINE SECTION * PORTING DEFINE SECTION *
 *
 * The following defines must be evaluated to determine the appropriate
 * value for the user system.
 *************************************************************************/
/* If it is a segmented machine, these then have to be far, and a word is
 usually a short rather then an int. */
#if SEGMENTED
#define FAR_PTR      far *
#define WORD_TYPE int
#else
#define FAR_PTR      *
#define WORD_TYPE short
#endif

typedef unsigned char BYTE;           /* Change to =  8 bits unsigned */
typedef WORD_TYPE  SWORD;             /* Change to = 16 bits signed */
typedef unsigned WORD_TYPE  WORD;     /* Change to = 16 bits unsigned */
typedef long   SDWORD;                /* Change to = 32 bits signed */
typedef unsigned long DWORD;          /* Change to = 32 bits unsigned */

typedef BYTE * BYTE_PTR;              /* Change to =  8 bit unsigned pointer */
typedef WORD  * WORD_PTR;             /* Change to = 16 bit unsigned pointer */
typedef DWORD * DWORD_PTR;            /* Change to = 32 bit unsigned pointer */
typedef void * VOID_PTR;

typedef BYTE FAR_PTR FULL_BYTE_PTR;   /* Change to =  8 bit unsigned far pointer */
typedef WORD  FAR_PTR FULL_WORD_PTR;  /* Change to = 16 bit unsigned far pointer */
typedef DWORD FAR_PTR FULL_DWORD_PTR; /* Change to = 32 bit unsigned far pointer */
typedef void FAR_PTR  FULL_VOID_PTR;

/* used to read directly from Flash during initialization */
#define MC_ADDR                                   0xD0000000/* Window address */
#define MC_WIND_MSK                               0x00000FFF  /* Window size of 4M mask*/

#define ERASE_TIME_LIMIT        0x80000 /* erase loop limit, since the erase 
                                             can occur in the bcakground we 
                                             need to set a limit to error out.*/

#define PROGRAM_TIME_LIMIT       0x1000 /* program loop limit*/

#define TIME_LIMIT(uSec) (uSec*50)
#endif