functions.h

i.MX31 NOR_flash(SPANSION_S71WS256ND0) bootloader src

/*----------------------------------------------------------------------
* FILE:  functions.h
*-----------------------------------------------------------------------
*             (C) Copyright 2001 Metrowerks Corp.
*                 ALL RIGHTS RESERVED .
*
*   THIS IS  CONFIDENTIAL  PROPRIETARY SOURCE CODE OF METROWERKS CORP.
*
*          The copyright notice above does not evidence any
*         actual or intended publication of such source code.
*-----------------------------------------------------------------------
*
* DESCRIPTION: Diagnostic board test on the TORTOLA (i.mx31) board
*              Defines file for common functions
*
* REFERENCES: 
*      1) TORTOLA spec
*
* HISTORY:
*
* 01 Feb  2005 zeldal	Created
*
*--------------------------------------------------------------------------*/
#ifndef FUNCTIONS_H
#define FUNCTIONS_H

// #####   EXPORTED MACROS   ########################################################### {{{1


//----------------------------------------------------------------------
//  Some Genaral Macros
//----------------------------------------------------------------------
#define FALSE		0
#define TRUE		1

#define DUMMY_INFO 0xf00f00


//----------------------------------------------------------------------
//  Basic Read/Write Macros
//----------------------------------------------------------------------
//{{{2
// ===  MACRO ======================================================================
// 
//         Name:  regN_read(addr)
// 
//  Description:  Basic Register Read/Write Macros -returns register value
//                N = 8,16,32 - access size
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in: WORD              addr 
//    in-out:  
//       out: BYTE/HALF/WORD                    value returned by macro, type depends on
//                                              N
//    return:  
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 13:37:12 IST
//  Revision:  none
// =====================================================================================
#define reg8_read(addr)       *((BYTE *)(addr))
#define reg16_read(addr)      *((HALF *)(addr))
#define reg32_read(addr)      *(WORD *)((addr))

// ===  MACRO  ======================================================================
// 
//         Name:  regN_write(addr,val)
// 
//  Description:  Basic Register Read/Write Macros - writes val to addr
//                N = 8,16,32 - access size
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in:  WORD             addr            address to access
//        in:  BYTE/HALF/WORD   val             value to write,  Type depends on N       
//    in-out:  
//       out:  
//    return:  
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 13:38:31 IST
//  Revision:  none
// =====================================================================================
#define reg8_write(addr,val)  *((BYTE *)(addr)) = (val)
#define reg16_write(addr,val) *((HALF *)(addr)) = (val)
#define reg32_write(addr,val) *((WORD *)(addr)) = (val)


// ===  MACRO ======================================================================
// 
//         Name:  memN_read(addr)
// 
//  Description:  Basic Memory Read/Write Macros - returns memory value
//                N = 8,16,32 - access size
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in: WORD              addr 
//    in-out:  
//       out: BYTE/HALF/WORD                    value returned by macro, type depends on
//                                              N
//    return:  
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 13:37:12 IST
//  Revision:  none
// =====================================================================================
#define mem8_read(addr)       *((BYTE *)(addr))
#define mem16_read(addr)      *((HALF *)(addr))
#define mem32_read(addr)      *(WORD *)((addr))

// ===  MACRO  ======================================================================
// 
//         Name:  memN_write(addr,val)
// 
//  Description:  Basic Memory Read/Write Macros - writes val to addr
//                N = 8,16,32 - access size
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in:  WORD             addr            address to access
//        in:  BYTE/HALF/WORD   val             value to write,  Type depends on N       
//    in-out:  
//       out:  
//    return:  
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 13:38:31 IST
//  Revision:  none
// =====================================================================================
#define mem8_write(addr,val)  *((BYTE *)(addr)) = (val)
#define mem16_write(addr,val) *((HALF *)(addr)) = (val)
#define mem32_write(addr,val) *((WORD *)(addr)) = (val)

//2}}}

//----------------------------------------------------------------------
//  Read and Compare Macros
//----------------------------------------------------------------------
//{{{2
// ===  MACRO     ======================================================================
// 
//         Name:  regN_read_tst
// 
//  Description:  Read data from a given register,and check Vs. expected value.
//                N=8,16,32
//         
//    Examples:  reg8_read_tst(OWIRE_TIME_DIV,0x12,0ff)
//               Here we read 8 bits from an 8-bit register OWIRE_TIME_DIV of OWIRE, 
//               and expect all 8 bits to be equal to 0x12
//
//               reg16_read_tst(WDOG_WSR,0x1212,0x00ff)
//               Here we read 16 bits from a 16-bit register WDOG_WSR of WDOG,
//               and expect only the lower 8 bits to be equal to 0x12
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in: WORD              reg_addr        address of register
//        in: BYTE/HALF/WORD    expect_val      expected value, type depends on N
//        in: BYTE/HALF/WORD    mask            bit mask, select bits to compare,
//                                              type depends on N
//    in-out:  
//       out:  
//    return: int                               pass(0)/fail(1) value   
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 13:55:41 IST
//  Revision:  none
// =====================================================================================
#define reg8_read_tst(reg_addr,expect_val,mask) (compare_results(reg_addr,expect_val & mask,reg8_read(reg_addr) & mask))
#define reg16_read_tst(reg_addr,expect_val,mask) (compare_results(reg_addr,expect_val & mask,reg16_read(reg_addr) & mask))
#define reg32_read_tst(reg_addr,expect_val,mask) (compare_results(reg_addr,expect_val & mask,reg32_read(reg_addr) & mask))


