cmd/x86/mtrr.c

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