Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 1 | /* |
| 2 | * This file is part of msrtool. |
| 3 | * |
| 4 | * Copyright (c) 2008 Peter Stuge <peter@stuge.se> |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License version 2 as |
| 8 | * published by the Free Software Foundation. |
| 9 | * |
| 10 | * This program is distributed in the hope that it will be useful, |
| 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 13 | * GNU General Public License for more details. |
| 14 | * |
| 15 | * You should have received a copy of the GNU General Public License |
| 16 | * along with this program; if not, write to the Free Software |
Paul Menzel | a46a712 | 2013-02-23 18:37:27 +0100 | [diff] [blame^] | 17 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 18 | */ |
| 19 | |
| 20 | #include <stdio.h> |
| 21 | #include <string.h> |
| 22 | #include <stdlib.h> |
| 23 | |
| 24 | #include "msrtool.h" |
| 25 | |
| 26 | static void print_bitdef(FILE *f, const struct msrbits *mb, const char *tail) { |
| 27 | uint8_t endbit; |
Peter Stuge | cc9db9d | 2008-11-22 18:29:44 +0000 | [diff] [blame] | 28 | if (!reserved && 0 == strcmp(mb->name, "RSVD")) |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 29 | return; |
| 30 | if (1 == mb->size) |
| 31 | fprintf(f, "# %5d", mb->start); |
| 32 | else { |
| 33 | endbit = mb->start - mb->size + 1; |
| 34 | fprintf(f, "# %*d:%d", endbit < 10 ? 3 : 2, mb->start, endbit); |
| 35 | } |
Peter Stuge | cc9db9d | 2008-11-22 18:29:44 +0000 | [diff] [blame] | 36 | if (0 == strcmp(mb->name, "RSVD")) |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 37 | fprintf(f, " [%s]", mb->desc); |
| 38 | else |
| 39 | fprintf(f, " %s %s", mb->name, mb->desc); |
| 40 | fprintf(f, "%s", tail); |
| 41 | } |
| 42 | |
| 43 | static void print_bitval(FILE *f, const struct msrbits *mb, const struct msr val) { |
| 44 | uint8_t i; |
| 45 | struct msr tmp, mask = MSR1(1); |
| 46 | const struct msrbitvalues *mbv = mb->bitval; |
| 47 | while (mbv->text && !msr_eq(mbv->value, val)) |
| 48 | mbv++; |
| 49 | switch (mb->present) { |
| 50 | case PRESENT_BIN: |
| 51 | mask = msr_shl(mask, mb->size - 1); |
| 52 | for (i = 0; i < mb->size; i++) { |
| 53 | memcpy(&tmp, &val, sizeof(val)); |
| 54 | msr_and(&tmp, mask); |
| 55 | fprintf(f, "%d", (tmp.hi || tmp.lo) ? 1 : 0); |
| 56 | mask = msr_shr(mask, 1); |
| 57 | } |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 58 | break; |
| 59 | case PRESENT_DEC: |
| 60 | fprintf(f, "%d", val.lo); |
| 61 | break; |
| 62 | case PRESENT_OCT: |
| 63 | fprintf(f, "0%o", val.lo); |
| 64 | break; |
| 65 | case PRESENT_HEX: |
| 66 | hexprint(f, val, mb->size); |
| 67 | break; |
| 68 | case PRESENT_HEXDEC: |
| 69 | hexprint(f, val, mb->size); |
| 70 | fprintf(f, " %d", val.lo); |
| 71 | break; |
| 72 | } |
| 73 | if (mbv->text) |
| 74 | fprintf(f, ": %s", mbv->text); |
| 75 | fprintf(f, "\n"); |
| 76 | } |
| 77 | |
| 78 | void hexprint(FILE *f, const struct msr val, const uint8_t bits) { |
| 79 | if (bits <= 4) |
Peter Stuge | b1180b4 | 2010-05-17 07:40:20 +0000 | [diff] [blame] | 80 | fprintf(f, "0x%01x", val.lo & 0xf); |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 81 | else if (bits <= 8) |
Peter Stuge | 8796486 | 2010-05-17 07:29:47 +0000 | [diff] [blame] | 82 | fprintf(f, "0x%02x", val.lo & 0xff); |
Peter Stuge | b1180b4 | 2010-05-17 07:40:20 +0000 | [diff] [blame] | 83 | else if (bits <= 12) |
| 84 | fprintf(f, "0x%03x", val.lo & 0xfff); |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 85 | else if (bits <= 16) |
Peter Stuge | 8796486 | 2010-05-17 07:29:47 +0000 | [diff] [blame] | 86 | fprintf(f, "0x%04x", val.lo & 0xffff); |
Peter Stuge | b1180b4 | 2010-05-17 07:40:20 +0000 | [diff] [blame] | 87 | else if (bits <= 20) |
| 88 | fprintf(f, "0x%05x", val.lo & 0xfffff); |
| 89 | else if (bits <= 24) |
| 90 | fprintf(f, "0x%06x", val.lo & 0xffffff); |
| 91 | else if (bits <= 28) |
| 92 | fprintf(f, "0x%07x", val.lo & 0xfffffff); |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 93 | else if (bits <= 32) |
| 94 | fprintf(f, "0x%08x", val.lo); |
Peter Stuge | b1180b4 | 2010-05-17 07:40:20 +0000 | [diff] [blame] | 95 | else if (bits <= 36) |
| 96 | fprintf(f, "0x%01x%08x", val.hi & 0xf, val.lo); |
| 97 | else if (bits <= 40) |
| 98 | fprintf(f, "0x%02x%08x", val.hi & 0xff, val.lo); |
| 99 | else if (bits <= 44) |
| 100 | fprintf(f, "0x%03x%08x", val.hi & 0xfff, val.lo); |
| 101 | else if (bits <= 48) |
| 102 | fprintf(f, "0x%04x%08x", val.hi & 0xffff, val.lo); |
| 103 | else if (bits <= 52) |
| 104 | fprintf(f, "0x%05x%08x", val.hi & 0xfffff, val.lo); |
| 105 | else if (bits <= 56) |
| 106 | fprintf(f, "0x%06x%08x", val.hi & 0xffffff, val.lo); |
| 107 | else if (bits <= 60) |
| 108 | fprintf(f, "0x%07x%08x", val.hi & 0xfffffff, val.lo); |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 109 | else |
| 110 | fprintf(f, "0x%08x%08x", val.hi, val.lo); |
| 111 | } |
| 112 | |
| 113 | int msr_eq(const struct msr a, const struct msr b) { |
| 114 | return a.hi == b.hi && a.lo == b.lo; |
| 115 | } |
| 116 | |
| 117 | struct msr msr_shl(const struct msr a, const uint8_t bits) { |
| 118 | struct msr ret; |
| 119 | |
| 120 | ret.hi = bits < 32 ? a.hi << bits : 0; |
| 121 | ret.lo = bits < 32 ? a.lo << bits : 0; |
| 122 | |
| 123 | if (bits < 32) |
| 124 | ret.hi |= bits ? a.lo >> (32 - bits) : 0; |
| 125 | else |
| 126 | ret.hi |= a.lo << (bits - 32); |
| 127 | |
| 128 | return ret; |
| 129 | } |
| 130 | |
| 131 | struct msr msr_shr(const struct msr a, const uint8_t bits) { |
| 132 | struct msr ret; |
| 133 | |
| 134 | ret.hi = bits < 32 ? a.hi >> bits : 0; |
| 135 | ret.lo = bits < 32 ? a.lo >> bits : 0; |
| 136 | |
| 137 | if (bits < 32) |
| 138 | ret.lo |= bits ? a.hi << (32 - bits) : 0; |
| 139 | else |
| 140 | ret.lo |= a.hi >> (bits - 32); |
| 141 | |
| 142 | return ret; |
| 143 | } |
| 144 | |
| 145 | void msr_and(struct msr *a, const struct msr b) { |
| 146 | a->hi &= b.hi; |
| 147 | a->lo &= b.lo; |
| 148 | } |
| 149 | |
| 150 | const struct msrdef *findmsrdef(const uint32_t addr) { |
| 151 | uint8_t t; |
| 152 | const struct msrdef *m; |
| 153 | if (!targets) |
| 154 | return NULL; |
| 155 | for (t = 0; t < targets_found; t++) |
| 156 | for (m = targets[t]->msrs; !MSR_ISEOT(*m); m++) |
| 157 | if (addr == m->addr) |
| 158 | return m; |
| 159 | return NULL; |
| 160 | } |
| 161 | |
Marc Jones | 8f21076 | 2009-03-08 04:37:39 +0000 | [diff] [blame] | 162 | uint32_t msraddrbyname(const char *name) { |
Peter Stuge | 3108a12 | 2009-01-26 17:18:31 +0000 | [diff] [blame] | 163 | uint8_t t; |
| 164 | const uint32_t addr = strtoul(name, NULL, 16); |
| 165 | const struct msrdef *m; |
| 166 | if (!targets) |
Peter Stuge | 5f28c09 | 2009-03-23 17:43:12 +0000 | [diff] [blame] | 167 | return addr; |
Peter Stuge | 3108a12 | 2009-01-26 17:18:31 +0000 | [diff] [blame] | 168 | for (t = 0; t < targets_found; t++) |
| 169 | for (m = targets[t]->msrs; !MSR_ISEOT(*m); m++) { |
| 170 | if (addr == m->addr) |
| 171 | return m->addr; |
| 172 | if (!strcasecmp(name, m->symbol)) |
| 173 | return m->addr; |
| 174 | } |
Peter Stuge | 5f28c09 | 2009-03-23 17:43:12 +0000 | [diff] [blame] | 175 | return addr; |
Peter Stuge | 3108a12 | 2009-01-26 17:18:31 +0000 | [diff] [blame] | 176 | } |
| 177 | |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 178 | void dumpmsrdefs(const struct targetdef *t) { |
| 179 | const struct msrdef *m; |
| 180 | const struct msrbits *mb; |
Peter Stuge | cc9db9d | 2008-11-22 18:29:44 +0000 | [diff] [blame] | 181 | if (NULL == t) |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 182 | return; |
| 183 | printf("# %s MSRs:\n", t->name); |
| 184 | for (m = t->msrs; !MSR_ISEOT(*m); m++) { |
| 185 | if (t->msrs != m) |
| 186 | printf("\n"); |
| 187 | printf("# %s\n", m->symbol); |
| 188 | for (mb = m->bits; mb->size; mb++) |
| 189 | print_bitdef(stdout, mb, "\n"); |
| 190 | printf("0x%08x\n", m->addr); |
| 191 | } |
| 192 | } |
| 193 | |
| 194 | int dumpmsrdefsvals(FILE *f, const struct targetdef *t, const uint8_t cpu) { |
| 195 | struct msr val = MSR1(0); |
| 196 | const struct msrdef *m; |
| 197 | const struct msrbits *mb; |
Peter Stuge | cc9db9d | 2008-11-22 18:29:44 +0000 | [diff] [blame] | 198 | if (NULL == t) |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 199 | return 1; |
| 200 | fprintf(f, "# %s MSRs:\n", t->name); |
| 201 | for (m = t->msrs; !MSR_ISEOT(*m); m++) { |
| 202 | if (t->msrs != m) |
| 203 | fprintf(f, "\n"); |
| 204 | if (!sys->rdmsr(cpu, m->addr, &val)) |
| 205 | return 1; |
| 206 | fprintf(f, "# %s\n", m->symbol); |
| 207 | for (mb = m->bits; mb->size; mb++) |
| 208 | print_bitdef(f, mb, "\n"); |
| 209 | fprintf(f, "0x%08x 0x%08x%08x\n", m->addr, val.hi, val.lo); |
| 210 | } |
| 211 | return 0; |
| 212 | } |
| 213 | |
| 214 | /** |
| 215 | * Parse a hexadecimal string into an MSR value. |
Uwe Hermann | 708ccac | 2009-04-10 21:05:56 +0000 | [diff] [blame] | 216 | * |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 217 | * Leading 0x or 0X is optional, the string is always parsed as hexadecimal. |
Peter Stuge | 34f2907 | 2010-01-17 18:33:53 +0000 | [diff] [blame] | 218 | * Any non-hexadecimal character except ' ' can separate the high 32 bits and |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 219 | * the low 32 bits. If there is such a separator, high and low values do not |
| 220 | * need to be zero padded. If there is no separator, the last <=8 digits are |
| 221 | * the low 32 bits and any characters before them are the high 32 bits. |
| 222 | * When there is no separator and less than eight digits, the high 32 bits |
| 223 | * are set to 0. |
| 224 | * Parsing fails when there is a separator and it is followed by another |
| 225 | * non-hexadecimal character. |
| 226 | * |
| 227 | * @param str The string to parse. The string must be writable but will be |
| 228 | * restored before return. |
| 229 | * @param msr Pointer to the struct msr where the value will be stored. |
Paul Menzel | 85bb83a | 2010-01-17 21:59:27 +0000 | [diff] [blame] | 230 | * @param endptr If endptr is not NULL, *endptr will point to after the MSR. |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 231 | * @return 1 on success, 0 on parse failure. msr is unchanged on failure. |
| 232 | */ |
Peter Stuge | 34f2907 | 2010-01-17 18:33:53 +0000 | [diff] [blame] | 233 | uint8_t str2msr(char *str, struct msr *msr, char **endptr) { |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 234 | char c; |
| 235 | size_t len, lo; |
| 236 | if (0 == strncmp(str, "0x", 2) || 0 == strncmp(str, "0X", 2)) |
| 237 | str += 2; |
| 238 | len = strspn(str, HEXCHARS); |
Peter Stuge | 34f2907 | 2010-01-17 18:33:53 +0000 | [diff] [blame] | 239 | if (len <= 8 && (0 == str[len] || ' ' == str[len])) { |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 240 | msr->hi = 0; |
| 241 | lo = 0; |
| 242 | } else if (len <= 8) { |
| 243 | lo = len + strcspn(str + len, HEXCHARS); |
| 244 | if (0 == len && 0 == strspn(str + lo, HEXCHARS)) |
| 245 | return 0; |
| 246 | c = str[len]; |
| 247 | str[len] = 0; |
| 248 | msr->hi = strtoul(str, NULL, 16); |
| 249 | str[len] = c; |
| 250 | } else { |
| 251 | lo = len - 8; |
| 252 | c = str[lo]; |
| 253 | str[lo] = 0; |
| 254 | msr->hi = strtoul(str, NULL, 16); |
| 255 | str[lo] = c; |
| 256 | } |
Peter Stuge | 34f2907 | 2010-01-17 18:33:53 +0000 | [diff] [blame] | 257 | msr->lo = strtoul(str + lo, endptr, 16); |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 258 | return 1; |
| 259 | } |
| 260 | |
| 261 | void decodemsr(const uint8_t cpu, const uint32_t addr, const struct msr val) { |
| 262 | struct msr bitval, mask; |
| 263 | const struct msrdef *m = findmsrdef(addr); |
| 264 | const struct msrbits *mb; |
| 265 | |
Peter Stuge | cc9db9d | 2008-11-22 18:29:44 +0000 | [diff] [blame] | 266 | if (NULL != m) |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 267 | printf("# %s ", m->symbol); |
| 268 | printf("0x%08x = 0x%08x%08x\n", addr, val.hi, val.lo); |
Peter Stuge | cc9db9d | 2008-11-22 18:29:44 +0000 | [diff] [blame] | 269 | if (NULL == m) { |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 270 | fprintf(stderr, "Sorry - no definition exists for this MSR! Please add it and send a signed-off\n"); |
| 271 | fprintf(stderr, "patch to coreboot@coreboot.org. Thanks for your help!\n"); |
| 272 | return; |
| 273 | } |
| 274 | |
| 275 | for (mb = m->bits; mb->size; mb++) { |
| 276 | if (!reserved && 0 == strcmp(mb->name, "RSVD")) |
| 277 | continue; |
| 278 | print_bitdef(stdout, mb, " = "); |
| 279 | mask.hi = mask.lo = 0xffffffff; |
| 280 | mask = msr_shr(mask, 64 - mb->size); |
| 281 | bitval = msr_shr(val, mb->start - mb->size + 1); |
| 282 | msr_and(&bitval, mask); |
| 283 | print_bitval(stdout, mb, bitval); |
| 284 | } |
| 285 | } |
| 286 | |
| 287 | /** |
| 288 | * Compare two MSR values and print any differences with field definitions and |
| 289 | * both old and new values decoded. |
| 290 | * |
| 291 | * @param f Output stream. |
| 292 | * @param addr MSR address. |
| 293 | * @param a Left value. |
| 294 | * @param b Right value. |
| 295 | * @return 1 when a and b differ, 0 when they are equal or only reserved bits |
| 296 | * differ and processing of reserved bits was not requested (with -r). |
| 297 | */ |
| 298 | uint8_t diff_msr(FILE *f, const uint32_t addr, const struct msr a, const struct msr b) { |
| 299 | uint8_t ret = 0, first = 1; |
| 300 | struct msr aval, bval, mask; |
| 301 | const struct msrdef *m = findmsrdef(addr); |
| 302 | const struct msrbits *mb; |
| 303 | |
| 304 | if (a.hi == b.hi && a.lo == b.lo) |
| 305 | return 0; |
| 306 | |
Peter Stuge | cc9db9d | 2008-11-22 18:29:44 +0000 | [diff] [blame] | 307 | if (NULL == m) { |
Peter Stuge | dad1e30 | 2008-11-22 17:13:36 +0000 | [diff] [blame] | 308 | fprintf(stderr, "MSR 0x%08x has no definition! Please add it and send a Signed-off-by patch\n", addr); |
| 309 | fprintf(stderr, "to coreboot@coreboot.org. Thank you for your help!\n"); |
| 310 | return 1; |
| 311 | } |
| 312 | |
| 313 | for (mb = m->bits; mb->size; mb++) { |
| 314 | if (!reserved && 0 == strcmp(mb->name, "RSVD")) |
| 315 | continue; |
| 316 | mask.hi = mask.lo = 0xffffffff; |
| 317 | mask = msr_shr(mask, 64 - mb->size); |
| 318 | aval = msr_shr(a, mb->start - mb->size + 1); |
| 319 | bval = msr_shr(b, mb->start - mb->size + 1); |
| 320 | msr_and(&aval, mask); |
| 321 | msr_and(&bval, mask); |
| 322 | if (msr_eq(aval, bval)) |
| 323 | continue; |
| 324 | if (first) { |
| 325 | fprintf(f, "# %s\n", m->symbol); |
| 326 | fprintf(f, "-0x%08x 0x%08x%08x\n", addr, a.hi, a.lo); |
| 327 | fprintf(f, "+0x%08x 0x%08x%08x\n", addr, b.hi, b.lo); |
| 328 | first = 0; |
| 329 | ret = 1; |
| 330 | } |
| 331 | print_bitdef(f, mb, "\n-"); |
| 332 | print_bitval(f, mb, aval); |
| 333 | fprintf(f, "+"); |
| 334 | print_bitval(f, mb, bval); |
| 335 | } |
| 336 | return ret; |
| 337 | } |