Commit | Line | Data |
---|---|---|
9d7164cf DK |
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: Abstract Memory Interface for x86 compatible | |
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: amix86.c,v $ | |
53 | ||
54 | $Author: D.Krueger $ | |
55 | ||
56 | $Revision: 1.3 $ $Date: 2008/04/17 21:36:32 $ | |
57 | ||
58 | $State: Exp $ | |
59 | ||
60 | Build Environment: | |
61 | ... | |
62 | ||
63 | ------------------------------------------------------------------------- | |
64 | ||
65 | Revision History: | |
66 | ||
67 | r.s.: first implemetation | |
68 | ||
69 | 2006-06-13 d.k.: duplicate functions for little endian and big endian | |
70 | ||
71 | ****************************************************************************/ | |
72 | ||
73 | //#include "global.h" | |
74 | //#include "EplAmi.h" | |
75 | #include "EplInc.h" | |
76 | ||
77 | #if (!defined(EPL_AMI_INLINED)) || defined(INLINE_ENABLED) | |
78 | ||
79 | //--------------------------------------------------------------------------- | |
80 | // typedef | |
81 | //--------------------------------------------------------------------------- | |
82 | ||
833dfbe7 GKH |
83 | typedef struct { |
84 | WORD m_wWord; | |
9d7164cf DK |
85 | |
86 | } twStruct; | |
87 | ||
833dfbe7 GKH |
88 | typedef struct { |
89 | DWORD m_dwDword; | |
9d7164cf DK |
90 | |
91 | } tdwStruct; | |
92 | ||
833dfbe7 GKH |
93 | typedef struct { |
94 | QWORD m_qwQword; | |
9d7164cf DK |
95 | |
96 | } tqwStruct; | |
97 | ||
9d7164cf DK |
98 | //=========================================================================// |
99 | // // | |
100 | // P U B L I C F U N C T I O N S // | |
101 | // // | |
102 | //=========================================================================// | |
103 | ||
104 | //--------------------------------------------------------------------------- | |
105 | // | |
106 | // Function: AmiSetXXXToBe() | |
107 | // | |
108 | // Description: writes the specified value to the absolute address in | |
109 | // big endian | |
110 | // | |
111 | // Parameters: pAddr_p = absolute address | |
112 | // xXXXVal_p = value | |
113 | // | |
114 | // Returns: (none) | |
115 | // | |
116 | // State: | |
117 | // | |
118 | //--------------------------------------------------------------------------- | |
119 | ||
120 | //------------< write BYTE in big endian >-------------------------- | |
121 | /* | |
122 | void PUBLIC AmiSetByteToBe (void FAR* pAddr_p, BYTE bByteVal_p) | |
123 | { | |
124 | ||
125 | *(BYTE FAR*)pAddr_p = bByteVal_p; | |
126 | ||
127 | } | |
128 | */ | |
129 | ||
9d7164cf DK |
130 | //------------< write WORD in big endian >-------------------------- |
131 | ||
833dfbe7 | 132 | INLINE_FUNCTION void PUBLIC AmiSetWordToBe(void FAR * pAddr_p, WORD wWordVal_p) |
9d7164cf | 133 | { |
833dfbe7 GKH |
134 | twStruct FAR *pwStruct; |
135 | twStruct wValue; | |
9d7164cf | 136 | |
833dfbe7 GKH |
137 | wValue.m_wWord = (WORD) ((wWordVal_p & 0x00FF) << 8); //LSB to MSB |
138 | wValue.m_wWord |= (WORD) ((wWordVal_p & 0xFF00) >> 8); //MSB to LSB | |
9d7164cf | 139 | |
833dfbe7 GKH |
140 | pwStruct = (twStruct FAR *) pAddr_p; |
141 | pwStruct->m_wWord = wValue.m_wWord; | |
9d7164cf DK |
142 | |
143 | } | |
144 | ||
9d7164cf DK |
145 | //------------< write DWORD in big endian >------------------------- |
146 | ||
833dfbe7 GKH |
147 | INLINE_FUNCTION void PUBLIC AmiSetDwordToBe(void FAR * pAddr_p, |
148 | DWORD dwDwordVal_p) | |
9d7164cf | 149 | { |
833dfbe7 GKH |
150 | tdwStruct FAR *pdwStruct; |
151 | tdwStruct dwValue; | |
9d7164cf | 152 | |
833dfbe7 GKH |
153 | dwValue.m_dwDword = ((dwDwordVal_p & 0x000000FF) << 24); //LSB to MSB |
154 | dwValue.m_dwDword |= ((dwDwordVal_p & 0x0000FF00) << 8); | |
155 | dwValue.m_dwDword |= ((dwDwordVal_p & 0x00FF0000) >> 8); | |
156 | dwValue.m_dwDword |= ((dwDwordVal_p & 0xFF000000) >> 24); //MSB to LSB | |
9d7164cf | 157 | |
833dfbe7 GKH |
158 | pdwStruct = (tdwStruct FAR *) pAddr_p; |
159 | pdwStruct->m_dwDword = dwValue.m_dwDword; | |
9d7164cf DK |
160 | |
161 | } | |
162 | ||
9d7164cf DK |
163 | //--------------------------------------------------------------------------- |
164 | // | |
165 | // Function: AmiSetXXXToLe() | |
166 | // | |
167 | // Description: writes the specified value to the absolute address in | |
168 | // little endian | |
169 | // | |
170 | // Parameters: pAddr_p = absolute address | |
171 | // xXXXVal_p = value | |
172 | // | |
173 | // Returns: (none) | |
174 | // | |
175 | // State: | |
176 | // | |
177 | //--------------------------------------------------------------------------- | |
178 | ||
179 | //------------< write BYTE in little endian >-------------------------- | |
180 | /* | |
181 | void PUBLIC AmiSetByteToLe (void FAR* pAddr_p, BYTE bByteVal_p) | |
182 | { | |
183 | ||
184 | *(BYTE FAR*)pAddr_p = bByteVal_p; | |
185 | ||
186 | } | |
187 | */ | |
188 | ||
9d7164cf DK |
189 | //------------< write WORD in little endian >-------------------------- |
190 | ||
833dfbe7 | 191 | INLINE_FUNCTION void PUBLIC AmiSetWordToLe(void FAR * pAddr_p, WORD wWordVal_p) |
9d7164cf | 192 | { |
833dfbe7 | 193 | twStruct FAR *pwStruct; |
9d7164cf | 194 | |
833dfbe7 GKH |
195 | pwStruct = (twStruct FAR *) pAddr_p; |
196 | pwStruct->m_wWord = wWordVal_p; | |
9d7164cf DK |
197 | |
198 | } | |
199 | ||
9d7164cf DK |
200 | //------------< write DWORD in little endian >------------------------- |
201 | ||
833dfbe7 GKH |
202 | INLINE_FUNCTION void PUBLIC AmiSetDwordToLe(void FAR * pAddr_p, |
203 | DWORD dwDwordVal_p) | |
9d7164cf | 204 | { |
833dfbe7 | 205 | tdwStruct FAR *pdwStruct; |
9d7164cf | 206 | |
833dfbe7 GKH |
207 | pdwStruct = (tdwStruct FAR *) pAddr_p; |
208 | pdwStruct->m_dwDword = dwDwordVal_p; | |
9d7164cf DK |
209 | |
210 | } | |
211 | ||
9d7164cf DK |
212 | //--------------------------------------------------------------------------- |
213 | // | |
214 | // Function: AmiGetXXXFromBe() | |
215 | // | |
216 | // Description: reads the specified value from the absolute address in | |
217 | // big endian | |
218 | // | |
219 | // Parameters: pAddr_p = absolute address | |
220 | // | |
221 | // Returns: XXX = value | |
222 | // | |
223 | // State: | |
224 | // | |
225 | //--------------------------------------------------------------------------- | |
226 | ||
227 | //------------< read BYTE in big endian >--------------------------- | |
228 | /* | |
229 | BYTE PUBLIC AmiGetByteFromBe (void FAR* pAddr_p) | |
230 | { | |
231 | ||
232 | return ( *(BYTE FAR*)pAddr_p ); | |
233 | ||
234 | } | |
235 | */ | |
236 | ||
9d7164cf DK |
237 | //------------< read WORD in big endian >--------------------------- |
238 | ||
833dfbe7 | 239 | INLINE_FUNCTION WORD PUBLIC AmiGetWordFromBe(void FAR * pAddr_p) |
9d7164cf | 240 | { |
833dfbe7 GKH |
241 | twStruct FAR *pwStruct; |
242 | twStruct wValue; | |
9d7164cf | 243 | |
833dfbe7 | 244 | pwStruct = (twStruct FAR *) pAddr_p; |
9d7164cf | 245 | |
833dfbe7 GKH |
246 | wValue.m_wWord = (WORD) ((pwStruct->m_wWord & 0x00FF) << 8); //LSB to MSB |
247 | wValue.m_wWord |= (WORD) ((pwStruct->m_wWord & 0xFF00) >> 8); //MSB to LSB | |
9d7164cf | 248 | |
833dfbe7 | 249 | return (wValue.m_wWord); |
9d7164cf DK |
250 | |
251 | } | |
252 | ||
9d7164cf DK |
253 | //------------< read DWORD in big endian >-------------------------- |
254 | ||
833dfbe7 | 255 | INLINE_FUNCTION DWORD PUBLIC AmiGetDwordFromBe(void FAR * pAddr_p) |
9d7164cf | 256 | { |
833dfbe7 GKH |
257 | tdwStruct FAR *pdwStruct; |
258 | tdwStruct dwValue; | |
9d7164cf | 259 | |
833dfbe7 | 260 | pdwStruct = (tdwStruct FAR *) pAddr_p; |
9d7164cf | 261 | |
833dfbe7 GKH |
262 | dwValue.m_dwDword = ((pdwStruct->m_dwDword & 0x000000FF) << 24); //LSB to MSB |
263 | dwValue.m_dwDword |= ((pdwStruct->m_dwDword & 0x0000FF00) << 8); | |
264 | dwValue.m_dwDword |= ((pdwStruct->m_dwDword & 0x00FF0000) >> 8); | |
265 | dwValue.m_dwDword |= ((pdwStruct->m_dwDword & 0xFF000000) >> 24); //MSB to LSB | |
9d7164cf | 266 | |
833dfbe7 | 267 | return (dwValue.m_dwDword); |
9d7164cf DK |
268 | |
269 | } | |
270 | ||
9d7164cf DK |
271 | //--------------------------------------------------------------------------- |
272 | // | |
273 | // Function: AmiGetXXXFromLe() | |
274 | // | |
275 | // Description: reads the specified value from the absolute address in | |
276 | // little endian | |
277 | // | |
278 | // Parameters: pAddr_p = absolute address | |
279 | // | |
280 | // Returns: XXX = value | |
281 | // | |
282 | // State: | |
283 | // | |
284 | //--------------------------------------------------------------------------- | |
285 | ||
286 | //------------< read BYTE in little endian >--------------------------- | |
287 | /* | |
288 | BYTE PUBLIC AmiGetByteFromLe (void FAR* pAddr_p) | |
289 | { | |
290 | ||
291 | return ( *(BYTE FAR*)pAddr_p ); | |
292 | ||
293 | } | |
294 | */ | |
295 | ||
9d7164cf DK |
296 | //------------< read WORD in little endian >--------------------------- |
297 | ||
833dfbe7 | 298 | INLINE_FUNCTION WORD PUBLIC AmiGetWordFromLe(void FAR * pAddr_p) |
9d7164cf | 299 | { |
833dfbe7 | 300 | twStruct FAR *pwStruct; |
9d7164cf | 301 | |
833dfbe7 GKH |
302 | pwStruct = (twStruct FAR *) pAddr_p; |
303 | return (pwStruct->m_wWord); | |
9d7164cf DK |
304 | |
305 | } | |
306 | ||
9d7164cf DK |
307 | //------------< read DWORD in little endian >-------------------------- |
308 | ||
833dfbe7 | 309 | INLINE_FUNCTION DWORD PUBLIC AmiGetDwordFromLe(void FAR * pAddr_p) |
9d7164cf | 310 | { |
833dfbe7 | 311 | tdwStruct FAR *pdwStruct; |
9d7164cf | 312 | |
833dfbe7 GKH |
313 | pdwStruct = (tdwStruct FAR *) pAddr_p; |
314 | return (pdwStruct->m_dwDword); | |
9d7164cf DK |
315 | |
316 | } | |
317 | ||
9d7164cf DK |
318 | //--------------------------------------------------------------------------- |
319 | // | |
320 | // Function: AmiSetDword24ToBe() | |
321 | // | |
322 | // Description: sets a 24 bit value to a buffer in big endian | |
323 | // | |
324 | // Parameters: pAddr_p = pointer to destination buffer | |
325 | // dwDwordVal_p = value to set | |
326 | // | |
327 | // Return: void | |
328 | // | |
329 | // State: not tested | |
330 | // | |
331 | //--------------------------------------------------------------------------- | |
332 | ||
833dfbe7 GKH |
333 | INLINE_FUNCTION void PUBLIC AmiSetDword24ToBe(void FAR * pAddr_p, |
334 | DWORD dwDwordVal_p) | |
9d7164cf DK |
335 | { |
336 | ||
833dfbe7 GKH |
337 | ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & dwDwordVal_p)[2]; |
338 | ((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & dwDwordVal_p)[1]; | |
339 | ((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & dwDwordVal_p)[0]; | |
9d7164cf DK |
340 | |
341 | } | |
342 | ||
9d7164cf DK |
343 | //--------------------------------------------------------------------------- |
344 | // | |
345 | // Function: AmiSetDword24ToLe() | |
346 | // | |
347 | // Description: sets a 24 bit value to a buffer in little endian | |
348 | // | |
349 | // Parameters: pAddr_p = pointer to destination buffer | |
350 | // dwDwordVal_p = value to set | |
351 | // | |
352 | // Return: void | |
353 | // | |
354 | // State: not tested | |
355 | // | |
356 | //--------------------------------------------------------------------------- | |
357 | ||
833dfbe7 GKH |
358 | INLINE_FUNCTION void PUBLIC AmiSetDword24ToLe(void FAR * pAddr_p, |
359 | DWORD dwDwordVal_p) | |
9d7164cf DK |
360 | { |
361 | ||
833dfbe7 GKH |
362 | ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & dwDwordVal_p)[0]; |
363 | ((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & dwDwordVal_p)[1]; | |
364 | ((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & dwDwordVal_p)[2]; | |
9d7164cf DK |
365 | |
366 | } | |
367 | ||
9d7164cf DK |
368 | //--------------------------------------------------------------------------- |
369 | // | |
370 | // Function: AmiGetDword24FromBe() | |
371 | // | |
372 | // Description: reads a 24 bit value from a buffer in big endian | |
373 | // | |
374 | // Parameters: pAddr_p = pointer to source buffer | |
375 | // | |
376 | // Return: DWORD = read value | |
377 | // | |
378 | // State: not tested | |
379 | // | |
380 | //--------------------------------------------------------------------------- | |
381 | ||
833dfbe7 | 382 | INLINE_FUNCTION DWORD PUBLIC AmiGetDword24FromBe(void FAR * pAddr_p) |
9d7164cf DK |
383 | { |
384 | ||
833dfbe7 | 385 | tdwStruct dwStruct; |
9d7164cf | 386 | |
833dfbe7 GKH |
387 | dwStruct.m_dwDword = AmiGetDwordFromBe(pAddr_p); |
388 | dwStruct.m_dwDword >>= 8; | |
9d7164cf | 389 | |
833dfbe7 | 390 | return (dwStruct.m_dwDword); |
9d7164cf DK |
391 | |
392 | } | |
393 | ||
9d7164cf DK |
394 | //--------------------------------------------------------------------------- |
395 | // | |
396 | // Function: AmiGetDword24FromLe() | |
397 | // | |
398 | // Description: reads a 24 bit value from a buffer in little endian | |
399 | // | |
400 | // Parameters: pAddr_p = pointer to source buffer | |
401 | // | |
402 | // Return: DWORD = read value | |
403 | // | |
404 | // State: not tested | |
405 | // | |
406 | //--------------------------------------------------------------------------- | |
407 | ||
833dfbe7 | 408 | INLINE_FUNCTION DWORD PUBLIC AmiGetDword24FromLe(void FAR * pAddr_p) |
9d7164cf DK |
409 | { |
410 | ||
833dfbe7 | 411 | tdwStruct dwStruct; |
9d7164cf | 412 | |
833dfbe7 GKH |
413 | dwStruct.m_dwDword = AmiGetDwordFromLe(pAddr_p); |
414 | dwStruct.m_dwDword &= 0x00FFFFFF; | |
9d7164cf | 415 | |
833dfbe7 | 416 | return (dwStruct.m_dwDword); |
9d7164cf DK |
417 | |
418 | } | |
419 | ||
9d7164cf DK |
420 | //#ifdef USE_VAR64 |
421 | ||
422 | //--------------------------------------------------------------------------- | |
423 | // | |
424 | // Function: AmiSetQword64ToBe() | |
425 | // | |
426 | // Description: sets a 64 bit value to a buffer in big endian | |
427 | // | |
428 | // Parameters: pAddr_p = pointer to destination buffer | |
429 | // qwQwordVal_p = quadruple word value | |
430 | // | |
431 | // Return: void | |
432 | // | |
433 | // State: not tested | |
434 | // | |
435 | //--------------------------------------------------------------------------- | |
436 | ||
833dfbe7 GKH |
437 | INLINE_FUNCTION void PUBLIC AmiSetQword64ToBe(void FAR * pAddr_p, |
438 | QWORD qwQwordVal_p) | |
9d7164cf DK |
439 | { |
440 | ||
833dfbe7 GKH |
441 | ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[7]; |
442 | ((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & qwQwordVal_p)[6]; | |
443 | ((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & qwQwordVal_p)[5]; | |
444 | ((BYTE FAR *) pAddr_p)[3] = ((BYTE FAR *) & qwQwordVal_p)[4]; | |
445 | ((BYTE FAR *) pAddr_p)[4] = ((BYTE FAR *) & qwQwordVal_p)[3]; | |
446 | ((BYTE FAR *) pAddr_p)[5] = ((BYTE FAR *) & qwQwordVal_p)[2]; | |
447 | ((BYTE FAR *) pAddr_p)[6] = ((BYTE FAR *) & qwQwordVal_p)[1]; | |
448 | ((BYTE FAR *) pAddr_p)[7] = ((BYTE FAR *) & qwQwordVal_p)[0]; | |
9d7164cf DK |
449 | |
450 | } | |
451 | ||
9d7164cf DK |
452 | //--------------------------------------------------------------------------- |
453 | // | |
454 | // Function: AmiSetQword64ToLe() | |
455 | // | |
456 | // Description: sets a 64 bit value to a buffer in little endian | |
457 | // | |
458 | // Parameters: pAddr_p = pointer to destination buffer | |
459 | // qwQwordVal_p = quadruple word value | |
460 | // | |
461 | // Return: void | |
462 | // | |
463 | // State: not tested | |
464 | // | |
465 | //--------------------------------------------------------------------------- | |
466 | ||
833dfbe7 GKH |
467 | INLINE_FUNCTION void PUBLIC AmiSetQword64ToLe(void FAR * pAddr_p, |
468 | QWORD qwQwordVal_p) | |
9d7164cf DK |
469 | { |
470 | ||
833dfbe7 | 471 | QWORD FAR *pqwDst; |
9d7164cf | 472 | |
833dfbe7 GKH |
473 | pqwDst = (QWORD FAR *) pAddr_p; |
474 | *pqwDst = qwQwordVal_p; | |
9d7164cf DK |
475 | |
476 | } | |
477 | ||
9d7164cf DK |
478 | //--------------------------------------------------------------------------- |
479 | // | |
480 | // Function: AmiGetQword64FromBe() | |
481 | // | |
482 | // Description: reads a 64 bit value from a buffer in big endian | |
483 | // | |
484 | // Parameters: pAddr_p = pointer to source buffer | |
485 | // | |
486 | // Return: void | |
487 | // | |
488 | // State: not tested | |
489 | // | |
490 | //--------------------------------------------------------------------------- | |
491 | ||
833dfbe7 | 492 | INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromBe(void FAR * pAddr_p) |
9d7164cf DK |
493 | { |
494 | ||
833dfbe7 | 495 | tqwStruct qwStruct; |
9d7164cf | 496 | |
833dfbe7 GKH |
497 | ((BYTE FAR *) & qwStruct.m_qwQword)[0] = ((BYTE FAR *) pAddr_p)[7]; |
498 | ((BYTE FAR *) & qwStruct.m_qwQword)[1] = ((BYTE FAR *) pAddr_p)[6]; | |
499 | ((BYTE FAR *) & qwStruct.m_qwQword)[2] = ((BYTE FAR *) pAddr_p)[5]; | |
500 | ((BYTE FAR *) & qwStruct.m_qwQword)[3] = ((BYTE FAR *) pAddr_p)[4]; | |
501 | ((BYTE FAR *) & qwStruct.m_qwQword)[4] = ((BYTE FAR *) pAddr_p)[3]; | |
502 | ((BYTE FAR *) & qwStruct.m_qwQword)[5] = ((BYTE FAR *) pAddr_p)[2]; | |
503 | ((BYTE FAR *) & qwStruct.m_qwQword)[6] = ((BYTE FAR *) pAddr_p)[1]; | |
504 | ((BYTE FAR *) & qwStruct.m_qwQword)[7] = ((BYTE FAR *) pAddr_p)[0]; | |
9d7164cf | 505 | |
833dfbe7 | 506 | return (qwStruct.m_qwQword); |
9d7164cf DK |
507 | |
508 | } | |
509 | ||
9d7164cf DK |
510 | //--------------------------------------------------------------------------- |
511 | // | |
512 | // Function: AmiGetQword64FromLe() | |
513 | // | |
514 | // Description: reads a 64 bit value from a buffer in little endian | |
515 | // | |
516 | // Parameters: pAddr_p = pointer to source buffer | |
517 | // | |
518 | // Return: void | |
519 | // | |
520 | // State: not tested | |
521 | // | |
522 | //--------------------------------------------------------------------------- | |
523 | ||
833dfbe7 | 524 | INLINE_FUNCTION QWORD PUBLIC AmiGetQword64FromLe(void FAR * pAddr_p) |
9d7164cf DK |
525 | { |
526 | ||
833dfbe7 GKH |
527 | tqwStruct FAR *pqwStruct; |
528 | tqwStruct qwStruct; | |
9d7164cf | 529 | |
833dfbe7 GKH |
530 | pqwStruct = (tqwStruct FAR *) pAddr_p; |
531 | qwStruct.m_qwQword = pqwStruct->m_qwQword; | |
9d7164cf | 532 | |
833dfbe7 | 533 | return (qwStruct.m_qwQword); |
9d7164cf DK |
534 | |
535 | } | |
536 | ||
9d7164cf DK |
537 | //--------------------------------------------------------------------------- |
538 | // | |
539 | // Function: AmiSetQword40ToBe() | |
540 | // | |
541 | // Description: sets a 40 bit value to a buffer in big endian | |
542 | // | |
543 | // Parameters: pAddr_p = pointer to destination buffer | |
544 | // qwQwordVal_p = quadruple word value | |
545 | // | |
546 | // Return: void | |
547 | // | |
548 | // State: not tested | |
549 | // | |
550 | //--------------------------------------------------------------------------- | |
551 | ||
833dfbe7 GKH |
552 | INLINE_FUNCTION void PUBLIC AmiSetQword40ToBe(void FAR * pAddr_p, |
553 | QWORD qwQwordVal_p) | |
9d7164cf DK |
554 | { |
555 | ||
833dfbe7 GKH |
556 | ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[4]; |
557 | ((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & qwQwordVal_p)[3]; | |
558 | ((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & qwQwordVal_p)[2]; | |
559 | ((BYTE FAR *) pAddr_p)[3] = ((BYTE FAR *) & qwQwordVal_p)[1]; | |
560 | ((BYTE FAR *) pAddr_p)[4] = ((BYTE FAR *) & qwQwordVal_p)[0]; | |
9d7164cf DK |
561 | |
562 | } | |
563 | ||
9d7164cf DK |
564 | //--------------------------------------------------------------------------- |
565 | // | |
566 | // Function: AmiSetQword40ToLe() | |
567 | // | |
568 | // Description: sets a 40 bit value to a buffer in little endian | |
569 | // | |
570 | // Parameters: pAddr_p = pointer to destination buffer | |
571 | // qwQwordVal_p = quadruple word value | |
572 | // | |
573 | // Return: void | |
574 | // | |
575 | // State: not tested | |
576 | // | |
577 | //--------------------------------------------------------------------------- | |
578 | ||
833dfbe7 GKH |
579 | INLINE_FUNCTION void PUBLIC AmiSetQword40ToLe(void FAR * pAddr_p, |
580 | QWORD qwQwordVal_p) | |
9d7164cf DK |
581 | { |
582 | ||
833dfbe7 GKH |
583 | ((DWORD FAR *) pAddr_p)[0] = ((DWORD FAR *) & qwQwordVal_p)[0]; |
584 | ((BYTE FAR *) pAddr_p)[4] = ((BYTE FAR *) & qwQwordVal_p)[4]; | |
9d7164cf DK |
585 | |
586 | } | |
587 | ||
9d7164cf DK |
588 | //--------------------------------------------------------------------------- |
589 | // | |
590 | // Function: AmiGetQword40FromBe() | |
591 | // | |
592 | // Description: reads a 40 bit value from a buffer in big endian | |
593 | // | |
594 | // Parameters: pAddr_p = pointer to source buffer | |
595 | // | |
596 | // Return: QWORD | |
597 | // | |
598 | // State: not tested | |
599 | // | |
600 | //--------------------------------------------------------------------------- | |
601 | ||
833dfbe7 | 602 | INLINE_FUNCTION QWORD PUBLIC AmiGetQword40FromBe(void FAR * pAddr_p) |
9d7164cf DK |
603 | { |
604 | ||
833dfbe7 | 605 | tqwStruct qwStruct; |
9d7164cf | 606 | |
833dfbe7 GKH |
607 | qwStruct.m_qwQword = AmiGetQword64FromBe(pAddr_p); |
608 | qwStruct.m_qwQword >>= 24; | |
9d7164cf | 609 | |
833dfbe7 | 610 | return (qwStruct.m_qwQword); |
9d7164cf DK |
611 | |
612 | } | |
613 | ||
9d7164cf DK |
614 | //--------------------------------------------------------------------------- |
615 | // | |
616 | // Function: AmiGetQword40FromLe() | |
617 | // | |
618 | // Description: reads a 40 bit value from a buffer in little endian | |
619 | // | |
620 | // Parameters: pAddr_p = pointer to source buffer | |
621 | // | |
622 | // Return: QWORD | |
623 | // | |
624 | // State: not tested | |
625 | // | |
626 | //--------------------------------------------------------------------------- | |
627 | ||
833dfbe7 | 628 | INLINE_FUNCTION QWORD PUBLIC AmiGetQword40FromLe(void FAR * pAddr_p) |
9d7164cf DK |
629 | { |
630 | ||
833dfbe7 | 631 | tqwStruct qwStruct; |
9d7164cf | 632 | |
833dfbe7 GKH |
633 | qwStruct.m_qwQword = AmiGetQword64FromLe(pAddr_p); |
634 | qwStruct.m_qwQword &= 0x000000FFFFFFFFFFLL; | |
9d7164cf | 635 | |
833dfbe7 | 636 | return (qwStruct.m_qwQword); |
9d7164cf DK |
637 | |
638 | } | |
639 | ||
9d7164cf DK |
640 | //--------------------------------------------------------------------------- |
641 | // | |
642 | // Function: AmiSetQword48ToBe() | |
643 | // | |
644 | // Description: sets a 48 bit value to a buffer in big endian | |
645 | // | |
646 | // Parameters: pAddr_p = pointer to destination buffer | |
647 | // qwQwordVal_p = quadruple word value | |
648 | // | |
649 | // Return: void | |
650 | // | |
651 | // State: not tested | |
652 | // | |
653 | //--------------------------------------------------------------------------- | |
654 | ||
833dfbe7 GKH |
655 | INLINE_FUNCTION void PUBLIC AmiSetQword48ToBe(void FAR * pAddr_p, |
656 | QWORD qwQwordVal_p) | |
9d7164cf DK |
657 | { |
658 | ||
833dfbe7 GKH |
659 | ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[5]; |
660 | ((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & qwQwordVal_p)[4]; | |
661 | ((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & qwQwordVal_p)[3]; | |
662 | ((BYTE FAR *) pAddr_p)[3] = ((BYTE FAR *) & qwQwordVal_p)[2]; | |
663 | ((BYTE FAR *) pAddr_p)[4] = ((BYTE FAR *) & qwQwordVal_p)[1]; | |
664 | ((BYTE FAR *) pAddr_p)[5] = ((BYTE FAR *) & qwQwordVal_p)[0]; | |
9d7164cf DK |
665 | |
666 | } | |
667 | ||
9d7164cf DK |
668 | //--------------------------------------------------------------------------- |
669 | // | |
670 | // Function: AmiSetQword48ToLe() | |
671 | // | |
672 | // Description: sets a 48 bit value to a buffer in little endian | |
673 | // | |
674 | // Parameters: pAddr_p = pointer to destination buffer | |
675 | // qwQwordVal_p = quadruple word value | |
676 | // | |
677 | // Return: void | |
678 | // | |
679 | // State: not tested | |
680 | // | |
681 | //--------------------------------------------------------------------------- | |
682 | ||
833dfbe7 GKH |
683 | INLINE_FUNCTION void PUBLIC AmiSetQword48ToLe(void FAR * pAddr_p, |
684 | QWORD qwQwordVal_p) | |
9d7164cf DK |
685 | { |
686 | ||
833dfbe7 GKH |
687 | ((DWORD FAR *) pAddr_p)[0] = ((DWORD FAR *) & qwQwordVal_p)[0]; |
688 | ((WORD FAR *) pAddr_p)[2] = ((WORD FAR *) & qwQwordVal_p)[2]; | |
9d7164cf DK |
689 | |
690 | } | |
691 | ||
9d7164cf DK |
692 | //--------------------------------------------------------------------------- |
693 | // | |
694 | // Function: AmiGetQword48FromBe() | |
695 | // | |
696 | // Description: reads a 48 bit value from a buffer in big endian | |
697 | // | |
698 | // Parameters: pAddr_p = pointer to source buffer | |
699 | // | |
700 | // Return: QWORD | |
701 | // | |
702 | // State: not tested | |
703 | // | |
704 | //--------------------------------------------------------------------------- | |
705 | ||
833dfbe7 | 706 | INLINE_FUNCTION QWORD PUBLIC AmiGetQword48FromBe(void FAR * pAddr_p) |
9d7164cf DK |
707 | { |
708 | ||
833dfbe7 | 709 | tqwStruct qwStruct; |
9d7164cf | 710 | |
833dfbe7 GKH |
711 | qwStruct.m_qwQword = AmiGetQword64FromBe(pAddr_p); |
712 | qwStruct.m_qwQword >>= 16; | |
9d7164cf | 713 | |
833dfbe7 | 714 | return (qwStruct.m_qwQword); |
9d7164cf DK |
715 | |
716 | } | |
717 | ||
9d7164cf DK |
718 | //--------------------------------------------------------------------------- |
719 | // | |
720 | // Function: AmiGetQword48FromLe() | |
721 | // | |
722 | // Description: reads a 48 bit value from a buffer in little endian | |
723 | // | |
724 | // Parameters: pAddr_p = pointer to source buffer | |
725 | // | |
726 | // Return: QWORD | |
727 | // | |
728 | // State: not tested | |
729 | // | |
730 | //--------------------------------------------------------------------------- | |
731 | ||
833dfbe7 | 732 | INLINE_FUNCTION QWORD PUBLIC AmiGetQword48FromLe(void FAR * pAddr_p) |
9d7164cf DK |
733 | { |
734 | ||
833dfbe7 | 735 | tqwStruct qwStruct; |
9d7164cf | 736 | |
833dfbe7 GKH |
737 | qwStruct.m_qwQword = AmiGetQword64FromLe(pAddr_p); |
738 | qwStruct.m_qwQword &= 0x0000FFFFFFFFFFFFLL; | |
9d7164cf | 739 | |
833dfbe7 | 740 | return (qwStruct.m_qwQword); |
9d7164cf DK |
741 | |
742 | } | |
743 | ||
9d7164cf DK |
744 | //--------------------------------------------------------------------------- |
745 | // | |
746 | // Function: AmiSetQword56ToBe() | |
747 | // | |
748 | // Description: sets a 56 bit value to a buffer in big endian | |
749 | // | |
750 | // Parameters: pAddr_p = pointer to destination buffer | |
751 | // qwQwordVal_p = quadruple word value | |
752 | // | |
753 | // Return: void | |
754 | // | |
755 | // State: not tested | |
756 | // | |
757 | //--------------------------------------------------------------------------- | |
758 | ||
833dfbe7 GKH |
759 | INLINE_FUNCTION void PUBLIC AmiSetQword56ToBe(void FAR * pAddr_p, |
760 | QWORD qwQwordVal_p) | |
9d7164cf DK |
761 | { |
762 | ||
833dfbe7 GKH |
763 | ((BYTE FAR *) pAddr_p)[0] = ((BYTE FAR *) & qwQwordVal_p)[6]; |
764 | ((BYTE FAR *) pAddr_p)[1] = ((BYTE FAR *) & qwQwordVal_p)[5]; | |
765 | ((BYTE FAR *) pAddr_p)[2] = ((BYTE FAR *) & qwQwordVal_p)[4]; | |
766 | ((BYTE FAR *) pAddr_p)[3] = ((BYTE FAR *) & qwQwordVal_p)[3]; | |
767 | ((BYTE FAR *) pAddr_p)[4] = ((BYTE FAR *) & qwQwordVal_p)[2]; | |
768 | ((BYTE FAR *) pAddr_p)[5] = ((BYTE FAR *) & qwQwordVal_p)[1]; | |
769 | ((BYTE FAR *) pAddr_p)[6] = ((BYTE FAR *) & qwQwordVal_p)[0]; | |
9d7164cf DK |
770 | |
771 | } | |
772 | ||
9d7164cf DK |
773 | //--------------------------------------------------------------------------- |
774 | // | |
775 | // Function: AmiSetQword56ToLe() | |
776 | // | |
777 | // Description: sets a 56 bit value to a buffer in little endian | |
778 | // | |
779 | // Parameters: pAddr_p = pointer to destination buffer | |
780 | // qwQwordVal_p = quadruple word value | |
781 | // | |
782 | // Return: void | |
783 | // | |
784 | // State: not tested | |
785 | // | |
786 | //--------------------------------------------------------------------------- | |
787 | ||
833dfbe7 GKH |
788 | INLINE_FUNCTION void PUBLIC AmiSetQword56ToLe(void FAR * pAddr_p, |
789 | QWORD qwQwordVal_p) | |
9d7164cf DK |
790 | { |
791 | ||
833dfbe7 GKH |
792 | ((DWORD FAR *) pAddr_p)[0] = ((DWORD FAR *) & qwQwordVal_p)[0]; |
793 | ((WORD FAR *) pAddr_p)[2] = ((WORD FAR *) & qwQwordVal_p)[2]; | |
794 | ((BYTE FAR *) pAddr_p)[6] = ((BYTE FAR *) & qwQwordVal_p)[6]; | |
9d7164cf DK |
795 | |
796 | } | |
797 | ||
9d7164cf DK |
798 | //--------------------------------------------------------------------------- |
799 | // | |
800 | // Function: AmiGetQword56FromBe() | |
801 | // | |
802 | // Description: reads a 56 bit value from a buffer in big endian | |
803 | // | |
804 | // Parameters: pAddr_p = pointer to source buffer | |
805 | // | |
806 | // Return: QWORD | |
807 | // | |
808 | // State: not tested | |
809 | // | |
810 | //--------------------------------------------------------------------------- | |
811 | ||
833dfbe7 | 812 | INLINE_FUNCTION QWORD PUBLIC AmiGetQword56FromBe(void FAR * pAddr_p) |
9d7164cf DK |
813 | { |
814 | ||
833dfbe7 | 815 | tqwStruct qwStruct; |
9d7164cf | 816 | |
833dfbe7 GKH |
817 | qwStruct.m_qwQword = AmiGetQword64FromBe(pAddr_p); |
818 | qwStruct.m_qwQword >>= 8; | |
9d7164cf | 819 | |
833dfbe7 | 820 | return (qwStruct.m_qwQword); |
9d7164cf DK |
821 | |
822 | } | |
823 | ||
9d7164cf DK |
824 | //--------------------------------------------------------------------------- |
825 | // | |
826 | // Function: AmiGetQword56FromLe() | |
827 | // | |
828 | // Description: reads a 56 bit value from a buffer in little endian | |
829 | // | |
830 | // Parameters: pAddr_p = pointer to source buffer | |
831 | // | |
832 | // Return: QWORD | |
833 | // | |
834 | // State: not tested | |
835 | // | |
836 | //--------------------------------------------------------------------------- | |
837 | ||
833dfbe7 | 838 | INLINE_FUNCTION QWORD PUBLIC AmiGetQword56FromLe(void FAR * pAddr_p) |
9d7164cf DK |
839 | { |
840 | ||
833dfbe7 | 841 | tqwStruct qwStruct; |
9d7164cf | 842 | |
833dfbe7 GKH |
843 | qwStruct.m_qwQword = AmiGetQword64FromLe(pAddr_p); |
844 | qwStruct.m_qwQword &= 0x00FFFFFFFFFFFFFFLL; | |
9d7164cf | 845 | |
833dfbe7 | 846 | return (qwStruct.m_qwQword); |
9d7164cf DK |
847 | |
848 | } | |
849 | ||
9d7164cf DK |
850 | //--------------------------------------------------------------------------- |
851 | // | |
852 | // Function: AmiSetTimeOfDay() | |
853 | // | |
854 | // Description: sets a TIME_OF_DAY (CANopen) value to a buffer | |
855 | // | |
856 | // Parameters: pAddr_p = pointer to destination buffer | |
857 | // pTimeOfDay_p = pointer to struct TIME_OF_DAY | |
858 | // | |
859 | // Return: void | |
860 | // | |
861 | // State: not tested | |
862 | // | |
863 | //--------------------------------------------------------------------------- | |
864 | ||
833dfbe7 GKH |
865 | INLINE_FUNCTION void PUBLIC AmiSetTimeOfDay(void FAR * pAddr_p, |
866 | tTimeOfDay FAR * pTimeOfDay_p) | |
9d7164cf DK |
867 | { |
868 | ||
833dfbe7 GKH |
869 | AmiSetDwordToLe(((BYTE FAR *) pAddr_p), |
870 | pTimeOfDay_p->m_dwMs & 0x0FFFFFFF); | |
871 | AmiSetWordToLe(((BYTE FAR *) pAddr_p) + 4, pTimeOfDay_p->m_wDays); | |
9d7164cf DK |
872 | |
873 | } | |
874 | ||
9d7164cf DK |
875 | //--------------------------------------------------------------------------- |
876 | // | |
877 | // Function: AmiGetTimeOfDay() | |
878 | // | |
879 | // Description: reads a TIME_OF_DAY (CANopen) value from a buffer | |
880 | // | |
881 | // Parameters: pAddr_p = pointer to source buffer | |
882 | // pTimeOfDay_p = pointer to struct TIME_OF_DAY | |
883 | // | |
884 | // Return: void | |
885 | // | |
886 | // State: not tested | |
887 | // | |
888 | //--------------------------------------------------------------------------- | |
889 | ||
833dfbe7 GKH |
890 | INLINE_FUNCTION void PUBLIC AmiGetTimeOfDay(void FAR * pAddr_p, |
891 | tTimeOfDay FAR * pTimeOfDay_p) | |
9d7164cf DK |
892 | { |
893 | ||
833dfbe7 GKH |
894 | pTimeOfDay_p->m_dwMs = |
895 | AmiGetDwordFromLe(((BYTE FAR *) pAddr_p)) & 0x0FFFFFFF; | |
896 | pTimeOfDay_p->m_wDays = AmiGetWordFromLe(((BYTE FAR *) pAddr_p) + 4); | |
9d7164cf DK |
897 | |
898 | } | |
899 | ||
9d7164cf DK |
900 | #endif |
901 | ||
9d7164cf DK |
902 | // EOF |
903 | ||
904 |