mtrr.c 3.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * (C) Copyright 2014 Google, Inc
  4. */
  5. #include <common.h>
  6. #include <asm/msr.h>
  7. #include <asm/mtrr.h>
  8. static const char *const mtrr_type_name[MTRR_TYPE_COUNT] = {
  9. "Uncacheable",
  10. "Combine",
  11. "2",
  12. "3",
  13. "Through",
  14. "Protect",
  15. "Back",
  16. };
  17. static int do_mtrr_list(void)
  18. {
  19. int i;
  20. printf("Reg Valid Write-type %-16s %-16s %-16s\n", "Base ||",
  21. "Mask ||", "Size ||");
  22. for (i = 0; i < MTRR_COUNT; i++) {
  23. const char *type = "Invalid";
  24. uint64_t base, mask, size;
  25. bool valid;
  26. base = native_read_msr(MTRR_PHYS_BASE_MSR(i));
  27. mask = native_read_msr(MTRR_PHYS_MASK_MSR(i));
  28. size = ~mask & ((1ULL << CONFIG_CPU_ADDR_BITS) - 1);
  29. size |= (1 << 12) - 1;
  30. size += 1;
  31. valid = mask & MTRR_PHYS_MASK_VALID;
  32. type = mtrr_type_name[base & MTRR_BASE_TYPE_MASK];
  33. printf("%d %-5s %-12s %016llx %016llx %016llx\n", i,
  34. valid ? "Y" : "N", type, base & ~MTRR_BASE_TYPE_MASK,
  35. mask & ~MTRR_PHYS_MASK_VALID, size);
  36. }
  37. return 0;
  38. }
  39. static int do_mtrr_set(uint reg, int argc, char * const argv[])
  40. {
  41. const char *typename = argv[0];
  42. struct mtrr_state state;
  43. uint32_t start, size;
  44. uint64_t base, mask;
  45. int i, type = -1;
  46. bool valid;
  47. if (argc < 3)
  48. return CMD_RET_USAGE;
  49. for (i = 0; i < MTRR_TYPE_COUNT; i++) {
  50. if (*typename == *mtrr_type_name[i])
  51. type = i;
  52. }
  53. if (type == -1) {
  54. printf("Invalid type name %s\n", typename);
  55. return CMD_RET_USAGE;
  56. }
  57. start = simple_strtoul(argv[1], NULL, 16);
  58. size = simple_strtoul(argv[2], NULL, 16);
  59. base = start | type;
  60. valid = native_read_msr(MTRR_PHYS_MASK_MSR(reg)) & MTRR_PHYS_MASK_VALID;
  61. mask = ~((uint64_t)size - 1);
  62. mask &= (1ULL << CONFIG_CPU_ADDR_BITS) - 1;
  63. if (valid)
  64. mask |= MTRR_PHYS_MASK_VALID;
  65. printf("base=%llx, mask=%llx\n", base, mask);
  66. mtrr_open(&state, true);
  67. wrmsrl(MTRR_PHYS_BASE_MSR(reg), base);
  68. wrmsrl(MTRR_PHYS_MASK_MSR(reg), mask);
  69. mtrr_close(&state, true);
  70. return 0;
  71. }
  72. static int mtrr_set_valid(int reg, bool valid)
  73. {
  74. struct mtrr_state state;
  75. uint64_t mask;
  76. mtrr_open(&state, true);
  77. mask = native_read_msr(MTRR_PHYS_MASK_MSR(reg));
  78. if (valid)
  79. mask |= MTRR_PHYS_MASK_VALID;
  80. else
  81. mask &= ~MTRR_PHYS_MASK_VALID;
  82. wrmsrl(MTRR_PHYS_MASK_MSR(reg), mask);
  83. mtrr_close(&state, true);
  84. return 0;
  85. }
  86. static int do_mtrr(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  87. {
  88. const char *cmd;
  89. uint reg;
  90. cmd = argv[1];
  91. if (argc < 2 || *cmd == 'l')
  92. return do_mtrr_list();
  93. argc -= 2;
  94. argv += 2;
  95. if (argc <= 0)
  96. return CMD_RET_USAGE;
  97. reg = simple_strtoul(argv[0], NULL, 16);
  98. if (reg >= MTRR_COUNT) {
  99. printf("Invalid register number\n");
  100. return CMD_RET_USAGE;
  101. }
  102. if (*cmd == 'e')
  103. return mtrr_set_valid(reg, true);
  104. else if (*cmd == 'd')
  105. return mtrr_set_valid(reg, false);
  106. else if (*cmd == 's')
  107. return do_mtrr_set(reg, argc - 1, argv + 1);
  108. else
  109. return CMD_RET_USAGE;
  110. return 0;
  111. }
  112. U_BOOT_CMD(
  113. mtrr, 6, 1, do_mtrr,
  114. "Use x86 memory type range registers (32-bit only)",
  115. "[list] - list current registers\n"
  116. "set <reg> <type> <start> <size> - set a register\n"
  117. "\t<type> is Uncacheable, Combine, Through, Protect, Back\n"
  118. "disable <reg> - disable a register\n"
  119. "ensable <reg> - enable a register"
  120. );