MdePkg/Library/BaseLib/Unaligned.c

   1 /** @file
   2   Unaligned access functions of BaseLib.
   3
   4   Copyright (c) 2006, Intel Corporation
   5   All rights reserved. This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13   Module Name:  Unaligned.c
  14
  15 **/
  16
  17 /**
  18   Reads a 16-bit value from memory that may be unaligned.
  19
  20   This function returns the 16-bit value pointed to by Buffer. The function
  21   guarantees that the read operation does not produce an alignment fault.
  22
  23   If the Buffer is NULL, then ASSERT().
  24
  25   @param  Buffer  Pointer to a 16-bit value that may be unaligned.
  26
  27   @return *Uint16
  28
  29 **/
  30 UINT16
  31 EFIAPI
  32 ReadUnaligned16 (
  33   IN      CONST UINT16              *Buffer
  34   )
  35 {
  36   ASSERT (Buffer != NULL);
  37
  38   return *Buffer;
  39 }
  40
  41 /**
  42   Writes a 16-bit value to memory that may be unaligned.
  43
  44   This function writes the 16-bit value specified by Value to Buffer. Value is
  45   returned. The function guarantees that the write operation does not produce
  46   an alignment fault.
  47
  48   If the Buffer is NULL, then ASSERT().
  49
  50   @param  Buffer  Pointer to a 16-bit value that may be unaligned.
  51   @param  Value   16-bit value to write to Buffer.
  52
  53   @return Value
  54
  55 **/
  56 UINT16
  57 EFIAPI
  58 WriteUnaligned16 (
  59   OUT     UINT16                    *Buffer,
  60   IN      UINT16                    Value
  61   )
  62 {
  63   ASSERT (Buffer != NULL);
  64
  65   return *Buffer = Value;
  66 }
  67
  68 /**
  69   Reads a 24-bit value from memory that may be unaligned.
  70
  71   This function returns the 24-bit value pointed to by Buffer. The function
  72   guarantees that the read operation does not produce an alignment fault.
  73
  74   If the Buffer is NULL, then ASSERT().
  75
  76   @param  Buffer  Pointer to a 24-bit value that may be unaligned.
  77
  78   @return The value read.
  79
  80 **/
  81 UINT32
  82 EFIAPI
  83 ReadUnaligned24 (
  84   IN      CONST UINT32              *Buffer
  85   )
  86 {
  87   ASSERT (Buffer != NULL);
  88
  89   return *Buffer & 0xffffff;
  90 }
  91
  92 /**
  93   Writes a 24-bit value to memory that may be unaligned.
  94
  95   This function writes the 24-bit value specified by Value to Buffer. Value is
  96   returned. The function guarantees that the write operation does not produce
  97   an alignment fault.
  98
  99   If the Buffer is NULL, then ASSERT().
 100
 101   @param  Buffer  Pointer to a 24-bit value that may be unaligned.
 102   @param  Value   24-bit value to write to Buffer.
 103
 104   @return The value written.
 105
 106 **/
 107 UINT32
 108 EFIAPI
 109 WriteUnaligned24 (
 110   OUT     UINT32                    *Buffer,
 111   IN      UINT32                    Value
 112   )
 113 {
 114   ASSERT (Buffer != NULL);
 115
 116   return *Buffer = BitFieldWrite32 (*Buffer, 0, 23, Value);
 117 }
 118
 119 /**
 120   Reads a 32-bit value from memory that may be unaligned.
 121
 122   This function returns the 32-bit value pointed to by Buffer. The function
 123   guarantees that the read operation does not produce an alignment fault.
 124
 125   If the Buffer is NULL, then ASSERT().
 126
 127   @param  Buffer  Pointer to a 32-bit value that may be unaligned.
 128
 129   @return *Uint32
 130
 131 **/
 132 UINT32
 133 EFIAPI
 134 ReadUnaligned32 (
 135   IN      CONST UINT32              *Buffer
 136   )
 137 {
 138   ASSERT (Buffer != NULL);
 139
 140   return *Buffer;
 141 }
 142
 143 /**
 144   Writes a 32-bit value to memory that may be unaligned.
 145
 146   This function writes the 32-bit value specified by Value to Buffer. Value is
 147   returned. The function guarantees that the write operation does not produce
 148   an alignment fault.
 149
 150   If the Buffer is NULL, then ASSERT().
 151
 152   @param  Buffer  Pointer to a 32-bit value that may be unaligned.
 153   @param  Value   32-bit value to write to Buffer.
 154
 155   @return Value
 156
 157 **/
 158 UINT32
 159 EFIAPI
 160 WriteUnaligned32 (
 161   OUT     UINT32                    *Buffer,
 162   IN      UINT32                    Value
 163   )
 164 {
 165   ASSERT (Buffer != NULL);
 166
 167   return *Buffer = Value;
 168 }
 169
 170 /**
 171   Reads a 64-bit value from memory that may be unaligned.
 172
 173   This function returns the 64-bit value pointed to by Buffer. The function
 174   guarantees that the read operation does not produce an alignment fault.
 175
 176   If the Buffer is NULL, then ASSERT().
 177
 178   @param  Buffer  Pointer to a 64-bit value that may be unaligned.
 179
 180   @return *Uint64
 181
 182 **/
 183 UINT64
 184 EFIAPI
 185 ReadUnaligned64 (
 186   IN      CONST UINT64              *Buffer
 187   )
 188 {
 189   ASSERT (Buffer != NULL);
 190
 191   return *Buffer;
 192 }
 193
 194 /**
 195   Writes a 64-bit value to memory that may be unaligned.
 196
 197   This function writes the 64-bit value specified by Value to Buffer. Value is
 198   returned. The function guarantees that the write operation does not produce
 199   an alignment fault.
 200
 201   If the Buffer is NULL, then ASSERT().
 202
 203   @param  Buffer  Pointer to a 64-bit value that may be unaligned.
 204   @param  Value   64-bit value to write to Buffer.
 205
 206   @return Value
 207
 208 **/
 209 UINT64
 210 EFIAPI
 211 WriteUnaligned64 (
 212   OUT     UINT64                    *Buffer,
 213   IN      UINT64                    Value
 214   )
 215 {
 216   ASSERT (Buffer != NULL);
 217
 218   return *Buffer = Value;
 219 }