arch/arm/include/asm/arch-sc8810/sc8810_plf_io.h

   1 /******************************************************************************
   2  ** File Name:    sc8810_plf_io.h                                            *
   3  ** Author:       Tim.Luo                                                    *
   4  ** DATE:         07/08/2010                                                  *
   5  ** Copyright:    2010  Spreatrum, Incoporated. All Rights Reserved.           *
   6  ** Description:                                                              *
   7  ******************************************************************************/
   8 /******************************************************************************
   9  **                   Edit    History                                         *
  10  **---------------------------------------------------------------------------*
  11  ** DATE          NAME            DESCRIPTION                                 *
  12  ** 07/08/2010    Tim.Luo         Create.                                     *
  13  ******************************************************************************/
  14 #ifndef _SC8810_PLF_IO_H_
  15 #define _SC8810_PLF_IO_H_
  16 /*----------------------------------------------------------------------------*
  17  **                         Dependencies                                      *
  18  **------------------------------------------------------------------------- */
  19
  20 /**---------------------------------------------------------------------------*
  21  **                             Compiler Flag                                 *
  22  **--------------------------------------------------------------------------*/
  23 #ifdef   __cplusplus
  24 extern   "C"
  25 {
  26 #endif
  27 /**---------------------------------------------------------------------------*
  28 **                               Micro Define                                **
  29 **---------------------------------------------------------------------------*/
  30
  31 //#define DRV_LSBFIRST 1234
  32 //#define DRV_MSBFIRST 4321
  33 //#define DRV_BYTEORDER           DRV_MSBFIRST    // Big endian
  34 //
  35 //
  36 //#define DRV_INTERRUPT_FUNCTIONS_ENABLE
  37 //
  38 ////-----------------------------------------------------------------------------
  39 //// BYTE Register access.
  40 //// Individual and vectorized access to 8 bit registers.
  41 //
  42 //// Little-endian version or big-endian version that doesn't need address munging
  43 //#if (DRV_BYTEORDER == DRV_LSBFIRST) || defined(HAL_IO_MACROS_NO_ADDRESS_MUNGING)
  44 //
  45 //#define HAL_READ_UINT8( _register_, _value_ ) \
  46 //    ((_value_) = *((volatile DRV_BYTE *)(_register_)))
  47 //
  48 //#define HAL_WRITE_UINT8( _register_, _value_ ) \
  49 //    (*((volatile DRV_BYTE *)(_register_)) = (_value_))
  50 //
  51 //#define HAL_READ_UINT8_VECTOR( _register_, _buf_, _count_, _step_ )     \
  52 //    DRV_MACRO_START                                                     \
  53 //    drv_count32 _i_,_j_;                                                \
  54 //    for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_))     \
  55 //        (_buf_)[_i_] = ((volatile DRV_BYTE *)(_register_))[_j_];        \
  56 //    DRV_MACRO_END
  57 //
  58 //#define HAL_WRITE_UINT8_VECTOR( _register_, _buf_, _count_, _step_ )    \
  59 //    DRV_MACRO_START                                                     \
  60 //    drv_count32 _i_,_j_;                                                \
  61 //    for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_))     \
  62 //        ((volatile DRV_BYTE *)(_register_))[_j_] = (_buf_)[_i_];        \
  63 //    DRV_MACRO_END
  64 //
  65 //#define HAL_READ_UINT8_STRING( _register_, _buf_, _count_ )             \
  66 //    DRV_MACRO_START                                                     \
  67 //    drv_count32 _i_;                                                    \
  68 //    for( _i_ = 0; _i_ < (_count_); _i_++)                               \
  69 //        (_buf_)[_i_] = ((volatile DRV_BYTE *)(_register_))[_i_];        \
  70 //    DRV_MACRO_END
  71 //
  72 //#define HAL_WRITE_UINT8_STRING( _register_, _buf_, _count_ )            \
  73 //    DRV_MACRO_START                                                     \
  74 //    drv_count32 _i_;                                                    \
  75 //    for( _i_ = 0; _i_ < (_count_); _i_++)                               \
  76 //        ((volatile DRV_BYTE *)(_register_)) = (_buf_)[_i_];             \
  77 //    DRV_MACRO_END
  78 //
  79 //#else // Big-endian version
  80 //
  81 //#define HAL_READ_UINT8( _register_, _value_ ) \
  82 //    ((_value_) = *((volatile DRV_BYTE *)((DRV_ADDRWORD)(_register_)^3)))
  83 //
  84 //#define HAL_WRITE_UINT8( _register_, _value_ ) \
  85 //    (*((volatile DRV_BYTE *)((DRV_ADDRWORD)(_register_)^3)) = (_value_))
  86 //
  87 //#define HAL_READ_UINT8_VECTOR( _register_, _buf_, _count_, _step_ )     \
  88 //    DRV_MACRO_START                                                     \
  89 //    drv_count32 _i_,_j_;                                                \
  90 //    volatile DRV_BYTE* _r_ = ((DRV_ADDRWORD)(_register_)^3);            \
  91 //    for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_))     \
  92 //        (_buf_)[_i_] = _r_[_j_];                                        \
  93 //    DRV_MACRO_END
  94 //
  95 //#define HAL_WRITE_UINT8_VECTOR( _register_, _buf_, _count_, _step_ )    \
  96 //    DRV_MACRO_START                                                     \
  97 //    drv_count32 _i_,_j_;                                                \
  98 //    volatile DRV_BYTE* _r_ = ((DRV_ADDRWORD)(_register_)^3);            \
  99 //    for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_))     \
 100 //        _r_[_j_] = (_buf_)[_i_];                                        \
 101 //    DRV_MACRO_END
 102 //
 103 //#define HAL_READ_UINT8_STRING( _register_, _buf_, _count_ )             \
 104 //    DRV_MACRO_START                                                     \
 105 //    drv_count32 _i_;                                                    \
 106 //    volatile DRV_BYTE* _r_ = ((DRV_ADDRWORD)(_register_)^3);            \
 107 //    for( _i_ = 0; _i_ < (_count_); _i_++;                               \
 108 //            (_buf_)[_i_] = _r_[_i_];                                        \
 109 //            DRV_MACRO_END
 110 //
 111 //#define HAL_WRITE_UINT8_STRING( _register_, _buf_, _count_ )            \
 112 //    DRV_MACRO_START                                                     \
 113 //    drv_count32 _i_;                                                    \
 114 //    volatile DRV_BYTE* _r_ = ((DRV_ADDRWORD)(_register_)^3);            \
 115 //    for( _i_ = 0; _i_ < (_count_); _i_++)                               \
 116 //        _r_[_i_] = (_buf_)[_i_];                                        \
 117 //    DRV_MACRO_END
 118 //
 119 //#endif // Big-endian
 120 //
 121 ////-----------------------------------------------------------------------------
 122 //// 16 bit access.
 123 //// Individual and vectorized access to 16 bit registers.
 124 //
 125 //// Little-endian version or big-endian version that doesn't need address munging
 126 //#if (DRV_BYTEORDER == DRV_LSBFIRST) || defined(HAL_IO_MACROS_NO_ADDRESS_MUNGING)
 127 //
 128 //#define HAL_READ_UINT16( _register_, _value_ ) \
 129 //    ((_value_) = *((volatile DRV_WORD16 *)(_register_)))
 130 //
 131 //#define HAL_WRITE_UINT16( _register_, _value_ ) \
 132 //    (*((volatile DRV_WORD16 *)(_register_)) = (_value_))
 133 //
 134 //#define HAL_READ_UINT16_VECTOR( _register_, _buf_, _count_, _step_ )    \
 135 //    DRV_MACRO_START                                                     \
 136 //    drv_count32 _i_,_j_;                                                \
 137 //    for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_))     \
 138 //        (_buf_)[_i_] = ((volatile DRV_WORD16 *)(_register_))[_j_];      \
 139 //    DRV_MACRO_END
 140 //
 141 //#define HAL_WRITE_UINT16_VECTOR( _register_, _buf_, _count_, _step_ )   \
 142 //    DRV_MACRO_START                                                     \
 143 //    drv_count32 _i_,_j_;                                                \
 144 //    for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_))     \
 145 //        ((volatile DRV_WORD16 *)(_register_))[_j_] = (_buf_)[_i_];      \
 146 //    DRV_MACRO_END
 147 //
 148 //#define HAL_READ_UINT16_STRING( _register_, _buf_, _count_)             \
 149 //    DRV_MACRO_START                                                     \
 150 //    drv_count32 _i_;                                                    \
 151 //    for( _i_ = 0; _i_ < (_count_); _i_++)                               \
 152 //        (_buf_)[_i_] = ((volatile DRV_WORD16 *)(_register_))[_i_];      \
 153 //    DRV_MACRO_END
 154 //
 155 //#define HAL_WRITE_UINT16_STRING( _register_, _buf_, _count_)            \
 156 //    DRV_MACRO_START                                                     \
 157 //    drv_count32 _i_;                                                    \
 158 //    for( _i_ = 0; _i_ < (_count_); _i_++)                               \
 159 //        ((volatile DRV_WORD16 *)(_register_))[_i_] = (_buf_)[_i_];      \
 160 //    DRV_MACRO_END
 161 //
 162 //
 163 //#else // Big-endian version
 164 //
 165 //#define HAL_READ_UINT16( _register_, _value_ ) \
 166 //    ((_value_) = *((volatile DRV_WORD16 *)((DRV_ADDRWORD)(_register_)^3)))
 167 //
 168 //#define HAL_WRITE_UINT16( _register_, _value_ ) \
 169 //    (*((volatile DRV_WORD16 *)((DRV_ADDRWORD)(_register_)^3)) = (_value_))
 170 //
 171 //#define HAL_READ_UINT16_VECTOR( _register_, _buf_, _count_, _step_ )    \
 172 //    DRV_MACRO_START                                                     \
 173 //    drv_count32 _i_,_j_;                                                \
 174 //    volatile DRV_WORD16* _r_ = ((DRV_ADDRWORD)(_register_)^3);          \
 175 //    for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_))     \
 176 //        (_buf_)[_i_] = _r_[_j_];                                        \
 177 //    DRV_MACRO_END
 178 //
 179 //#define HAL_WRITE_UINT16_VECTOR( _register_, _buf_, _count_, _step_ )   \
 180 //    DRV_MACRO_START                                                     \
 181 //    drv_count32 _i_,_j_;                                                \
 182 //    volatile DRV_WORD16* _r_ = ((DRV_ADDRWORD)(_register_)^3);          \
 183 //    for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_))     \
 184 //        _r_[_j_] = (_buf_)[_i_];                                        \
 185 //    DRV_MACRO_END
 186 //
 187 //#define HAL_READ_UINT16_STRING( _register_, _buf_, _count_)             \
 188 //    DRV_MACRO_START                                                     \
 189 //    drv_count32 _i_;                                                    \
 190 //    volatile DRV_WORD16* _r_ = ((DRV_ADDRWORD)(_register_)^3);          \
 191 //    for( _i_ = 0 = 0; _i_ < (_count_); _i_++)                           \
 192 //        (_buf_)[_i_] = _r_[_i_];                                        \
 193 //    DRV_MACRO_END
 194 //
 195 //#define HAL_WRITE_UINT16_STRING( _register_, _buf_, _count_)            \
 196 //    DRV_MACRO_START                                                     \
 197 //    drv_count32 _i_;                                                    \
 198 //    volatile DRV_WORD16* _r_ = ((DRV_ADDRWORD)(_register_)^3);          \
 199 //    for( _i_ = 0 = 0; _i_ < (_count_); _i_++)                           \
 200 //        _r_[_i_] = (_buf_)[_i_];                                        \
 201 //    DRV_MACRO_END
 202 //
 203 //
 204 //#endif // Big-endian
 205 //
 206 ////-----------------------------------------------------------------------------
 207 //// 32 bit access.
 208 //// Individual and vectorized access to 32 bit registers.
 209 //
 210 //// Note: same macros for little- and big-endian systems.
 211 //
 212 //#define HAL_READ_UINT32( _register_, _value_ ) \
 213 //    ((_value_) = *((volatile DRV_WORD32 *)(_register_)))
 214 //
 215 //#define HAL_WRITE_UINT32( _register_, _value_ ) \
 216 //    (*((volatile DRV_WORD32 *)(_register_)) = (_value_))
 217 //
 218 //#define HAL_READ_UINT32_VECTOR( _register_, _buf_, _count_, _step_ )    \
 219 //    DRV_MACRO_START                                                     \
 220 //    drv_count32 _i_,_j_;                                                \
 221 //    for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_))     \
 222 //        (_buf_)[_i_] = ((volatile DRV_WORD32 *)(_register_))[_j_];      \
 223 //    DRV_MACRO_END
 224 //
 225 //#define HAL_WRITE_UINT32_VECTOR( _register_, _buf_, _count_, _step_ )   \
 226 //    DRV_MACRO_START                                                     \
 227 //    drv_count32 _i_,_j_;                                                \
 228 //    for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_))     \
 229 //        ((volatile DRV_WORD32 *)(_register_))[_j_] = (_buf_)[_i_];      \
 230 //    DRV_MACRO_END
 231 //
 232 //#define HAL_READ_UINT32_STRING( _register_, _buf_, _count_)             \
 233 //    DRV_MACRO_START                                                     \
 234 //    drv_count32 _i_;                                                    \
 235 //    for( _i_ = 0; _i_ < (_count_); _i_++)                               \
 236 //        (_buf_)[_i_] = ((volatile DRV_WORD32 *)(_register_))[_i_];      \
 237 //    DRV_MACRO_END
 238 //
 239 //#define HAL_WRITE_UINT32_STRING( _register_, _buf_, _count_)            \
 240 //    DRV_MACRO_START                                                     \
 241 //    drv_count32 _i_;                                                    \
 242 //    for( _i_ = 0; _i_ < (_count_); _i_++)                               \
 243 //        ((volatile DRV_WORD32 *)(_register_))[_i_] = (_buf_)[_i_];      \
 244 //    DRV_MACRO_END
 245 //
 246 //
 247 //#define HAL_IO_MACROS_DEFINED
 248
 249
 250 /**----------------------------------------------------------------------------*
 251 **                         Local Function Prototype                           **
 252 **----------------------------------------------------------------------------*/
 253
 254 /**----------------------------------------------------------------------------*
 255 **                           Function Prototype                               **
 256 **----------------------------------------------------------------------------*/
 257
 258
 259 /**----------------------------------------------------------------------------*
 260 **                         Compiler Flag                                      **
 261 **----------------------------------------------------------------------------*/
 262 #ifdef   __cplusplus
 263 }
 264 #endif
 265 /**---------------------------------------------------------------------------*/
 266 #endif
 267 // End