drivers/staging/epl/amix86.c

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