MdePkg/Library/BaseLib/CheckSum.c

   1 /** @file
   2   Utility functions to generate checksum based on 2's complement
   3   algorithm.
   4
   5   Copyright (c) 2007, Intel Corporation<BR>
   6   All rights reserved. This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 //
  17 // Include common header file for this module.
  18 //
  19 #include <BaseLibInternals.h>
  20
  21
  22 /**
  23   Calculate the sum of all elements in a buffer in unit of UINT8.
  24   During calculation, the carry bits are dropped.
  25
  26   This function calculates the sum of all elements in a buffer
  27   in unit of UINT8. The carry bits in result of addition are dropped.
  28   The result is returned as UINT8. If Length is Zero, then Zero is
  29   returned.
  30
  31   If Buffer is NULL, then ASSERT().
  32   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
  33
  34   @param  Buffer                        Pointer to the buffer to carry out the sum operation.
  35   @param  Length            The size, in bytes, of Buffer .
  36
  37   @return Sum         The sum of Buffer with carry bits dropped during additions.
  38
  39 **/
  40 UINT8
  41 EFIAPI
  42 CalculateSum8 (
  43   IN      CONST UINT8                   *Buffer,
  44   IN      UINTN                               Length
  45   )
  46 {
  47   UINT8     Sum;
  48   UINTN     Count;
  49
  50   ASSERT (Buffer != NULL);
  51   ASSERT (Length <= (MAX_ADDRESS - ((UINTN) Buffer) + 1));
  52
  53   for (Sum = 0, Count = 0; Count < Length; Count++) {
  54     Sum = (UINT8) (Sum + *(Buffer + Count));
  55   }
  56
  57   return Sum;
  58 }
  59
  60
  61 /**
  62   Returns the two's complement checksum of all elements in a buffer
  63   of 8-bit values.
  64
  65   This function first calculates the sum of the 8-bit values in the
  66   buffer specified by Buffer and Length.  The carry bits in the result
  67   of addition are dropped. Then, the two's complement of the sum is
  68   returned.  If Length is 0, then 0 is returned.
  69
  70   If Buffer is NULL, then ASSERT().
  71   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
  72
  73
  74   @param  Buffer                        Pointer to the buffer to carry out the checksum operation.
  75   @param  Length            The size, in bytes, of Buffer.
  76
  77   @return Checksum        The 2's complement checksum of Buffer.
  78
  79 **/
  80 UINT8
  81 EFIAPI
  82 CalculateCheckSum8 (
  83   IN      CONST UINT8                   *Buffer,
  84   IN      UINTN                               Length
  85   )
  86 {
  87   UINT8     CheckSum;
  88
  89   CheckSum = CalculateSum8 (Buffer, Length);
  90
  91   //
  92   // Return the checksum based on 2's complement.
  93   //
  94   return (UINT8) (0x100 - CheckSum);
  95 }
  96
  97 /**
  98   Returns the sum of all elements in a buffer of 16-bit values.  During
  99   calculation, the carry bits are dropped.
 100
 101   This function calculates the sum of the 16-bit values in the buffer
 102   specified by Buffer and Length. The carry bits in result of addition are dropped.
 103   The 16-bit result is returned.  If Length is 0, then 0 is returned.
 104
 105   If Buffer is NULL, then ASSERT().
 106   If Buffer is not aligned on a 16-bit boundary, then ASSERT().
 107   If Length is not aligned on a 16-bit boundary, then ASSERT().
 108   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
 109
 110   @param  Buffer                        Pointer to the buffer to carry out the sum operation.
 111   @param  Length            The size, in bytes, of Buffer.
 112
 113   @return Sum         The sum of Buffer with carry bits dropped during additions.
 114
 115 **/
 116 UINT16
 117 EFIAPI
 118 CalculateSum16 (
 119   IN      CONST UINT16                  *Buffer,
 120   IN      UINTN                               Length
 121   )
 122 {
 123   UINT16    Sum;
 124   UINTN     Count;
 125
 126   ASSERT (Buffer != NULL);
 127   ASSERT (((UINTN) Buffer & 0x1) == 0);
 128   ASSERT ((Length & 0x1) == 0);
 129   ASSERT (Length <= (MAX_ADDRESS - ((UINTN) Buffer) + 1));
 130
 131
 132   for (Sum = 0, Count = 0; Count < Length; Count++) {
 133     Sum = (UINT16) (Sum + *(Buffer + Count));
 134   }
 135
 136   return Sum;
 137 }
 138
 139
 140 /**
 141   Returns the two's complement checksum of all elements in a buffer of
 142   16-bit values.
 143
 144   This function first calculates the sum of the 16-bit values in the buffer
 145   specified by Buffer and Length.  The carry bits in the result of addition
 146   are dropped. Then, the two's complement of the sum is returned.  If Length
 147   is 0, then 0 is returned.
 148
 149   If Buffer is NULL, then ASSERT().
 150   If Buffer is not aligned on a 16-bit boundary, then ASSERT().
 151   If Length is not aligned on a 16-bit boundary, then ASSERT().
 152   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
 153
 154   @param  Buffer                        Pointer to the buffer to carry out the checksum operation.
 155   @param  Length            The size, in bytes, of Buffer.
 156
 157   @return Checksum        The 2's complement checksum of Buffer.
 158
 159 **/
 160 UINT16
 161 EFIAPI
 162 CalculateCheckSum16 (
 163   IN      CONST UINT16                  *Buffer,
 164   IN      UINTN                               Length
 165   )
 166 {
 167   UINT16     CheckSum;
 168
 169   CheckSum = CalculateSum16 (Buffer, Length);
 170
 171   //
 172   // Return the checksum based on 2's complement.
 173   //
 174   return (UINT16) (0x10000 - CheckSum);
 175 }
 176
 177
 178 /**
 179   Returns the sum of all elements in a buffer of 32-bit values.  During
 180   calculation, the carry bits are dropped.
 181
 182   This function calculates the sum of the 32-bit values in the buffer
 183   specified by Buffer and Length. The carry bits in result of addition are dropped.
 184   The 32-bit result is returned.  If Length is 0, then 0 is returned.
 185
 186   If Buffer is NULL, then ASSERT().
 187   If Buffer is not aligned on a 32-bit boundary, then ASSERT().
 188   If Length is not aligned on a 32-bit boundary, then ASSERT().
 189   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
 190
 191   @param  Buffer                        Pointer to the buffer to carry out the sum operation.
 192   @param  Length            The size, in bytes, of Buffer.
 193
 194   @return Sum         The sum of Buffer with carry bits dropped during additions.
 195
 196 **/
 197 UINT32
 198 EFIAPI
 199 CalculateSum32 (
 200   IN      CONST UINT32                  *Buffer,
 201   IN      UINTN                               Length
 202   )
 203 {
 204   UINT32    Sum;
 205   UINTN     Count;
 206
 207   ASSERT (Buffer != NULL);
 208   ASSERT (((UINTN) Buffer & 0x3) == 0);
 209   ASSERT ((Length & 0x3) == 0);
 210   ASSERT (Length <= (MAX_ADDRESS - ((UINTN) Buffer) + 1));
 211
 212
 213   for (Sum = 0, Count = 0; Count < Length; Count++) {
 214     Sum = Sum + *(Buffer + Count);
 215   }
 216
 217   return Sum;
 218 }
 219
 220
 221 /**
 222   Returns the two's complement checksum of all elements in a buffer of
 223   32-bit values.
 224
 225   This function first calculates the sum of the 32-bit values in the buffer
 226   specified by Buffer and Length.  The carry bits in the result of addition
 227   are dropped. Then, the two's complement of the sum is returned.  If Length
 228   is 0, then 0 is returned.
 229
 230   If Buffer is NULL, then ASSERT().
 231   If Buffer is not aligned on a 32-bit boundary, then ASSERT().
 232   If Length is not aligned on a 32-bit boundary, then ASSERT().
 233   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
 234
 235   @param  Buffer                        Pointer to the buffer to carry out the checksum operation.
 236   @param  Length            The size, in bytes, of Buffer.
 237
 238   @return Checksum        The 2's complement checksum of Buffer.
 239
 240 **/
 241 UINT32
 242 EFIAPI
 243 CalculateCheckSum32 (
 244   IN      CONST UINT32                  *Buffer,
 245   IN      UINTN                               Length
 246   )
 247 {
 248   UINT32     CheckSum;
 249
 250   CheckSum = CalculateSum32 (Buffer, Length);
 251
 252   //
 253   // Return the checksum based on 2's complement.
 254   //
 255   return (UINT32) ((UINT32)(-1) - CheckSum + 1);
 256 }
 257
 258
 259 /**
 260   Returns the sum of all elements in a buffer of 64-bit values.  During
 261   calculation, the carry bits are dropped.
 262
 263   This function calculates the sum of the 64-bit values in the buffer
 264   specified by Buffer and Length. The carry bits in result of addition are dropped.
 265   The 64-bit result is returned.  If Length is 0, then 0 is returned.
 266
 267   If Buffer is NULL, then ASSERT().
 268   If Buffer is not aligned on a 64-bit boundary, then ASSERT().
 269   If Length is not aligned on a 64-bit boundary, then ASSERT().
 270   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
 271
 272   @param  Buffer                        Pointer to the buffer to carry out the sum operation.
 273   @param  Length            The size, in bytes, of Buffer.
 274
 275   @return Sum         The sum of Buffer with carry bits dropped during additions.
 276
 277 **/
 278 UINT64
 279 EFIAPI
 280 CalculateSum64 (
 281   IN      CONST UINT64                  *Buffer,
 282   IN      UINTN                               Length
 283   )
 284 {
 285   UINT64    Sum;
 286   UINTN     Count;
 287
 288   ASSERT (Buffer != NULL);
 289   ASSERT (((UINTN) Buffer & 0x7) == 0);
 290   ASSERT ((Length & 0x7) == 0);
 291   ASSERT (Length <= (MAX_ADDRESS - ((UINTN) Buffer) + 1));
 292
 293   for (Sum = 0, Count = 0; Count < Length; Count++) {
 294     Sum = Sum + *(Buffer + Count);
 295   }
 296
 297   return Sum;
 298 }
 299
 300
 301 /**
 302   Returns the two's complement checksum of all elements in a buffer of
 303   64-bit values.
 304
 305   This function first calculates the sum of the 64-bit values in the buffer
 306   specified by Buffer and Length.  The carry bits in the result of addition
 307   are dropped. Then, the two's complement of the sum is returned.  If Length
 308   is 0, then 0 is returned.
 309
 310   If Buffer is NULL, then ASSERT().
 311   If Buffer is not aligned on a 64-bit boundary, then ASSERT().
 312   If Length is not aligned on a 64-bit boundary, then ASSERT().
 313   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
 314
 315   @param  Buffer                        Pointer to the buffer to carry out the checksum operation.
 316   @param  Length            The size, in bytes, of Buffer.
 317
 318   @return Checksum        The 2's complement checksum of Buffer.
 319
 320 **/
 321 UINT64
 322 EFIAPI
 323 CalculateCheckSum64 (
 324   IN      CONST UINT64                  *Buffer,
 325   IN      UINTN                               Length
 326   )
 327 {
 328   UINT64     CheckSum;
 329
 330   CheckSum = CalculateSum64 (Buffer, Length);
 331
 332   //
 333   // Return the checksum based on 2's complement.
 334   //
 335   return (UINT64) ((UINT64)(-1) - CheckSum + 1);
 336 }
 337
 338