mtrr.c 4.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * (C) Copyright 2014 Google, Inc
  4. */
  5. #include <common.h>
  6. #include <command.h>
  7. #include <log.h>
  8. #include <asm/msr.h>
  9. #include <asm/mp.h>
  10. #include <asm/mtrr.h>
  11. static const char *const mtrr_type_name[MTRR_TYPE_COUNT] = {
  12. "Uncacheable",
  13. "Combine",
  14. "2",
  15. "3",
  16. "Through",
  17. "Protect",
  18. "Back",
  19. };
  20. static void read_mtrrs(void *arg)
  21. {
  22. struct mtrr_info *info = arg;
  23. mtrr_read_all(info);
  24. }
  25. static int do_mtrr_list(int reg_count, int cpu_select)
  26. {
  27. struct mtrr_info info;
  28. int ret;
  29. int i;
  30. printf("Reg Valid Write-type %-16s %-16s %-16s\n", "Base ||",
  31. "Mask ||", "Size ||");
  32. memset(&info, '\0', sizeof(info));
  33. ret = mp_run_on_cpus(cpu_select, read_mtrrs, &info);
  34. if (ret)
  35. return log_msg_ret("run", ret);
  36. for (i = 0; i < reg_count; i++) {
  37. const char *type = "Invalid";
  38. uint64_t base, mask, size;
  39. bool valid;
  40. base = info.mtrr[i].base;
  41. mask = info.mtrr[i].mask;
  42. size = ~mask & ((1ULL << CONFIG_CPU_ADDR_BITS) - 1);
  43. size |= (1 << 12) - 1;
  44. size += 1;
  45. valid = mask & MTRR_PHYS_MASK_VALID;
  46. type = mtrr_type_name[base & MTRR_BASE_TYPE_MASK];
  47. printf("%d %-5s %-12s %016llx %016llx %016llx\n", i,
  48. valid ? "Y" : "N", type, base & ~MTRR_BASE_TYPE_MASK,
  49. mask & ~MTRR_PHYS_MASK_VALID, size);
  50. }
  51. return 0;
  52. }
  53. static int do_mtrr_set(int cpu_select, uint reg, int argc, char *const argv[])
  54. {
  55. const char *typename = argv[0];
  56. uint32_t start, size;
  57. uint64_t base, mask;
  58. int i, type = -1;
  59. bool valid;
  60. int ret;
  61. if (argc < 3)
  62. return CMD_RET_USAGE;
  63. for (i = 0; i < MTRR_TYPE_COUNT; i++) {
  64. if (*typename == *mtrr_type_name[i])
  65. type = i;
  66. }
  67. if (type == -1) {
  68. printf("Invalid type name %s\n", typename);
  69. return CMD_RET_USAGE;
  70. }
  71. start = hextoul(argv[1], NULL);
  72. size = hextoul(argv[2], NULL);
  73. base = start | type;
  74. valid = native_read_msr(MTRR_PHYS_MASK_MSR(reg)) & MTRR_PHYS_MASK_VALID;
  75. mask = ~((uint64_t)size - 1);
  76. mask &= (1ULL << CONFIG_CPU_ADDR_BITS) - 1;
  77. if (valid)
  78. mask |= MTRR_PHYS_MASK_VALID;
  79. ret = mtrr_set(cpu_select, reg, base, mask);
  80. if (ret)
  81. return CMD_RET_FAILURE;
  82. return 0;
  83. }
  84. static int do_mtrr(struct cmd_tbl *cmdtp, int flag, int argc,
  85. char *const argv[])
  86. {
  87. int reg_count = mtrr_get_var_count();
  88. int cmd;
  89. int cpu_select;
  90. uint reg;
  91. int ret;
  92. cpu_select = MP_SELECT_BSP;
  93. if (argc >= 3 && !strcmp("-c", argv[1])) {
  94. const char *cpustr;
  95. cpustr = argv[2];
  96. if (*cpustr == 'a')
  97. cpu_select = MP_SELECT_ALL;
  98. else
  99. cpu_select = simple_strtol(cpustr, NULL, 16);
  100. argc -= 2;
  101. argv += 2;
  102. }
  103. argc--;
  104. argv++;
  105. cmd = argv[0] ? *argv[0] : 0;
  106. if (argc < 1 || !cmd) {
  107. cmd = 'l';
  108. reg = 0;
  109. }
  110. if (cmd != 'l') {
  111. if (argc < 2)
  112. return CMD_RET_USAGE;
  113. reg = hextoul(argv[1], NULL);
  114. if (reg >= reg_count) {
  115. printf("Invalid register number\n");
  116. return CMD_RET_USAGE;
  117. }
  118. }
  119. if (cmd == 'l') {
  120. bool first;
  121. int i;
  122. i = mp_first_cpu(cpu_select);
  123. if (i < 0) {
  124. printf("Invalid CPU (err=%d)\n", i);
  125. return CMD_RET_FAILURE;
  126. }
  127. first = true;
  128. for (; i >= 0; i = mp_next_cpu(cpu_select, i)) {
  129. if (!first)
  130. printf("\n");
  131. printf("CPU %d:\n", i);
  132. ret = do_mtrr_list(reg_count, i);
  133. if (ret) {
  134. printf("Failed to read CPU %d (err=%d)\n", i,
  135. ret);
  136. return CMD_RET_FAILURE;
  137. }
  138. first = false;
  139. }
  140. } else {
  141. switch (cmd) {
  142. case 'e':
  143. ret = mtrr_set_valid(cpu_select, reg, true);
  144. break;
  145. case 'd':
  146. ret = mtrr_set_valid(cpu_select, reg, false);
  147. break;
  148. case 's':
  149. ret = do_mtrr_set(cpu_select, reg, argc - 2, argv + 2);
  150. break;
  151. default:
  152. return CMD_RET_USAGE;
  153. }
  154. if (ret) {
  155. printf("Operation failed (err=%d)\n", ret);
  156. return CMD_RET_FAILURE;
  157. }
  158. }
  159. return 0;
  160. }
  161. U_BOOT_CMD(
  162. mtrr, 8, 1, do_mtrr,
  163. "Use x86 memory type range registers (32-bit only)",
  164. "[list] - list current registers\n"
  165. "set <reg> <type> <start> <size> - set a register\n"
  166. "\t<type> is Uncacheable, Combine, Through, Protect, Back\n"
  167. "disable <reg> - disable a register\n"
  168. "enable <reg> - enable a register\n"
  169. "\n"
  170. "Precede command with '-c <n>|all' to access a particular hex CPU, e.g.\n"
  171. " mtrr -c all list; mtrr -c 2e list"
  172. );