packages/hal/arm/mx53/karo/v1_0/include/karo_tx53.h

   1 #ifndef CYGONCE_KARO_TX53_H
   2 #define CYGONCE_KARO_TX53_H
   3
   4 //=============================================================================
   5 //
   6 //      Platform specific support (register layout, etc)
   7 //
   8 //=============================================================================
   9 //####ECOSGPLCOPYRIGHTBEGIN####
  10 // -------------------------------------------
  11 // This file is part of eCos, the Embedded Configurable Operating System.
  12 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
  13 //
  14 // eCos is free software; you can redistribute it and/or modify it under
  15 // the terms of the GNU General Public License as published by the Free
  16 // Software Foundation; either version 2 or (at your option) any later version.
  17 //
  18 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
  19 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  20 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  21 // for more details.
  22 //
  23 // You should have received a copy of the GNU General Public License along
  24 // with eCos; if not, write to the Free Software Foundation, Inc.,
  25 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  26 //
  27 // As a special exception, if other files instantiate templates or use macros
  28 // or inline functions from this file, or you compile this file and link it
  29 // with other works to produce a work based on this file, this file does not
  30 // by itself cause the resulting work to be covered by the GNU General Public
  31 // License. However the source code for this file must still be made available
  32 // in accordance with section (3) of the GNU General Public License.
  33 //
  34 // This exception does not invalidate any other reasons why a work based on
  35 // this file might be covered by the GNU General Public License.
  36 //
  37 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
  38 // at http://sources.redhat.com/ecos/ecos-license/
  39 // -------------------------------------------
  40 //####ECOSGPLCOPYRIGHTEND####
  41 //===========================================================================
  42
  43 #include <cyg/hal/hal_soc.h>    // Hardware definitions
  44 #include <cyg/hal/mx53_iomux.h>
  45
  46 #include CYGHWR_MEMORY_LAYOUT_H
  47
  48 #define GPIO_DR                                         0x00
  49 #define GPIO_GDIR                                       0x04
  50 #define GPIO_PSR                                        0x08
  51
  52 #define STK5_LED_MASK                           (1 << 20)
  53 #define STK5_LED_REG_ADDR                       (GPIO2_BASE_ADDR + GPIO_DR)
  54
  55 #define LED_MAX_NUM                                     1
  56
  57 #define SOC_FEC_MAC_BASE                        (IIM_BASE_ADDR + 0xc24)
  58
  59 #define TX53_SDRAM_SIZE                         SDRAM_SIZE
  60
  61 #define LED_IS_ON(n) ({                                                 \
  62         CYG_WORD32 __val;                                                       \
  63         HAL_READ_UINT32(STK5_LED_REG_ADDR, __val);      \
  64         __val & STK5_LED_MASK;                                          \
  65 })
  66
  67 #define TURN_LED_ON(n)                                                  \
  68         CYG_MACRO_START                                                         \
  69         CYG_WORD32 __val;                                                       \
  70         HAL_READ_UINT32(STK5_LED_REG_ADDR, __val);      \
  71         __val |= STK5_LED_MASK;                                         \
  72         HAL_WRITE_UINT32(STK5_LED_REG_ADDR, __val);     \
  73         CYG_MACRO_END
  74
  75 #define TURN_LED_OFF(n)                                                 \
  76         CYG_MACRO_START                                                         \
  77         CYG_WORD32 __val;                                                       \
  78         HAL_READ_UINT32(STK5_LED_REG_ADDR, __val);      \
  79         __val &= ~STK5_LED_MASK;                                        \
  80         HAL_WRITE_UINT32(STK5_LED_REG_ADDR, __val);     \
  81         CYG_MACRO_END
  82
  83 #define BOARD_DEBUG_LED(n)                                              \
  84         CYG_MACRO_START                                                         \
  85         if (n >= 0 && n < LED_MAX_NUM) {                        \
  86                 if (LED_IS_ON(n))                                               \
  87                         TURN_LED_OFF(n);                                        \
  88                 else                                                                    \
  89                         TURN_LED_ON(n);                                         \
  90         }                                                                                       \
  91         CYG_MACRO_END
  92
  93 #define BLINK_LED(l, n)                                                 \
  94         CYG_MACRO_START                                                         \
  95         int _i;                                                                         \
  96         for (_i = 0; _i < (n); _i++) {                          \
  97                 BOARD_DEBUG_LED(l);                                             \
  98                 HAL_DELAY_US(200000);                                   \
  99                 BOARD_DEBUG_LED(l);                                             \
 100                 HAL_DELAY_US(300000);                                   \
 101         }                                                                                       \
 102         HAL_DELAY_US(1000000);                                          \
 103         CYG_MACRO_END
 104
 105 #if !defined(__ASSEMBLER__)
 106 extern int tx53_fuse_voltage(int on);
 107 #define FUSE_PROG_START()               tx53_fuse_voltage(1)
 108 #define FUSE_PROG_DONE()                tx53_fuse_voltage(0)
 109
 110 void mxc_ipu_iomux_config(void);
 111
 112 enum {
 113         BOARD_TYPE_TX53KARO,
 114 };
 115
 116 #define gpio_tst_bit(__grp, __gpio)                             \
 117         CYG_MACRO_START                                                         \
 118         CYG_ADDRESS addr = MX53_GPIO_ADDR(__grp);       \
 119         CYG_WORD32 val;                                                         \
 120                                                                                                 \
 121         if (addr == 0)                                                          \
 122                 return;                                                                 \
 123         if (__gpio < 0 || __gpio >= GPIO_NUM_PIN) {     \
 124                 return 0;                                                               \
 125         }                                                                                       \
 126         HAL_READ_UINT32(addr + GPIO_PSR, val);          \
 127         return !!(val & (1 << __gpio));                         \
 128         CYG_MACRO_END
 129
 130 #define gpio_set_bit(__grp, __gpio)                                                             \
 131         CYG_MACRO_START                                                                                         \
 132         CYG_WORD32 val;                                                                                         \
 133         CYG_ADDRESS addr = MX53_GPIO_ADDR(__grp);                                       \
 134                                                                                                                                 \
 135         if (addr == 0)                                                                                          \
 136                 return;                                                                                                 \
 137         if (__gpio < 0 || __gpio >= GPIO_NUM_PIN)                                       \
 138                 return;                                                                                                 \
 139                                                                                                                                 \
 140         HAL_READ_UINT32(addr + GPIO_DR, val);                                           \
 141         HAL_WRITE_UINT32(addr + GPIO_DR, val | (1 << __gpio));          \
 142                                                                                                                                 \
 143         HAL_READ_UINT32(addr + GPIO_GDIR, val);                                         \
 144         HAL_WRITE_UINT32(addr + GPIO_GDIR, val | (1 << __gpio));        \
 145         CYG_MACRO_END
 146
 147 #define gpio_clr_bit(__grp, __gpio)                                                             \
 148         CYG_MACRO_START                                                                                         \
 149         CYG_WORD32 val;                                                                                         \
 150         CYG_ADDRESS addr = MX53_GPIO_ADDR(__grp);                                       \
 151                                                                                                                                 \
 152         if (addr == 0)                                                                                          \
 153                 return;                                                                                                 \
 154         if (__gpio < 0 || __gpio >= GPIO_NUM_PIN)                                       \
 155                 return;                                                                                                 \
 156                                                                                                                                 \
 157         HAL_READ_UINT32(addr + GPIO_DR, val);                                           \
 158         HAL_WRITE_UINT32(addr + GPIO_DR, val & ~(1 << __gpio));         \
 159                                                                                                                                 \
 160         HAL_READ_UINT32(addr + GPIO_GDIR, val);                                         \
 161         HAL_WRITE_UINT32(addr + GPIO_GDIR, val | (1 << __gpio));        \
 162         CYG_MACRO_END
 163
 164 #endif /* __ASSEMBLER__ */
 165
 166 #endif /* CYGONCE_KARO_TX53_H */