1 /**************************************************************************** 2 3 (c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29 4 www.systec-electronic.com 5 6 Project: openPOWERLINK 7 8 Description: Definitions for Abstract Memory Interface 9 10 License: 11 12 Redistribution and use in source and binary forms, with or without 13 modification, are permitted provided that the following conditions 14 are met: 15 16 1. Redistributions of source code must retain the above copyright 17 notice, this list of conditions and the following disclaimer. 18 19 2. Redistributions in binary form must reproduce the above copyright 20 notice, this list of conditions and the following disclaimer in the 21 documentation and/or other materials provided with the distribution. 22 23 3. Neither the name of SYSTEC electronic GmbH nor the names of its 24 contributors may be used to endorse or promote products derived 25 from this software without prior written permission. For written 26 permission, please contact info@systec-electronic.com. 27 28 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 29 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 30 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 31 FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 32 COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 33 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 34 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 35 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 36 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 37 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 38 ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 39 POSSIBILITY OF SUCH DAMAGE. 40 41 Severability Clause: 42 43 If a provision of this License is or becomes illegal, invalid or 44 unenforceable in any jurisdiction, that shall not affect: 45 1. the validity or enforceability in that jurisdiction of any other 46 provision of this License; or 47 2. the validity or enforceability in other jurisdictions of that or 48 any other provision of this License. 49 50 ------------------------------------------------------------------------- 51 52 $RCSfile: EplAmi.h,v $ 53 54 $Author: D.Krueger $ 55 56 $Revision: 1.2 $ $Date: 2008/04/17 21:36:32 $ 57 58 $State: Exp $ 59 60 Build Environment: 61 GCC 62 63 ------------------------------------------------------------------------- 64 65 Revision History: 66 67 06.03.2000 -rs 68 Implementation 69 70 16.09.2002 -as 71 To save code space the functions AmiSetByte and AmiGetByte 72 are replaced by macros. For targets which assign BYTE by 73 an 16Bit type, the definition of macros must changed to 74 functions. 75 76 23.02.2005 r.d.: 77 Functions included for extended data types such as UNSIGNED24, 78 UNSIGNED40, ... 79 80 13.06.2006 d.k.: 81 Extended the interface for EPL with the different functions 82 for little endian and big endian 83 84 ****************************************************************************/ 85 86 #ifndef _EPLAMI_H_ 87 #define _EPLAMI_H_ 88 89 #if ((DEV_SYSTEM & _DEV_64BIT_SUPPORT_) == 0) 90 // #ifdef USE_VAR64 91 #error 'ERROR: development system does not support 64 bit operations!' 92 // #endif 93 #endif 94 95 //--------------------------------------------------------------------------- 96 // types 97 //--------------------------------------------------------------------------- 98 99 //--------------------------------------------------------------------------- 100 // Prototypen 101 //--------------------------------------------------------------------------- 102 103 #ifdef __cplusplus 104 extern "C" { 105 #endif 106 107 #if (TARGET_SYSTEM == _WIN32_) 108 #if defined(INLINE_FUNCTION_DEF) 109 #undef INLINE_FUNCTION 110 #define INLINE_FUNCTION INLINE_FUNCTION_DEF 111 #define INLINE_ENABLED TRUE 112 #define EPL_AMI_INLINED 113 #include "../EplStack/amix86.c" 114 #endif 115 116 #elif (TARGET_SYSTEM == _LINUX_) 117 #if defined(__m68k__) // it is an big endian machine 118 #if defined(INLINE_FUNCTION_DEF) 119 #undef INLINE_FUNCTION 120 #define INLINE_FUNCTION INLINE_FUNCTION_DEF 121 #define INLINE_ENABLED TRUE 122 #define EPL_AMI_INLINED 123 #include "../EplStack/amibe.c" 124 #endif 125 #endif 126 #endif 127 128 //--------------------------------------------------------------------------- 129 // 130 // write functions 131 // 132 // To save code space the function AmiSetByte is replaced by 133 // an macro. 134 // void PUBLIC AmiSetByte (void FAR* pAddr_p, BYTE bByteVal_p); 135 136 #define AmiSetByteToBe(pAddr_p, bByteVal_p) {*(BYTE FAR*)(pAddr_p) = (bByteVal_p);} 137 #define AmiSetByteToLe(pAddr_p, bByteVal_p) {*(BYTE FAR*)(pAddr_p) = (bByteVal_p);} 138 139 #if !defined(INLINE_ENABLED) 140 void PUBLIC AmiSetWordToBe(void FAR * pAddr_p, WORD wWordVal_p); 141 void PUBLIC AmiSetDwordToBe(void FAR * pAddr_p, DWORD dwDwordVal_p); 142 void PUBLIC AmiSetWordToLe(void FAR * pAddr_p, WORD wWordVal_p); 143 void PUBLIC AmiSetDwordToLe(void FAR * pAddr_p, DWORD dwDwordVal_p); 144 #endif 145 146 //--------------------------------------------------------------------------- 147 // 148 // read functions 149 // 150 // To save code space the function AmiGetByte is replaced by 151 // an macro. 152 // BYTE PUBLIC AmiGetByte (void FAR* pAddr_p); 153 154 #define AmiGetByteFromBe(pAddr_p) (*(BYTE FAR*)(pAddr_p)) 155 #define AmiGetByteFromLe(pAddr_p) (*(BYTE FAR*)(pAddr_p)) 156 157 #if !defined(INLINE_ENABLED) 158 159 WORD PUBLIC AmiGetWordFromBe(void FAR * pAddr_p); 160 DWORD PUBLIC AmiGetDwordFromBe(void FAR * pAddr_p); 161 WORD PUBLIC AmiGetWordFromLe(void FAR * pAddr_p); 162 DWORD PUBLIC AmiGetDwordFromLe(void FAR * pAddr_p); 163 164 //--------------------------------------------------------------------------- 165 // 166 // Function: AmiSetDword24() 167 // 168 // Description: sets a 24 bit value to a buffer 169 // 170 // Parameters: pAddr_p = pointer to destination buffer 171 // dwDwordVal_p = value to set 172 // 173 // Return: void 174 // 175 //--------------------------------------------------------------------------- 176 177 void PUBLIC AmiSetDword24ToBe(void FAR * pAddr_p, DWORD dwDwordVal_p); 178 void PUBLIC AmiSetDword24ToLe(void FAR * pAddr_p, DWORD dwDwordVal_p); 179 180 //--------------------------------------------------------------------------- 181 // 182 // Function: AmiGetDword24() 183 // 184 // Description: reads a 24 bit value from a buffer 185 // 186 // Parameters: pAddr_p = pointer to source buffer 187 // 188 // Return: DWORD = read value 189 // 190 //--------------------------------------------------------------------------- 191 192 DWORD PUBLIC AmiGetDword24FromBe(void FAR * pAddr_p); 193 DWORD PUBLIC AmiGetDword24FromLe(void FAR * pAddr_p); 194 195 //#ifdef USE_VAR64 196 197 //--------------------------------------------------------------------------- 198 // 199 // Function: AmiSetQword40() 200 // 201 // Description: sets a 40 bit value to a buffer 202 // 203 // Parameters: pAddr_p = pointer to destination buffer 204 // qwQwordVal_p = quadruple word value 205 // 206 // Return: void 207 // 208 //--------------------------------------------------------------------------- 209 210 void PUBLIC AmiSetQword40ToBe(void FAR * pAddr_p, QWORD qwQwordVal_p); 211 void PUBLIC AmiSetQword40ToLe(void FAR * pAddr_p, QWORD qwQwordVal_p); 212 213 //--------------------------------------------------------------------------- 214 // 215 // Function: AmiGetQword40() 216 // 217 // Description: reads a 40 bit value from a buffer 218 // 219 // Parameters: pAddr_p = pointer to source buffer 220 // 221 // Return: QWORD 222 // 223 //--------------------------------------------------------------------------- 224 225 QWORD PUBLIC AmiGetQword40FromBe(void FAR * pAddr_p); 226 QWORD PUBLIC AmiGetQword40FromLe(void FAR * pAddr_p); 227 228 //--------------------------------------------------------------------------- 229 // 230 // Function: AmiSetQword48() 231 // 232 // Description: sets a 48 bit value to a buffer 233 // 234 // Parameters: pAddr_p = pointer to destination buffer 235 // qwQwordVal_p = quadruple word value 236 // 237 // Return: void 238 // 239 //--------------------------------------------------------------------------- 240 241 void PUBLIC AmiSetQword48ToBe(void FAR * pAddr_p, QWORD qwQwordVal_p); 242 void PUBLIC AmiSetQword48ToLe(void FAR * pAddr_p, QWORD qwQwordVal_p); 243 244 //--------------------------------------------------------------------------- 245 // 246 // Function: AmiGetQword48() 247 // 248 // Description: reads a 48 bit value from a buffer 249 // 250 // Parameters: pAddr_p = pointer to source buffer 251 // 252 // Return: QWORD 253 // 254 //--------------------------------------------------------------------------- 255 256 QWORD PUBLIC AmiGetQword48FromBe(void FAR * pAddr_p); 257 QWORD PUBLIC AmiGetQword48FromLe(void FAR * pAddr_p); 258 259 //--------------------------------------------------------------------------- 260 // 261 // Function: AmiSetQword56() 262 // 263 // Description: sets a 56 bit value to a buffer 264 // 265 // Parameters: pAddr_p = pointer to destination buffer 266 // qwQwordVal_p = quadruple word value 267 // 268 // Return: void 269 // 270 //--------------------------------------------------------------------------- 271 272 void PUBLIC AmiSetQword56ToBe(void FAR * pAddr_p, QWORD qwQwordVal_p); 273 void PUBLIC AmiSetQword56ToLe(void FAR * pAddr_p, QWORD qwQwordVal_p); 274 275 //--------------------------------------------------------------------------- 276 // 277 // Function: AmiGetQword56() 278 // 279 // Description: reads a 56 bit value from a buffer 280 // 281 // Parameters: pAddr_p = pointer to source buffer 282 // 283 // Return: QWORD 284 // 285 //--------------------------------------------------------------------------- 286 287 QWORD PUBLIC AmiGetQword56FromBe(void FAR * pAddr_p); 288 QWORD PUBLIC AmiGetQword56FromLe(void FAR * pAddr_p); 289 290 //--------------------------------------------------------------------------- 291 // 292 // Function: AmiSetQword64() 293 // 294 // Description: sets a 64 bit value to a buffer 295 // 296 // Parameters: pAddr_p = pointer to destination buffer 297 // qwQwordVal_p = quadruple word value 298 // 299 // Return: void 300 // 301 //--------------------------------------------------------------------------- 302 303 void PUBLIC AmiSetQword64ToBe(void FAR * pAddr_p, QWORD qwQwordVal_p); 304 void PUBLIC AmiSetQword64ToLe(void FAR * pAddr_p, QWORD qwQwordVal_p); 305 306 //--------------------------------------------------------------------------- 307 // 308 // Function: AmiGetQword64() 309 // 310 // Description: reads a 64 bit value from a buffer 311 // 312 // Parameters: pAddr_p = pointer to source buffer 313 // 314 // Return: void 315 // 316 //--------------------------------------------------------------------------- 317 318 QWORD PUBLIC AmiGetQword64FromBe(void FAR * pAddr_p); 319 QWORD PUBLIC AmiGetQword64FromLe(void FAR * pAddr_p); 320 321 //--------------------------------------------------------------------------- 322 // 323 // Function: AmiSetTimeOfDay() 324 // 325 // Description: sets a TIME_OF_DAY (CANopen) value to a buffer 326 // 327 // Parameters: pAddr_p = pointer to destination buffer 328 // pTimeOfDay_p = pointer to struct TIME_OF_DAY 329 // 330 // Return: void 331 // 332 //--------------------------------------------------------------------------- 333 334 void PUBLIC AmiSetTimeOfDay(void FAR * pAddr_p, 335 tTimeOfDay FAR * pTimeOfDay_p); 336 337 //--------------------------------------------------------------------------- 338 // 339 // Function: AmiGetTimeOfDay() 340 // 341 // Description: reads a TIME_OF_DAY (CANopen) value from a buffer 342 // 343 // Parameters: pAddr_p = pointer to source buffer 344 // pTimeOfDay_p = pointer to struct TIME_OF_DAY 345 // 346 // Return: void 347 // 348 //--------------------------------------------------------------------------- 349 350 void PUBLIC AmiGetTimeOfDay(void FAR * pAddr_p, 351 tTimeOfDay FAR * pTimeOfDay_p); 352 353 #endif 354 355 #undef INLINE_ENABLED // disable actual inlining of functions 356 #define EPL_AMI_INCLUDED 357 358 #ifdef __cplusplus 359 } 360 #endif 361 #endif // ifndef _EPLAMI_H_ 362 // Die letzte Zeile mu� unbedingt eine leere Zeile sein, weil manche Compiler// damit ein Problem haben, wenn das nicht so ist (z.B. GNU oder Borland C++ Builder). 363