andrewfish | 5fc3b5d | 2010-07-22 19:22:34 +0000 | [diff] [blame] | 1 | /** @file
|
| 2 | IA-32/x64 MSR functions.
|
| 3 |
|
| 4 | Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
|
| 5 | 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 | **/
|
| 14 |
|
| 15 |
|
| 16 | #include "BaseLibInternals.h"
|
| 17 |
|
| 18 |
|
| 19 | /**
|
| 20 | Returns the lower 32-bits of a Machine Specific Register(MSR).
|
| 21 |
|
| 22 | Reads and returns the lower 32-bits of the MSR specified by Index.
|
| 23 | No parameter checking is performed on Index, and some Index values may cause
|
| 24 | CPU exceptions. The caller must either guarantee that Index is valid, or the
|
| 25 | caller must set up exception handlers to catch the exceptions. This function
|
| 26 | is only available on IA-32 and x64.
|
| 27 |
|
| 28 | @param Index The 32-bit MSR index to read.
|
| 29 |
|
| 30 | @return The lower 32 bits of the MSR identified by Index.
|
| 31 |
|
| 32 | **/
|
| 33 | UINT32
|
| 34 | EFIAPI
|
| 35 | AsmReadMsr32 (
|
| 36 | IN UINT32 Index
|
| 37 | )
|
| 38 | {
|
| 39 | return (UINT32)AsmReadMsr64 (Index);
|
| 40 | }
|
| 41 |
|
| 42 | /**
|
| 43 | Writes a 32-bit value to a Machine Specific Register(MSR), and returns the value.
|
| 44 | The upper 32-bits of the MSR are set to zero.
|
| 45 |
|
| 46 | Writes the 32-bit value specified by Value to the MSR specified by Index. The
|
| 47 | upper 32-bits of the MSR write are set to zero. The 32-bit value written to
|
| 48 | the MSR is returned. No parameter checking is performed on Index or Value,
|
| 49 | and some of these may cause CPU exceptions. The caller must either guarantee
|
| 50 | that Index and Value are valid, or the caller must establish proper exception
|
| 51 | handlers. This function is only available on IA-32 and x64.
|
| 52 |
|
| 53 | @param Index The 32-bit MSR index to write.
|
| 54 | @param Value The 32-bit value to write to the MSR.
|
| 55 |
|
| 56 | @return Value
|
| 57 |
|
| 58 | **/
|
| 59 | UINT32
|
| 60 | EFIAPI
|
| 61 | AsmWriteMsr32 (
|
| 62 | IN UINT32 Index,
|
| 63 | IN UINT32 Value
|
| 64 | )
|
| 65 | {
|
| 66 | return (UINT32)AsmWriteMsr64 (Index, Value);
|
| 67 | }
|
| 68 |
|
| 69 | /**
|
| 70 | Reads a 64-bit MSR, performs a bitwise OR on the lower 32-bits, and
|
| 71 | writes the result back to the 64-bit MSR.
|
| 72 |
|
| 73 | Reads the 64-bit MSR specified by Index, performs a bitwise OR
|
| 74 | between the lower 32-bits of the read result and the value specified by
|
| 75 | OrData, and writes the result to the 64-bit MSR specified by Index. The lower
|
| 76 | 32-bits of the value written to the MSR is returned. No parameter checking is
|
| 77 | performed on Index or OrData, and some of these may cause CPU exceptions. The
|
| 78 | caller must either guarantee that Index and OrData are valid, or the caller
|
| 79 | must establish proper exception handlers. This function is only available on
|
| 80 | IA-32 and x64.
|
| 81 |
|
| 82 | @param Index The 32-bit MSR index to write.
|
| 83 | @param OrData The value to OR with the read value from the MSR.
|
| 84 |
|
| 85 | @return The lower 32-bit value written to the MSR.
|
| 86 |
|
| 87 | **/
|
| 88 | UINT32
|
| 89 | EFIAPI
|
| 90 | AsmMsrOr32 (
|
| 91 | IN UINT32 Index,
|
| 92 | IN UINT32 OrData
|
| 93 | )
|
| 94 | {
|
| 95 | return (UINT32)AsmMsrOr64 (Index, OrData);
|
| 96 | }
|
| 97 |
|
| 98 | /**
|
| 99 | Reads a 64-bit MSR, performs a bitwise AND on the lower 32-bits, and writes
|
| 100 | the result back to the 64-bit MSR.
|
| 101 |
|
| 102 | Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
|
| 103 | lower 32-bits of the read result and the value specified by AndData, and
|
| 104 | writes the result to the 64-bit MSR specified by Index. The lower 32-bits of
|
| 105 | the value written to the MSR is returned. No parameter checking is performed
|
| 106 | on Index or AndData, and some of these may cause CPU exceptions. The caller
|
| 107 | must either guarantee that Index and AndData are valid, or the caller must
|
| 108 | establish proper exception handlers. This function is only available on IA-32
|
| 109 | and x64.
|
| 110 |
|
| 111 | @param Index The 32-bit MSR index to write.
|
| 112 | @param AndData The value to AND with the read value from the MSR.
|
| 113 |
|
| 114 | @return The lower 32-bit value written to the MSR.
|
| 115 |
|
| 116 | **/
|
| 117 | UINT32
|
| 118 | EFIAPI
|
| 119 | AsmMsrAnd32 (
|
| 120 | IN UINT32 Index,
|
| 121 | IN UINT32 AndData
|
| 122 | )
|
| 123 | {
|
| 124 | return (UINT32)AsmMsrAnd64 (Index, AndData);
|
| 125 | }
|
| 126 |
|
| 127 | /**
|
| 128 | Reads a 64-bit MSR, performs a bitwise AND followed by a bitwise OR
|
| 129 | on the lower 32-bits, and writes the result back to the 64-bit MSR.
|
| 130 |
|
| 131 | Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
|
| 132 | lower 32-bits of the read result and the value specified by AndData
|
| 133 | preserving the upper 32-bits, performs a bitwise OR between the
|
| 134 | result of the AND operation and the value specified by OrData, and writes the
|
| 135 | result to the 64-bit MSR specified by Address. The lower 32-bits of the value
|
| 136 | written to the MSR is returned. No parameter checking is performed on Index,
|
| 137 | AndData, or OrData, and some of these may cause CPU exceptions. The caller
|
| 138 | must either guarantee that Index, AndData, and OrData are valid, or the
|
| 139 | caller must establish proper exception handlers. This function is only
|
| 140 | available on IA-32 and x64.
|
| 141 |
|
| 142 | @param Index The 32-bit MSR index to write.
|
| 143 | @param AndData The value to AND with the read value from the MSR.
|
| 144 | @param OrData The value to OR with the result of the AND operation.
|
| 145 |
|
| 146 | @return The lower 32-bit value written to the MSR.
|
| 147 |
|
| 148 | **/
|
| 149 | UINT32
|
| 150 | EFIAPI
|
| 151 | AsmMsrAndThenOr32 (
|
| 152 | IN UINT32 Index,
|
| 153 | IN UINT32 AndData,
|
| 154 | IN UINT32 OrData
|
| 155 | )
|
| 156 | {
|
| 157 | return (UINT32)AsmMsrAndThenOr64 (Index, AndData, OrData);
|
| 158 | }
|
| 159 |
|
| 160 | /**
|
| 161 | Reads a bit field of an MSR.
|
| 162 |
|
| 163 | Reads the bit field in the lower 32-bits of a 64-bit MSR. The bit field is
|
| 164 | specified by the StartBit and the EndBit. The value of the bit field is
|
| 165 | returned. The caller must either guarantee that Index is valid, or the caller
|
| 166 | must set up exception handlers to catch the exceptions. This function is only
|
| 167 | available on IA-32 and x64.
|
| 168 |
|
| 169 | If StartBit is greater than 31, then ASSERT().
|
| 170 | If EndBit is greater than 31, then ASSERT().
|
| 171 | If EndBit is less than StartBit, then ASSERT().
|
| 172 |
|
| 173 | @param Index The 32-bit MSR index to read.
|
| 174 | @param StartBit The ordinal of the least significant bit in the bit field.
|
| 175 | Range 0..31.
|
| 176 | @param EndBit The ordinal of the most significant bit in the bit field.
|
| 177 | Range 0..31.
|
| 178 |
|
| 179 | @return The bit field read from the MSR.
|
| 180 |
|
| 181 | **/
|
| 182 | UINT32
|
| 183 | EFIAPI
|
| 184 | AsmMsrBitFieldRead32 (
|
| 185 | IN UINT32 Index,
|
| 186 | IN UINTN StartBit,
|
| 187 | IN UINTN EndBit
|
| 188 | )
|
| 189 | {
|
| 190 | return BitFieldRead32 (AsmReadMsr32 (Index), StartBit, EndBit);
|
| 191 | }
|
| 192 |
|
| 193 | /**
|
| 194 | Writes a bit field to an MSR.
|
| 195 |
|
| 196 | Writes Value to a bit field in the lower 32-bits of a 64-bit MSR. The bit
|
| 197 | field is specified by the StartBit and the EndBit. All other bits in the
|
| 198 | destination MSR are preserved. The lower 32-bits of the MSR written is
|
| 199 | returned. The caller must either guarantee that Index and the data written
|
| 200 | is valid, or the caller must set up exception handlers to catch the exceptions.
|
| 201 | This function is only available on IA-32 and x64.
|
| 202 |
|
| 203 | If StartBit is greater than 31, then ASSERT().
|
| 204 | If EndBit is greater than 31, then ASSERT().
|
| 205 | If EndBit is less than StartBit, then ASSERT().
|
| 206 |
|
| 207 | @param Index The 32-bit MSR index to write.
|
| 208 | @param StartBit The ordinal of the least significant bit in the bit field.
|
| 209 | Range 0..31.
|
| 210 | @param EndBit The ordinal of the most significant bit in the bit field.
|
| 211 | Range 0..31.
|
| 212 | @param Value The new value of the bit field.
|
| 213 |
|
| 214 | @return The lower 32-bit of the value written to the MSR.
|
| 215 |
|
| 216 | **/
|
| 217 | UINT32
|
| 218 | EFIAPI
|
| 219 | AsmMsrBitFieldWrite32 (
|
| 220 | IN UINT32 Index,
|
| 221 | IN UINTN StartBit,
|
| 222 | IN UINTN EndBit,
|
| 223 | IN UINT32 Value
|
| 224 | )
|
| 225 | {
|
| 226 | ASSERT (EndBit < sizeof (Value) * 8);
|
| 227 | ASSERT (StartBit <= EndBit);
|
| 228 | return (UINT32)AsmMsrBitFieldWrite64 (Index, StartBit, EndBit, Value);
|
| 229 | }
|
| 230 |
|
| 231 | /**
|
| 232 | Reads a bit field in a 64-bit MSR, performs a bitwise OR, and writes the
|
| 233 | result back to the bit field in the 64-bit MSR.
|
| 234 |
|
| 235 | Reads the 64-bit MSR specified by Index, performs a bitwise OR
|
| 236 | between the read result and the value specified by OrData, and writes the
|
| 237 | result to the 64-bit MSR specified by Index. The lower 32-bits of the value
|
| 238 | written to the MSR are returned. Extra left bits in OrData are stripped. The
|
| 239 | caller must either guarantee that Index and the data written is valid, or
|
| 240 | the caller must set up exception handlers to catch the exceptions. This
|
| 241 | function is only available on IA-32 and x64.
|
| 242 |
|
| 243 | If StartBit is greater than 31, then ASSERT().
|
| 244 | If EndBit is greater than 31, then ASSERT().
|
| 245 | If EndBit is less than StartBit, then ASSERT().
|
| 246 |
|
| 247 | @param Index The 32-bit MSR index to write.
|
| 248 | @param StartBit The ordinal of the least significant bit in the bit field.
|
| 249 | Range 0..31.
|
| 250 | @param EndBit The ordinal of the most significant bit in the bit field.
|
| 251 | Range 0..31.
|
| 252 | @param OrData The value to OR with the read value from the MSR.
|
| 253 |
|
| 254 | @return The lower 32-bit of the value written to the MSR.
|
| 255 |
|
| 256 | **/
|
| 257 | UINT32
|
| 258 | EFIAPI
|
| 259 | AsmMsrBitFieldOr32 (
|
| 260 | IN UINT32 Index,
|
| 261 | IN UINTN StartBit,
|
| 262 | IN UINTN EndBit,
|
| 263 | IN UINT32 OrData
|
| 264 | )
|
| 265 | {
|
| 266 | ASSERT (EndBit < sizeof (OrData) * 8);
|
| 267 | ASSERT (StartBit <= EndBit);
|
| 268 | return (UINT32)AsmMsrBitFieldOr64 (Index, StartBit, EndBit, OrData);
|
| 269 | }
|
| 270 |
|
| 271 | /**
|
| 272 | Reads a bit field in a 64-bit MSR, performs a bitwise AND, and writes the
|
| 273 | result back to the bit field in the 64-bit MSR.
|
| 274 |
|
| 275 | Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
|
| 276 | read result and the value specified by AndData, and writes the result to the
|
| 277 | 64-bit MSR specified by Index. The lower 32-bits of the value written to the
|
| 278 | MSR are returned. Extra left bits in AndData are stripped. The caller must
|
| 279 | either guarantee that Index and the data written is valid, or the caller must
|
| 280 | set up exception handlers to catch the exceptions. This function is only
|
| 281 | available on IA-32 and x64.
|
| 282 |
|
| 283 | If StartBit is greater than 31, then ASSERT().
|
| 284 | If EndBit is greater than 31, then ASSERT().
|
| 285 | If EndBit is less than StartBit, then ASSERT().
|
| 286 |
|
| 287 | @param Index The 32-bit MSR index to write.
|
| 288 | @param StartBit The ordinal of the least significant bit in the bit field.
|
| 289 | Range 0..31.
|
| 290 | @param EndBit The ordinal of the most significant bit in the bit field.
|
| 291 | Range 0..31.
|
| 292 | @param AndData The value to AND with the read value from the MSR.
|
| 293 |
|
| 294 | @return The lower 32-bit of the value written to the MSR.
|
| 295 |
|
| 296 | **/
|
| 297 | UINT32
|
| 298 | EFIAPI
|
| 299 | AsmMsrBitFieldAnd32 (
|
| 300 | IN UINT32 Index,
|
| 301 | IN UINTN StartBit,
|
| 302 | IN UINTN EndBit,
|
| 303 | IN UINT32 AndData
|
| 304 | )
|
| 305 | {
|
| 306 | ASSERT (EndBit < sizeof (AndData) * 8);
|
| 307 | ASSERT (StartBit <= EndBit);
|
| 308 | return (UINT32)AsmMsrBitFieldAnd64 (Index, StartBit, EndBit, AndData);
|
| 309 | }
|
| 310 |
|
| 311 | /**
|
| 312 | Reads a bit field in a 64-bit MSR, performs a bitwise AND followed by a
|
| 313 | bitwise OR, and writes the result back to the bit field in the
|
| 314 | 64-bit MSR.
|
| 315 |
|
| 316 | Reads the 64-bit MSR specified by Index, performs a bitwise AND followed by a
|
| 317 | bitwise OR between the read result and the value specified by
|
| 318 | AndData, and writes the result to the 64-bit MSR specified by Index. The
|
| 319 | lower 32-bits of the value written to the MSR are returned. Extra left bits
|
| 320 | in both AndData and OrData are stripped. The caller must either guarantee
|
| 321 | that Index and the data written is valid, or the caller must set up exception
|
| 322 | handlers to catch the exceptions. This function is only available on IA-32
|
| 323 | and x64.
|
| 324 |
|
| 325 | If StartBit is greater than 31, then ASSERT().
|
| 326 | If EndBit is greater than 31, then ASSERT().
|
| 327 | If EndBit is less than StartBit, then ASSERT().
|
| 328 |
|
| 329 | @param Index The 32-bit MSR index to write.
|
| 330 | @param StartBit The ordinal of the least significant bit in the bit field.
|
| 331 | Range 0..31.
|
| 332 | @param EndBit The ordinal of the most significant bit in the bit field.
|
| 333 | Range 0..31.
|
| 334 | @param AndData The value to AND with the read value from the MSR.
|
| 335 | @param OrData The value to OR with the result of the AND operation.
|
| 336 |
|
| 337 | @return The lower 32-bit of the value written to the MSR.
|
| 338 |
|
| 339 | **/
|
| 340 | UINT32
|
| 341 | EFIAPI
|
| 342 | AsmMsrBitFieldAndThenOr32 (
|
| 343 | IN UINT32 Index,
|
| 344 | IN UINTN StartBit,
|
| 345 | IN UINTN EndBit,
|
| 346 | IN UINT32 AndData,
|
| 347 | IN UINT32 OrData
|
| 348 | )
|
| 349 | {
|
| 350 | ASSERT (EndBit < sizeof (AndData) * 8);
|
| 351 | ASSERT (StartBit <= EndBit);
|
| 352 | return (UINT32)AsmMsrBitFieldAndThenOr64 (
|
| 353 | Index,
|
| 354 | StartBit,
|
| 355 | EndBit,
|
| 356 | AndData,
|
| 357 | OrData
|
| 358 | );
|
| 359 | }
|
| 360 |
|
| 361 | /**
|
| 362 | Reads a 64-bit MSR, performs a bitwise OR, and writes the result
|
| 363 | back to the 64-bit MSR.
|
| 364 |
|
| 365 | Reads the 64-bit MSR specified by Index, performs a bitwise OR
|
| 366 | between the read result and the value specified by OrData, and writes the
|
| 367 | result to the 64-bit MSR specified by Index. The value written to the MSR is
|
| 368 | returned. No parameter checking is performed on Index or OrData, and some of
|
| 369 | these may cause CPU exceptions. The caller must either guarantee that Index
|
| 370 | and OrData are valid, or the caller must establish proper exception handlers.
|
| 371 | This function is only available on IA-32 and x64.
|
| 372 |
|
| 373 | @param Index The 32-bit MSR index to write.
|
| 374 | @param OrData The value to OR with the read value from the MSR.
|
| 375 |
|
| 376 | @return The value written back to the MSR.
|
| 377 |
|
| 378 | **/
|
| 379 | UINT64
|
| 380 | EFIAPI
|
| 381 | AsmMsrOr64 (
|
| 382 | IN UINT32 Index,
|
| 383 | IN UINT64 OrData
|
| 384 | )
|
| 385 | {
|
| 386 | return AsmWriteMsr64 (Index, AsmReadMsr64 (Index) | OrData);
|
| 387 | }
|
| 388 |
|
| 389 | /**
|
| 390 | Reads a 64-bit MSR, performs a bitwise AND, and writes the result back to the
|
| 391 | 64-bit MSR.
|
| 392 |
|
| 393 | Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
|
| 394 | read result and the value specified by OrData, and writes the result to the
|
| 395 | 64-bit MSR specified by Index. The value written to the MSR is returned. No
|
| 396 | parameter checking is performed on Index or OrData, and some of these may
|
| 397 | cause CPU exceptions. The caller must either guarantee that Index and OrData
|
| 398 | are valid, or the caller must establish proper exception handlers. This
|
| 399 | function is only available on IA-32 and x64.
|
| 400 |
|
| 401 | @param Index The 32-bit MSR index to write.
|
| 402 | @param AndData The value to AND with the read value from the MSR.
|
| 403 |
|
| 404 | @return The value written back to the MSR.
|
| 405 |
|
| 406 | **/
|
| 407 | UINT64
|
| 408 | EFIAPI
|
| 409 | AsmMsrAnd64 (
|
| 410 | IN UINT32 Index,
|
| 411 | IN UINT64 AndData
|
| 412 | )
|
| 413 | {
|
| 414 | return AsmWriteMsr64 (Index, AsmReadMsr64 (Index) & AndData);
|
| 415 | }
|
| 416 |
|
| 417 | /**
|
| 418 | Reads a 64-bit MSR, performs a bitwise AND followed by a bitwise
|
| 419 | OR, and writes the result back to the 64-bit MSR.
|
| 420 |
|
| 421 | Reads the 64-bit MSR specified by Index, performs a bitwise AND between read
|
| 422 | result and the value specified by AndData, performs a bitwise OR
|
| 423 | between the result of the AND operation and the value specified by OrData,
|
| 424 | and writes the result to the 64-bit MSR specified by Index. The value written
|
| 425 | to the MSR is returned. No parameter checking is performed on Index, AndData,
|
| 426 | or OrData, and some of these may cause CPU exceptions. The caller must either
|
| 427 | guarantee that Index, AndData, and OrData are valid, or the caller must
|
| 428 | establish proper exception handlers. This function is only available on IA-32
|
| 429 | and x64.
|
| 430 |
|
| 431 | @param Index The 32-bit MSR index to write.
|
| 432 | @param AndData The value to AND with the read value from the MSR.
|
| 433 | @param OrData The value to OR with the result of the AND operation.
|
| 434 |
|
| 435 | @return The value written back to the MSR.
|
| 436 |
|
| 437 | **/
|
| 438 | UINT64
|
| 439 | EFIAPI
|
| 440 | AsmMsrAndThenOr64 (
|
| 441 | IN UINT32 Index,
|
| 442 | IN UINT64 AndData,
|
| 443 | IN UINT64 OrData
|
| 444 | )
|
| 445 | {
|
| 446 | return AsmWriteMsr64 (Index, (AsmReadMsr64 (Index) & AndData) | OrData);
|
| 447 | }
|
| 448 |
|
| 449 | /**
|
| 450 | Reads a bit field of an MSR.
|
| 451 |
|
| 452 | Reads the bit field in the 64-bit MSR. The bit field is specified by the
|
| 453 | StartBit and the EndBit. The value of the bit field is returned. The caller
|
| 454 | must either guarantee that Index is valid, or the caller must set up
|
| 455 | exception handlers to catch the exceptions. This function is only available
|
| 456 | on IA-32 and x64.
|
| 457 |
|
| 458 | If StartBit is greater than 63, then ASSERT().
|
| 459 | If EndBit is greater than 63, then ASSERT().
|
| 460 | If EndBit is less than StartBit, then ASSERT().
|
| 461 |
|
| 462 | @param Index The 32-bit MSR index to read.
|
| 463 | @param StartBit The ordinal of the least significant bit in the bit field.
|
| 464 | Range 0..63.
|
| 465 | @param EndBit The ordinal of the most significant bit in the bit field.
|
| 466 | Range 0..63.
|
| 467 |
|
| 468 | @return The value read from the MSR.
|
| 469 |
|
| 470 | **/
|
| 471 | UINT64
|
| 472 | EFIAPI
|
| 473 | AsmMsrBitFieldRead64 (
|
| 474 | IN UINT32 Index,
|
| 475 | IN UINTN StartBit,
|
| 476 | IN UINTN EndBit
|
| 477 | )
|
| 478 | {
|
| 479 | return BitFieldRead64 (AsmReadMsr64 (Index), StartBit, EndBit);
|
| 480 | }
|
| 481 |
|
| 482 | /**
|
| 483 | Writes a bit field to an MSR.
|
| 484 |
|
| 485 | Writes Value to a bit field in a 64-bit MSR. The bit field is specified by
|
| 486 | the StartBit and the EndBit. All other bits in the destination MSR are
|
| 487 | preserved. The MSR written is returned. The caller must either guarantee
|
| 488 | that Index and the data written is valid, or the caller must set up exception
|
| 489 | handlers to catch the exceptions. This function is only available on IA-32 and x64.
|
| 490 |
|
| 491 | If StartBit is greater than 63, then ASSERT().
|
| 492 | If EndBit is greater than 63, then ASSERT().
|
| 493 | If EndBit is less than StartBit, then ASSERT().
|
| 494 |
|
| 495 | @param Index The 32-bit MSR index to write.
|
| 496 | @param StartBit The ordinal of the least significant bit in the bit field.
|
| 497 | Range 0..63.
|
| 498 | @param EndBit The ordinal of the most significant bit in the bit field.
|
| 499 | Range 0..63.
|
| 500 | @param Value The new value of the bit field.
|
| 501 |
|
| 502 | @return The value written back to the MSR.
|
| 503 |
|
| 504 | **/
|
| 505 | UINT64
|
| 506 | EFIAPI
|
| 507 | AsmMsrBitFieldWrite64 (
|
| 508 | IN UINT32 Index,
|
| 509 | IN UINTN StartBit,
|
| 510 | IN UINTN EndBit,
|
| 511 | IN UINT64 Value
|
| 512 | )
|
| 513 | {
|
| 514 | return AsmWriteMsr64 (
|
| 515 | Index,
|
| 516 | BitFieldWrite64 (AsmReadMsr64 (Index), StartBit, EndBit, Value)
|
| 517 | );
|
| 518 | }
|
| 519 |
|
| 520 | /**
|
| 521 | Reads a bit field in a 64-bit MSR, performs a bitwise OR, and
|
| 522 | writes the result back to the bit field in the 64-bit MSR.
|
| 523 |
|
| 524 | Reads the 64-bit MSR specified by Index, performs a bitwise OR
|
| 525 | between the read result and the value specified by OrData, and writes the
|
| 526 | result to the 64-bit MSR specified by Index. The value written to the MSR is
|
| 527 | returned. Extra left bits in OrData are stripped. The caller must either
|
| 528 | guarantee that Index and the data written is valid, or the caller must set up
|
| 529 | exception handlers to catch the exceptions. This function is only available
|
| 530 | on IA-32 and x64.
|
| 531 |
|
| 532 | If StartBit is greater than 63, then ASSERT().
|
| 533 | If EndBit is greater than 63, then ASSERT().
|
| 534 | If EndBit is less than StartBit, then ASSERT().
|
| 535 |
|
| 536 | @param Index The 32-bit MSR index to write.
|
| 537 | @param StartBit The ordinal of the least significant bit in the bit field.
|
| 538 | Range 0..63.
|
| 539 | @param EndBit The ordinal of the most significant bit in the bit field.
|
| 540 | Range 0..63.
|
| 541 | @param OrData The value to OR with the read value from the bit field.
|
| 542 |
|
| 543 | @return The value written back to the MSR.
|
| 544 |
|
| 545 | **/
|
| 546 | UINT64
|
| 547 | EFIAPI
|
| 548 | AsmMsrBitFieldOr64 (
|
| 549 | IN UINT32 Index,
|
| 550 | IN UINTN StartBit,
|
| 551 | IN UINTN EndBit,
|
| 552 | IN UINT64 OrData
|
| 553 | )
|
| 554 | {
|
| 555 | return AsmWriteMsr64 (
|
| 556 | Index,
|
| 557 | BitFieldOr64 (AsmReadMsr64 (Index), StartBit, EndBit, OrData)
|
| 558 | );
|
| 559 | }
|
| 560 |
|
| 561 | /**
|
| 562 | Reads a bit field in a 64-bit MSR, performs a bitwise AND, and writes the
|
| 563 | result back to the bit field in the 64-bit MSR.
|
| 564 |
|
| 565 | Reads the 64-bit MSR specified by Index, performs a bitwise AND between the
|
| 566 | read result and the value specified by AndData, and writes the result to the
|
| 567 | 64-bit MSR specified by Index. The value written to the MSR is returned.
|
| 568 | Extra left bits in AndData are stripped. The caller must either guarantee
|
| 569 | that Index and the data written is valid, or the caller must set up exception
|
| 570 | handlers to catch the exceptions. This function is only available on IA-32
|
| 571 | and x64.
|
| 572 |
|
| 573 | If StartBit is greater than 63, then ASSERT().
|
| 574 | If EndBit is greater than 63, then ASSERT().
|
| 575 | If EndBit is less than StartBit, then ASSERT().
|
| 576 |
|
| 577 | @param Index The 32-bit MSR index to write.
|
| 578 | @param StartBit The ordinal of the least significant bit in the bit field.
|
| 579 | Range 0..63.
|
| 580 | @param EndBit The ordinal of the most significant bit in the bit field.
|
| 581 | Range 0..63.
|
| 582 | @param AndData The value to AND with the read value from the bit field.
|
| 583 |
|
| 584 | @return The value written back to the MSR.
|
| 585 |
|
| 586 | **/
|
| 587 | UINT64
|
| 588 | EFIAPI
|
| 589 | AsmMsrBitFieldAnd64 (
|
| 590 | IN UINT32 Index,
|
| 591 | IN UINTN StartBit,
|
| 592 | IN UINTN EndBit,
|
| 593 | IN UINT64 AndData
|
| 594 | )
|
| 595 | {
|
| 596 | return AsmWriteMsr64 (
|
| 597 | Index,
|
| 598 | BitFieldAnd64 (AsmReadMsr64 (Index), StartBit, EndBit, AndData)
|
| 599 | );
|
| 600 | }
|
| 601 |
|
| 602 | /**
|
| 603 | Reads a bit field in a 64-bit MSR, performs a bitwise AND followed by a
|
| 604 | bitwise OR, and writes the result back to the bit field in the
|
| 605 | 64-bit MSR.
|
| 606 |
|
| 607 | Reads the 64-bit MSR specified by Index, performs a bitwise AND followed by
|
| 608 | a bitwise OR between the read result and the value specified by
|
| 609 | AndData, and writes the result to the 64-bit MSR specified by Index. The
|
| 610 | value written to the MSR is returned. Extra left bits in both AndData and
|
| 611 | OrData are stripped. The caller must either guarantee that Index and the data
|
| 612 | written is valid, or the caller must set up exception handlers to catch the
|
| 613 | exceptions. This function is only available on IA-32 and x64.
|
| 614 |
|
| 615 | If StartBit is greater than 63, then ASSERT().
|
| 616 | If EndBit is greater than 63, then ASSERT().
|
| 617 | If EndBit is less than StartBit, then ASSERT().
|
| 618 |
|
| 619 | @param Index The 32-bit MSR index to write.
|
| 620 | @param StartBit The ordinal of the least significant bit in the bit field.
|
| 621 | Range 0..63.
|
| 622 | @param EndBit The ordinal of the most significant bit in the bit field.
|
| 623 | Range 0..63.
|
| 624 | @param AndData The value to AND with the read value from the bit field.
|
| 625 | @param OrData The value to OR with the result of the AND operation.
|
| 626 |
|
| 627 | @return The value written back to the MSR.
|
| 628 |
|
| 629 | **/
|
| 630 | UINT64
|
| 631 | EFIAPI
|
| 632 | AsmMsrBitFieldAndThenOr64 (
|
| 633 | IN UINT32 Index,
|
| 634 | IN UINTN StartBit,
|
| 635 | IN UINTN EndBit,
|
| 636 | IN UINT64 AndData,
|
| 637 | IN UINT64 OrData
|
| 638 | )
|
| 639 | {
|
| 640 | return AsmWriteMsr64 (
|
| 641 | Index,
|
| 642 | BitFieldAndThenOr64 (
|
| 643 | AsmReadMsr64 (Index),
|
| 644 | StartBit,
|
| 645 | EndBit,
|
| 646 | AndData,
|
| 647 | OrData
|
| 648 | )
|
| 649 | );
|
| 650 | }
|