// ===  MACRO     ======================================================================
// 
//         Name:  memN_read_tst
// 
//  Description: Identical to regN_read_tst, used for memory read and compare 
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in: WORD              reg_addr        address to accedd
//        in: BYTE/HALF/WORD    expect_val      expected value, type depends on N
//        in: BYTE/HALF/WORD    mask            bit mask, select bits to compare,
//                                              type depends on N
//    in-out:  
//       out:  
//    return: int                               pass(0)/fail(1) value   
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 13:56:04 IST
//  Revision:  none
// =====================================================================================
#define mem8_read_tst(reg_addr,expect_val,mask) (compare_results(reg_addr,expect_val & mask,reg8_read(reg_addr) & mask))
#define mem16_read_tst(reg_addr,expect_val,mask) (compare_results(reg_addr,expect_val & mask,reg16_read(reg_addr) & mask))
#define mem32_read_tst(reg_addr,expect_val,mask) (compare_results(reg_addr,expect_val & mask,reg32_read(reg_addr) & mask))

//2}}}

//----------------------------------------------------------------------
//  Specific bits manipulation Macros
//----------------------------------------------------------------------
//{{{2
// ===  MACRO     ======================================================================
// 
//         Name:  regNsetbit
// 
//  Description:  Set specific bit in a register
//                N=8,16,32
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in:  WORD             addr            register address
//        in:  unsigned         bitpos          position of bit to set [0..N-1]
//    in-out:  
//       out:  
//    return:  
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 14:12:30 IST
//  Revision:  none
// =====================================================================================
#define  reg8setbit(addr,bitpos) \
         reg8_write((addr),(reg8_read((addr)) | (1<<(bitpos))))

#define  reg16setbit(addr,bitpos) \
         reg16_write((addr),(reg16_read((addr)) | (1<<(bitpos))))

#define  reg32setbit(addr,bitpos) \
         reg32_write((addr),(reg32_read((addr)) | (1<<(bitpos))))


// ===  MACRO     ======================================================================
// 
//         Name:  regNclrbit
// 
//  Description:  Clear specific bit in a register
//                N=8,16,32
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in:  WORD             addr            register address
//        in:  unsigned         bitpos          position of bit to clear [0..N-1]
//    in-out:  
//       out:  
//    return:  
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 14:16:03 IST
//  Revision:  none
// =====================================================================================
#define  reg8clrbit(addr,bitpos) \
         reg8_write((addr),(reg8_read((addr)) & (0xFF ^ (1<<(bitpos)))))

#define  reg16clrbit(addr,bitpos) \
         reg16_write((addr),(reg16_read((addr)) & (0xFFFF ^ (1<<(bitpos)))))

#define  reg32clrbit(addr,bitpos) \
         reg32_write((addr),(reg32_read((addr)) & (0xFFFFFFFF ^ (1<<(bitpos)))))

//2}}}

//----------------------------------------------------------------------
//  Interrupts Handling
//----------------------------------------------------------------------
//{{{2    
// ===  MACRO     ======================================================================
// 
//         Name: CAPTURE_INTERRUPT 
// 
//  Description:  assign a user handler routine to specific IRQ,
//                and override default routine
//                by default all interrupts are enabled, and will produce an 
//                error event
//  example: CAPTURE_INTERRUPT(GPT_INT_ROUTINE,my_int_handler)
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in:  WORD             irq_addr           default irq handler address
//        in:  function name    handler_routine    user supplied handler
//    in-out:  
//       out:  
//    return:  
// -------------------------------------------------------------------------------------
//    Author:  
//   Created:  03/01/04 13:45:53 IST
//  Revision:  none
// =====================================================================================
#define CAPTURE_INTERRUPT(irq_addr,handler_routine) mem32_write((irq_addr),(WORD)(handler_routine))



// ===  MACRO     ======================================================================
// 
//         Name:  setup_irq_hdler
// 
//  Description:  Bind  handler routine to certain FIQ (Fast IRQ),
//                by using interrupt number, or name (macro).
//                (while CAPTURE_INTERRUPT - uses handler routine address to override)
//                recommendation: use the name macro, and NOT the absolute number
//                
//
//      Examples: setup_irq_hdler(29,my_int_handler)  or, 
//                setup_irq_hdler(GPT_INT,my_int_handler)
// 
// - PARAMETER -------------------------------------------------------------------------
//      Mode   Type             Name            Description
// -------------------------------------------------------------------------------------
//        in: WORD              int_name        interrupt number (or macro name) 
//        in: WORD              func_ptr        function name
//    in-out: