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