1 /******************************************************************************
2 ** File Name: sc8810_plf_io.h *
5 ** Copyright: 2010 Spreatrum, Incoporated. All Rights Reserved. *
7 ******************************************************************************/
8 /******************************************************************************
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 /*----------------------------------------------------------------------------*
18 **------------------------------------------------------------------------- */
20 /**---------------------------------------------------------------------------*
22 **--------------------------------------------------------------------------*/
27 /**---------------------------------------------------------------------------*
29 **---------------------------------------------------------------------------*/
31 //#define DRV_LSBFIRST 1234
32 //#define DRV_MSBFIRST 4321
33 //#define DRV_BYTEORDER DRV_MSBFIRST // Big endian
36 //#define DRV_INTERRUPT_FUNCTIONS_ENABLE
38 ////-----------------------------------------------------------------------------
39 //// BYTE Register access.
40 //// Individual and vectorized access to 8 bit registers.
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)
45 //#define HAL_READ_UINT8( _register_, _value_ ) \
46 // ((_value_) = *((volatile DRV_BYTE *)(_register_)))
48 //#define HAL_WRITE_UINT8( _register_, _value_ ) \
49 // (*((volatile DRV_BYTE *)(_register_)) = (_value_))
51 //#define HAL_READ_UINT8_VECTOR( _register_, _buf_, _count_, _step_ ) \
53 // drv_count32 _i_,_j_; \
54 // for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_)) \
55 // (_buf_)[_i_] = ((volatile DRV_BYTE *)(_register_))[_j_]; \
58 //#define HAL_WRITE_UINT8_VECTOR( _register_, _buf_, _count_, _step_ ) \
60 // drv_count32 _i_,_j_; \
61 // for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_)) \
62 // ((volatile DRV_BYTE *)(_register_))[_j_] = (_buf_)[_i_]; \
65 //#define HAL_READ_UINT8_STRING( _register_, _buf_, _count_ ) \
68 // for( _i_ = 0; _i_ < (_count_); _i_++) \
69 // (_buf_)[_i_] = ((volatile DRV_BYTE *)(_register_))[_i_]; \
72 //#define HAL_WRITE_UINT8_STRING( _register_, _buf_, _count_ ) \
75 // for( _i_ = 0; _i_ < (_count_); _i_++) \
76 // ((volatile DRV_BYTE *)(_register_)) = (_buf_)[_i_]; \
79 //#else // Big-endian version
81 //#define HAL_READ_UINT8( _register_, _value_ ) \
82 // ((_value_) = *((volatile DRV_BYTE *)((DRV_ADDRWORD)(_register_)^3)))
84 //#define HAL_WRITE_UINT8( _register_, _value_ ) \
85 // (*((volatile DRV_BYTE *)((DRV_ADDRWORD)(_register_)^3)) = (_value_))
87 //#define HAL_READ_UINT8_VECTOR( _register_, _buf_, _count_, _step_ ) \
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_]; \
95 //#define HAL_WRITE_UINT8_VECTOR( _register_, _buf_, _count_, _step_ ) \
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_]; \
103 //#define HAL_READ_UINT8_STRING( _register_, _buf_, _count_ ) \
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_]; \
111 //#define HAL_WRITE_UINT8_STRING( _register_, _buf_, _count_ ) \
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_]; \
119 //#endif // Big-endian
121 ////-----------------------------------------------------------------------------
123 //// Individual and vectorized access to 16 bit registers.
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)
128 //#define HAL_READ_UINT16( _register_, _value_ ) \
129 // ((_value_) = *((volatile DRV_WORD16 *)(_register_)))
131 //#define HAL_WRITE_UINT16( _register_, _value_ ) \
132 // (*((volatile DRV_WORD16 *)(_register_)) = (_value_))
134 //#define HAL_READ_UINT16_VECTOR( _register_, _buf_, _count_, _step_ ) \
136 // drv_count32 _i_,_j_; \
137 // for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_)) \
138 // (_buf_)[_i_] = ((volatile DRV_WORD16 *)(_register_))[_j_]; \
141 //#define HAL_WRITE_UINT16_VECTOR( _register_, _buf_, _count_, _step_ ) \
143 // drv_count32 _i_,_j_; \
144 // for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_)) \
145 // ((volatile DRV_WORD16 *)(_register_))[_j_] = (_buf_)[_i_]; \
148 //#define HAL_READ_UINT16_STRING( _register_, _buf_, _count_) \
150 // drv_count32 _i_; \
151 // for( _i_ = 0; _i_ < (_count_); _i_++) \
152 // (_buf_)[_i_] = ((volatile DRV_WORD16 *)(_register_))[_i_]; \
155 //#define HAL_WRITE_UINT16_STRING( _register_, _buf_, _count_) \
157 // drv_count32 _i_; \
158 // for( _i_ = 0; _i_ < (_count_); _i_++) \
159 // ((volatile DRV_WORD16 *)(_register_))[_i_] = (_buf_)[_i_]; \
163 //#else // Big-endian version
165 //#define HAL_READ_UINT16( _register_, _value_ ) \
166 // ((_value_) = *((volatile DRV_WORD16 *)((DRV_ADDRWORD)(_register_)^3)))
168 //#define HAL_WRITE_UINT16( _register_, _value_ ) \
169 // (*((volatile DRV_WORD16 *)((DRV_ADDRWORD)(_register_)^3)) = (_value_))
171 //#define HAL_READ_UINT16_VECTOR( _register_, _buf_, _count_, _step_ ) \
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_]; \
179 //#define HAL_WRITE_UINT16_VECTOR( _register_, _buf_, _count_, _step_ ) \
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_]; \
187 //#define HAL_READ_UINT16_STRING( _register_, _buf_, _count_) \
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_]; \
195 //#define HAL_WRITE_UINT16_STRING( _register_, _buf_, _count_) \
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_]; \
204 //#endif // Big-endian
206 ////-----------------------------------------------------------------------------
208 //// Individual and vectorized access to 32 bit registers.
210 //// Note: same macros for little- and big-endian systems.
212 //#define HAL_READ_UINT32( _register_, _value_ ) \
213 // ((_value_) = *((volatile DRV_WORD32 *)(_register_)))
215 //#define HAL_WRITE_UINT32( _register_, _value_ ) \
216 // (*((volatile DRV_WORD32 *)(_register_)) = (_value_))
218 //#define HAL_READ_UINT32_VECTOR( _register_, _buf_, _count_, _step_ ) \
220 // drv_count32 _i_,_j_; \
221 // for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_)) \
222 // (_buf_)[_i_] = ((volatile DRV_WORD32 *)(_register_))[_j_]; \
225 //#define HAL_WRITE_UINT32_VECTOR( _register_, _buf_, _count_, _step_ ) \
227 // drv_count32 _i_,_j_; \
228 // for( _i_ = 0, _j_ = 0; _i_ < (_count_); _i_++, _j_ += (_step_)) \
229 // ((volatile DRV_WORD32 *)(_register_))[_j_] = (_buf_)[_i_]; \
232 //#define HAL_READ_UINT32_STRING( _register_, _buf_, _count_) \
234 // drv_count32 _i_; \
235 // for( _i_ = 0; _i_ < (_count_); _i_++) \
236 // (_buf_)[_i_] = ((volatile DRV_WORD32 *)(_register_))[_i_]; \
239 //#define HAL_WRITE_UINT32_STRING( _register_, _buf_, _count_) \
241 // drv_count32 _i_; \
242 // for( _i_ = 0; _i_ < (_count_); _i_++) \
243 // ((volatile DRV_WORD32 *)(_register_))[_i_] = (_buf_)[_i_]; \
247 //#define HAL_IO_MACROS_DEFINED
250 /**----------------------------------------------------------------------------*
251 ** Local Function Prototype **
252 **----------------------------------------------------------------------------*/
254 /**----------------------------------------------------------------------------*
255 ** Function Prototype **
256 **----------------------------------------------------------------------------*/
259 /**----------------------------------------------------------------------------*
261 **----------------------------------------------------------------------------*/
265 /**---------------------------------------------------------------------------*/