Peter Stuge | 33fefca | 2009-01-26 01:33:02 +0000 | [diff] [blame] | 1 | /* |
| 2 | * This file is part of the flashrom project. |
| 3 | * |
| 4 | * Copyright (C) 2009 Peter Stuge <peter@stuge.se> |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 5 | * Copyright (C) 2009 coresystems GmbH |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 6 | * Copyright (C) 2010 Carl-Daniel Hailfinger |
Rudolf Marek | 03ae5c1 | 2010-03-16 23:59:19 +0000 | [diff] [blame] | 7 | * Copyright (C) 2010 Rudolf Marek <r.marek@assembler.cz> |
Peter Stuge | 33fefca | 2009-01-26 01:33:02 +0000 | [diff] [blame] | 8 | * |
| 9 | * This program is free software; you can redistribute it and/or modify |
| 10 | * it under the terms of the GNU General Public License as published by |
| 11 | * the Free Software Foundation; version 2 of the License. |
| 12 | * |
| 13 | * This program is distributed in the hope that it will be useful, |
| 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 16 | * GNU General Public License for more details. |
| 17 | * |
| 18 | * You should have received a copy of the GNU General Public License |
| 19 | * along with this program; if not, write to the Free Software |
| 20 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 21 | */ |
Uwe Hermann | 7b2969b | 2009-04-15 10:52:49 +0000 | [diff] [blame] | 22 | |
Carl-Daniel Hailfinger | 831e8f4 | 2010-05-30 22:24:40 +0000 | [diff] [blame] | 23 | #include <unistd.h> |
Stefan Tauner | 7fb5aa0 | 2013-08-14 15:48:44 +0000 | [diff] [blame^] | 24 | #include <stdbool.h> |
Carl-Daniel Hailfinger | 831e8f4 | 2010-05-30 22:24:40 +0000 | [diff] [blame] | 25 | #include <stdio.h> |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 26 | #include <stdlib.h> |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 27 | #include <string.h> |
Carl-Daniel Hailfinger | 11990da | 2013-07-13 23:21:05 +0000 | [diff] [blame] | 28 | #include <errno.h> |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 29 | #include "flash.h" |
Patrick Georgi | 32508eb | 2012-07-20 20:35:14 +0000 | [diff] [blame] | 30 | #include "hwaccess.h" |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 31 | |
Patrick Georgi | a9095a9 | 2010-09-30 17:03:32 +0000 | [diff] [blame] | 32 | #if !defined(__DJGPP__) && !defined(__LIBPAYLOAD__) |
Carl-Daniel Hailfinger | 11990da | 2013-07-13 23:21:05 +0000 | [diff] [blame] | 33 | /* No file access needed/possible to get mmap access permissions or access MSR. */ |
Carl-Daniel Hailfinger | dcef67e | 2010-06-21 23:20:15 +0000 | [diff] [blame] | 34 | #include <sys/stat.h> |
| 35 | #include <fcntl.h> |
Carl-Daniel Hailfinger | dcef67e | 2010-06-21 23:20:15 +0000 | [diff] [blame] | 36 | #endif |
| 37 | |
Rudolf Marek | 03ae5c1 | 2010-03-16 23:59:19 +0000 | [diff] [blame] | 38 | #ifdef __DJGPP__ |
| 39 | #include <dpmi.h> |
Rudolf Marek | 837d810 | 2010-04-25 22:47:50 +0000 | [diff] [blame] | 40 | #include <sys/nearptr.h> |
Rudolf Marek | 03ae5c1 | 2010-03-16 23:59:19 +0000 | [diff] [blame] | 41 | |
| 42 | #define MEM_DEV "dpmi" |
| 43 | |
Rudolf Marek | 837d810 | 2010-04-25 22:47:50 +0000 | [diff] [blame] | 44 | static void *realmem_map; |
| 45 | |
Stefan Tauner | 305e0b9 | 2013-07-17 23:46:44 +0000 | [diff] [blame] | 46 | static void *map_first_meg(uintptr_t phys_addr, size_t len) |
Rudolf Marek | 837d810 | 2010-04-25 22:47:50 +0000 | [diff] [blame] | 47 | { |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 48 | if (realmem_map) |
Rudolf Marek | 837d810 | 2010-04-25 22:47:50 +0000 | [diff] [blame] | 49 | return realmem_map + phys_addr; |
Rudolf Marek | 837d810 | 2010-04-25 22:47:50 +0000 | [diff] [blame] | 50 | |
| 51 | realmem_map = valloc(1024 * 1024); |
| 52 | |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 53 | if (!realmem_map) |
Patrick Georgi | ed7a964 | 2010-09-25 22:53:44 +0000 | [diff] [blame] | 54 | return ERROR_PTR; |
Rudolf Marek | 837d810 | 2010-04-25 22:47:50 +0000 | [diff] [blame] | 55 | |
| 56 | if (__djgpp_map_physical_memory(realmem_map, (1024 * 1024), 0)) { |
Carl-Daniel Hailfinger | 602de98 | 2010-10-05 23:21:51 +0000 | [diff] [blame] | 57 | free(realmem_map); |
| 58 | realmem_map = NULL; |
Patrick Georgi | ed7a964 | 2010-09-25 22:53:44 +0000 | [diff] [blame] | 59 | return ERROR_PTR; |
Rudolf Marek | 837d810 | 2010-04-25 22:47:50 +0000 | [diff] [blame] | 60 | } |
| 61 | |
| 62 | return realmem_map + phys_addr; |
| 63 | } |
Rudolf Marek | 03ae5c1 | 2010-03-16 23:59:19 +0000 | [diff] [blame] | 64 | |
Stefan Tauner | 305e0b9 | 2013-07-17 23:46:44 +0000 | [diff] [blame] | 65 | static void *sys_physmap(uintptr_t phys_addr, size_t len) |
Rudolf Marek | 03ae5c1 | 2010-03-16 23:59:19 +0000 | [diff] [blame] | 66 | { |
| 67 | int ret; |
| 68 | __dpmi_meminfo mi; |
| 69 | |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 70 | /* Enable 4GB limit on DS descriptor. */ |
| 71 | if (!__djgpp_nearptr_enable()) |
Patrick Georgi | ed7a964 | 2010-09-25 22:53:44 +0000 | [diff] [blame] | 72 | return ERROR_PTR; |
Rudolf Marek | 837d810 | 2010-04-25 22:47:50 +0000 | [diff] [blame] | 73 | |
| 74 | if ((phys_addr + len - 1) < (1024 * 1024)) { |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 75 | /* We need to use another method to map first 1MB. */ |
Rudolf Marek | 837d810 | 2010-04-25 22:47:50 +0000 | [diff] [blame] | 76 | return map_first_meg(phys_addr, len); |
Rudolf Marek | 03ae5c1 | 2010-03-16 23:59:19 +0000 | [diff] [blame] | 77 | } |
| 78 | |
| 79 | mi.address = phys_addr; |
| 80 | mi.size = len; |
Carl-Daniel Hailfinger | 082c8b5 | 2011-08-15 19:54:20 +0000 | [diff] [blame] | 81 | ret = __dpmi_physical_address_mapping(&mi); |
Rudolf Marek | 03ae5c1 | 2010-03-16 23:59:19 +0000 | [diff] [blame] | 82 | |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 83 | if (ret != 0) |
Patrick Georgi | ed7a964 | 2010-09-25 22:53:44 +0000 | [diff] [blame] | 84 | return ERROR_PTR; |
Rudolf Marek | 03ae5c1 | 2010-03-16 23:59:19 +0000 | [diff] [blame] | 85 | |
Rudolf Marek | 837d810 | 2010-04-25 22:47:50 +0000 | [diff] [blame] | 86 | return (void *) mi.address + __djgpp_conventional_base; |
Rudolf Marek | 03ae5c1 | 2010-03-16 23:59:19 +0000 | [diff] [blame] | 87 | } |
| 88 | |
| 89 | #define sys_physmap_rw_uncached sys_physmap |
Rudolf Marek | 837d810 | 2010-04-25 22:47:50 +0000 | [diff] [blame] | 90 | #define sys_physmap_ro_cached sys_physmap |
Rudolf Marek | 03ae5c1 | 2010-03-16 23:59:19 +0000 | [diff] [blame] | 91 | |
| 92 | void physunmap(void *virt_addr, size_t len) |
| 93 | { |
| 94 | __dpmi_meminfo mi; |
| 95 | |
Carl-Daniel Hailfinger | 602de98 | 2010-10-05 23:21:51 +0000 | [diff] [blame] | 96 | /* There is no known way to unmap the first 1 MB. The DPMI server will |
| 97 | * do this for us on exit. |
| 98 | */ |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 99 | if ((virt_addr >= realmem_map) && |
| 100 | ((virt_addr + len) <= (realmem_map + (1024 * 1024)))) { |
Rudolf Marek | 03ae5c1 | 2010-03-16 23:59:19 +0000 | [diff] [blame] | 101 | return; |
| 102 | } |
| 103 | |
| 104 | mi.address = (unsigned long) virt_addr; |
| 105 | __dpmi_free_physical_address_mapping(&mi); |
| 106 | } |
| 107 | |
Patrick Georgi | a9095a9 | 2010-09-30 17:03:32 +0000 | [diff] [blame] | 108 | #elif defined(__LIBPAYLOAD__) |
| 109 | #include <arch/virtual.h> |
| 110 | |
| 111 | #define MEM_DEV "" |
| 112 | |
Stefan Tauner | 305e0b9 | 2013-07-17 23:46:44 +0000 | [diff] [blame] | 113 | void *sys_physmap(uintptr_t phys_addr, size_t len) |
Patrick Georgi | a9095a9 | 2010-09-30 17:03:32 +0000 | [diff] [blame] | 114 | { |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 115 | return (void *)phys_to_virt(phys_addr); |
Patrick Georgi | a9095a9 | 2010-09-30 17:03:32 +0000 | [diff] [blame] | 116 | } |
| 117 | |
| 118 | #define sys_physmap_rw_uncached sys_physmap |
| 119 | #define sys_physmap_ro_cached sys_physmap |
| 120 | |
| 121 | void physunmap(void *virt_addr, size_t len) |
| 122 | { |
| 123 | } |
Carl-Daniel Hailfinger | 60d9bd2 | 2012-08-09 23:34:41 +0000 | [diff] [blame] | 124 | #elif defined(__MACH__) && defined(__APPLE__) |
Rudolf Marek | 03ae5c1 | 2010-03-16 23:59:19 +0000 | [diff] [blame] | 125 | |
Stefan Reinauer | 83704c5 | 2011-03-18 22:00:15 +0000 | [diff] [blame] | 126 | #define MEM_DEV "DirectHW" |
Stefan Reinauer | f79edb9 | 2009-01-26 01:23:31 +0000 | [diff] [blame] | 127 | |
Stefan Tauner | 305e0b9 | 2013-07-17 23:46:44 +0000 | [diff] [blame] | 128 | static void *sys_physmap(uintptr_t phys_addr, size_t len) |
Stefan Reinauer | f79edb9 | 2009-01-26 01:23:31 +0000 | [diff] [blame] | 129 | { |
Patrick Georgi | ed7a964 | 2010-09-25 22:53:44 +0000 | [diff] [blame] | 130 | /* The short form of ?: is a GNU extension. |
| 131 | * FIXME: map_physical returns NULL both for errors and for success |
| 132 | * if the region is mapped at virtual address zero. If in doubt, report |
| 133 | * an error until a better interface exists. |
| 134 | */ |
| 135 | return map_physical(phys_addr, len) ? : ERROR_PTR; |
Stefan Reinauer | f79edb9 | 2009-01-26 01:23:31 +0000 | [diff] [blame] | 136 | } |
| 137 | |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 138 | /* The OS X driver does not differentiate between mapping types. */ |
| 139 | #define sys_physmap_rw_uncached sys_physmap |
| 140 | #define sys_physmap_ro_cached sys_physmap |
| 141 | |
Stefan Reinauer | f79edb9 | 2009-01-26 01:23:31 +0000 | [diff] [blame] | 142 | void physunmap(void *virt_addr, size_t len) |
| 143 | { |
| 144 | unmap_physical(virt_addr, len); |
| 145 | } |
| 146 | |
| 147 | #else |
| 148 | #include <sys/mman.h> |
| 149 | |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 150 | #if defined (__sun) && (defined(__i386) || defined(__amd64)) |
| 151 | # define MEM_DEV "/dev/xsvc" |
| 152 | #else |
| 153 | # define MEM_DEV "/dev/mem" |
| 154 | #endif |
| 155 | |
| 156 | static int fd_mem = -1; |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 157 | static int fd_mem_cached = -1; |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 158 | |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 159 | /* For MMIO access. Must be uncached, doesn't make sense to restrict to ro. */ |
Stefan Tauner | 305e0b9 | 2013-07-17 23:46:44 +0000 | [diff] [blame] | 160 | static void *sys_physmap_rw_uncached(uintptr_t phys_addr, size_t len) |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 161 | { |
| 162 | void *virt_addr; |
| 163 | |
| 164 | if (-1 == fd_mem) { |
| 165 | /* Open the memory device UNCACHED. Important for MMIO. */ |
Uwe Hermann | 7b2969b | 2009-04-15 10:52:49 +0000 | [diff] [blame] | 166 | if (-1 == (fd_mem = open(MEM_DEV, O_RDWR | O_SYNC))) { |
Stefan Tauner | 363fd7e | 2013-04-07 13:08:30 +0000 | [diff] [blame] | 167 | msg_perr("Critical error: open(" MEM_DEV "): %s\n", strerror(errno)); |
Peter Stuge | 43438ba | 2009-01-26 02:04:19 +0000 | [diff] [blame] | 168 | exit(2); |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 169 | } |
| 170 | } |
| 171 | |
Peter Huewe | 73f8ec8 | 2011-01-24 19:15:51 +0000 | [diff] [blame] | 172 | virt_addr = mmap(NULL, len, PROT_WRITE | PROT_READ, MAP_SHARED, |
Uwe Hermann | 7b2969b | 2009-04-15 10:52:49 +0000 | [diff] [blame] | 173 | fd_mem, (off_t)phys_addr); |
Patrick Georgi | ed7a964 | 2010-09-25 22:53:44 +0000 | [diff] [blame] | 174 | return MAP_FAILED == virt_addr ? ERROR_PTR : virt_addr; |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 175 | } |
| 176 | |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 177 | /* For reading DMI/coreboot/whatever tables. We should never write, and we |
| 178 | * do not care about caching. |
| 179 | */ |
Stefan Tauner | 305e0b9 | 2013-07-17 23:46:44 +0000 | [diff] [blame] | 180 | static void *sys_physmap_ro_cached(uintptr_t phys_addr, size_t len) |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 181 | { |
| 182 | void *virt_addr; |
| 183 | |
| 184 | if (-1 == fd_mem_cached) { |
| 185 | /* Open the memory device CACHED. */ |
| 186 | if (-1 == (fd_mem_cached = open(MEM_DEV, O_RDWR))) { |
Stefan Tauner | 363fd7e | 2013-04-07 13:08:30 +0000 | [diff] [blame] | 187 | msg_perr("Critical error: open(" MEM_DEV "): %s\n", strerror(errno)); |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 188 | exit(2); |
| 189 | } |
| 190 | } |
| 191 | |
Peter Huewe | 73f8ec8 | 2011-01-24 19:15:51 +0000 | [diff] [blame] | 192 | virt_addr = mmap(NULL, len, PROT_READ, MAP_SHARED, |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 193 | fd_mem_cached, (off_t)phys_addr); |
Patrick Georgi | ed7a964 | 2010-09-25 22:53:44 +0000 | [diff] [blame] | 194 | return MAP_FAILED == virt_addr ? ERROR_PTR : virt_addr; |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 195 | } |
| 196 | |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 197 | void physunmap(void *virt_addr, size_t len) |
| 198 | { |
Carl-Daniel Hailfinger | 1455b2b | 2009-05-11 14:13:25 +0000 | [diff] [blame] | 199 | if (len == 0) { |
Sean Nelson | 316a29f | 2010-05-07 20:09:04 +0000 | [diff] [blame] | 200 | msg_pspew("Not unmapping zero size at %p\n", virt_addr); |
Carl-Daniel Hailfinger | 1455b2b | 2009-05-11 14:13:25 +0000 | [diff] [blame] | 201 | return; |
| 202 | } |
| 203 | |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 204 | munmap(virt_addr, len); |
| 205 | } |
Stefan Reinauer | f79edb9 | 2009-01-26 01:23:31 +0000 | [diff] [blame] | 206 | #endif |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 207 | |
Stefan Tauner | 7fb5aa0 | 2013-08-14 15:48:44 +0000 | [diff] [blame^] | 208 | #define PHYSMAP_NOFAIL 0 |
| 209 | #define PHYSMAP_MAYFAIL 1 |
| 210 | #define PHYSMAP_RW 0 |
| 211 | #define PHYSMAP_RO 1 |
| 212 | #define PHYSMAP_NOCLEANUP 0 |
| 213 | #define PHYSMAP_CLEANUP 1 |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 214 | |
Stefan Tauner | 7fb5aa0 | 2013-08-14 15:48:44 +0000 | [diff] [blame^] | 215 | struct undo_physmap_data { |
| 216 | void *virt_addr; |
| 217 | size_t len; |
| 218 | }; |
| 219 | |
| 220 | static int undo_physmap(void *data) |
| 221 | { |
| 222 | if (data == NULL) { |
| 223 | msg_perr("%s: tried to physunmap without valid data!\n", __func__); |
| 224 | return 1; |
| 225 | } |
| 226 | struct undo_physmap_data *d = data; |
| 227 | physunmap(d->virt_addr, d->len); |
| 228 | free(data); |
| 229 | return 0; |
| 230 | } |
| 231 | |
| 232 | static void *physmap_common(const char *descr, uintptr_t phys_addr, size_t len, bool mayfail, |
| 233 | bool readonly, bool autocleanup) |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 234 | { |
Stephan Guilloux | 6d08a3e | 2009-06-23 10:44:36 +0000 | [diff] [blame] | 235 | void *virt_addr; |
| 236 | |
Carl-Daniel Hailfinger | 1455b2b | 2009-05-11 14:13:25 +0000 | [diff] [blame] | 237 | if (len == 0) { |
Stefan Tauner | 305e0b9 | 2013-07-17 23:46:44 +0000 | [diff] [blame] | 238 | msg_pspew("Not mapping %s, zero size at 0x%0*" PRIxPTR ".\n", descr, PRIxPTR_WIDTH, phys_addr); |
Patrick Georgi | ed7a964 | 2010-09-25 22:53:44 +0000 | [diff] [blame] | 239 | return ERROR_PTR; |
Carl-Daniel Hailfinger | 1455b2b | 2009-05-11 14:13:25 +0000 | [diff] [blame] | 240 | } |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 241 | |
Carl-Daniel Hailfinger | 1455b2b | 2009-05-11 14:13:25 +0000 | [diff] [blame] | 242 | if ((getpagesize() - 1) & len) { |
Stefan Tauner | 0554ca5 | 2013-07-25 22:54:25 +0000 | [diff] [blame] | 243 | msg_perr("Mapping %s at 0x%0*" PRIxPTR ", unaligned size 0x%zx.\n", |
| 244 | descr, PRIxPTR_WIDTH, phys_addr, len); |
Carl-Daniel Hailfinger | 1455b2b | 2009-05-11 14:13:25 +0000 | [diff] [blame] | 245 | } |
| 246 | |
| 247 | if ((getpagesize() - 1) & phys_addr) { |
Stefan Tauner | 0554ca5 | 2013-07-25 22:54:25 +0000 | [diff] [blame] | 248 | msg_perr("Mapping %s, 0x%zx bytes at unaligned 0x%0*" PRIxPTR ".\n", |
| 249 | descr, len, PRIxPTR_WIDTH, phys_addr); |
Carl-Daniel Hailfinger | 1455b2b | 2009-05-11 14:13:25 +0000 | [diff] [blame] | 250 | } |
| 251 | |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 252 | if (readonly) |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 253 | virt_addr = sys_physmap_ro_cached(phys_addr, len); |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 254 | else |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 255 | virt_addr = sys_physmap_rw_uncached(phys_addr, len); |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 256 | |
Patrick Georgi | ed7a964 | 2010-09-25 22:53:44 +0000 | [diff] [blame] | 257 | if (ERROR_PTR == virt_addr) { |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 258 | if (NULL == descr) |
| 259 | descr = "memory"; |
Stefan Tauner | 0554ca5 | 2013-07-25 22:54:25 +0000 | [diff] [blame] | 260 | msg_perr("Error accessing %s, 0x%zx bytes at 0x%0*" PRIxPTR "\n", |
| 261 | descr, len, PRIxPTR_WIDTH, phys_addr); |
Stefan Tauner | 363fd7e | 2013-04-07 13:08:30 +0000 | [diff] [blame] | 262 | msg_perr(MEM_DEV " mmap failed: %s\n", strerror(errno)); |
Sean Nelson | 316a29f | 2010-05-07 20:09:04 +0000 | [diff] [blame] | 263 | #ifdef __linux__ |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 264 | if (EINVAL == errno) { |
Sean Nelson | 316a29f | 2010-05-07 20:09:04 +0000 | [diff] [blame] | 265 | msg_perr("In Linux this error can be caused by the CONFIG_NONPROMISC_DEVMEM (<2.6.27),\n"); |
| 266 | msg_perr("CONFIG_STRICT_DEVMEM (>=2.6.27) and CONFIG_X86_PAT kernel options.\n"); |
| 267 | msg_perr("Please check if either is enabled in your kernel before reporting a failure.\n"); |
| 268 | msg_perr("You can override CONFIG_X86_PAT at boot with the nopat kernel parameter but\n"); |
| 269 | msg_perr("disabling the other option unfortunately requires a kernel recompile. Sorry!\n"); |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 270 | } |
Carl-Daniel Hailfinger | b63b067 | 2010-07-02 17:12:50 +0000 | [diff] [blame] | 271 | #elif defined (__OpenBSD__) |
| 272 | msg_perr("Please set securelevel=-1 in /etc/rc.securelevel " |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 273 | "and reboot, or reboot into\n" |
| 274 | "single user mode.\n"); |
Sean Nelson | 316a29f | 2010-05-07 20:09:04 +0000 | [diff] [blame] | 275 | #endif |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 276 | if (!mayfail) |
| 277 | exit(3); |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 278 | } |
| 279 | |
Stefan Tauner | 7fb5aa0 | 2013-08-14 15:48:44 +0000 | [diff] [blame^] | 280 | if (autocleanup) { |
| 281 | struct undo_physmap_data *d = malloc(sizeof(struct undo_physmap_data)); |
| 282 | if (d == NULL) { |
| 283 | msg_perr("%s: Out of memory!\n", __func__); |
| 284 | goto unmap_out; |
| 285 | } |
| 286 | |
| 287 | d->virt_addr = virt_addr; |
| 288 | d->len = len; |
| 289 | if (register_shutdown(undo_physmap, d) != 0) { |
| 290 | msg_perr("%s: Could not register shutdown function!\n", __func__); |
| 291 | goto unmap_out; |
| 292 | } |
| 293 | } |
| 294 | |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 295 | return virt_addr; |
Stefan Tauner | 7fb5aa0 | 2013-08-14 15:48:44 +0000 | [diff] [blame^] | 296 | unmap_out: |
| 297 | physunmap(virt_addr, len); |
| 298 | if (!mayfail) |
| 299 | exit(3); |
| 300 | return ERROR_PTR; |
Stefan Reinauer | 0593f21 | 2009-01-26 01:10:48 +0000 | [diff] [blame] | 301 | } |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 302 | |
Stefan Tauner | 305e0b9 | 2013-07-17 23:46:44 +0000 | [diff] [blame] | 303 | void *physmap(const char *descr, uintptr_t phys_addr, size_t len) |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 304 | { |
Stefan Tauner | 7fb5aa0 | 2013-08-14 15:48:44 +0000 | [diff] [blame^] | 305 | return physmap_common(descr, phys_addr, len, PHYSMAP_NOFAIL, PHYSMAP_RW, PHYSMAP_NOCLEANUP); |
| 306 | } |
| 307 | |
| 308 | void *rphysmap(const char *descr, uintptr_t phys_addr, size_t len) |
| 309 | { |
| 310 | return physmap_common(descr, phys_addr, len, PHYSMAP_NOFAIL, PHYSMAP_RW, PHYSMAP_CLEANUP); |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 311 | } |
| 312 | |
Stefan Tauner | 305e0b9 | 2013-07-17 23:46:44 +0000 | [diff] [blame] | 313 | void *physmap_try_ro(const char *descr, uintptr_t phys_addr, size_t len) |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 314 | { |
Stefan Tauner | 7fb5aa0 | 2013-08-14 15:48:44 +0000 | [diff] [blame^] | 315 | return physmap_common(descr, phys_addr, len, PHYSMAP_MAYFAIL, PHYSMAP_RO, PHYSMAP_NOCLEANUP); |
Carl-Daniel Hailfinger | baaffe0 | 2010-02-02 11:09:03 +0000 | [diff] [blame] | 316 | } |
| 317 | |
Stefan Tauner | 6bf5fe7 | 2013-07-13 21:18:32 +0000 | [diff] [blame] | 318 | /* MSR abstraction implementations for Linux, OpenBSD, FreeBSD/Dragonfly, OSX, libpayload |
| 319 | * and a non-working default implemenation on the bottom. See also hwaccess.h for some (re)declarations. */ |
Carl-Daniel Hailfinger | cceafa2 | 2010-05-26 01:45:41 +0000 | [diff] [blame] | 320 | #if defined(__i386__) || defined(__x86_64__) |
| 321 | |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 322 | #ifdef __linux__ |
| 323 | /* |
| 324 | * Reading and writing to MSRs, however requires instructions rdmsr/wrmsr, |
| 325 | * which are ring0 privileged instructions so only the kernel can do the |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 326 | * read/write. This function, therefore, requires that the msr kernel module |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 327 | * be loaded to access these instructions from user space using device |
| 328 | * /dev/cpu/0/msr. |
| 329 | */ |
| 330 | |
| 331 | static int fd_msr = -1; |
| 332 | |
| 333 | msr_t rdmsr(int addr) |
| 334 | { |
Stefan Reinauer | 95e892b | 2009-09-04 13:57:07 +0000 | [diff] [blame] | 335 | uint32_t buf[2]; |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 336 | msr_t msr = { 0xffffffff, 0xffffffff }; |
| 337 | |
| 338 | if (lseek(fd_msr, (off_t) addr, SEEK_SET) == -1) { |
Stefan Tauner | 363fd7e | 2013-04-07 13:08:30 +0000 | [diff] [blame] | 339 | msg_perr("Could not lseek() MSR: %s\n", strerror(errno)); |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 340 | close(fd_msr); |
| 341 | exit(1); |
| 342 | } |
| 343 | |
| 344 | if (read(fd_msr, buf, 8) == 8) { |
Stefan Reinauer | 95e892b | 2009-09-04 13:57:07 +0000 | [diff] [blame] | 345 | msr.lo = buf[0]; |
| 346 | msr.hi = buf[1]; |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 347 | return msr; |
| 348 | } |
| 349 | |
| 350 | if (errno != EIO) { |
| 351 | // A severe error. |
Stefan Tauner | 363fd7e | 2013-04-07 13:08:30 +0000 | [diff] [blame] | 352 | msg_perr("Could not read() MSR: %s\n", strerror(errno)); |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 353 | close(fd_msr); |
| 354 | exit(1); |
| 355 | } |
| 356 | |
| 357 | return msr; |
| 358 | } |
| 359 | |
| 360 | int wrmsr(int addr, msr_t msr) |
| 361 | { |
Anti Sullin | be24d81 | 2010-05-17 23:19:22 +0000 | [diff] [blame] | 362 | uint32_t buf[2]; |
| 363 | buf[0] = msr.lo; |
| 364 | buf[1] = msr.hi; |
| 365 | |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 366 | if (lseek(fd_msr, (off_t) addr, SEEK_SET) == -1) { |
Stefan Tauner | 363fd7e | 2013-04-07 13:08:30 +0000 | [diff] [blame] | 367 | msg_perr("Could not lseek() MSR: %s\n", strerror(errno)); |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 368 | close(fd_msr); |
| 369 | exit(1); |
| 370 | } |
| 371 | |
Anti Sullin | be24d81 | 2010-05-17 23:19:22 +0000 | [diff] [blame] | 372 | if (write(fd_msr, buf, 8) != 8 && errno != EIO) { |
Stefan Tauner | 363fd7e | 2013-04-07 13:08:30 +0000 | [diff] [blame] | 373 | msg_perr("Could not write() MSR: %s\n", strerror(errno)); |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 374 | close(fd_msr); |
| 375 | exit(1); |
| 376 | } |
| 377 | |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 378 | /* Some MSRs must not be written. */ |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 379 | if (errno == EIO) |
| 380 | return -1; |
| 381 | |
| 382 | return 0; |
| 383 | } |
| 384 | |
| 385 | int setup_cpu_msr(int cpu) |
| 386 | { |
| 387 | char msrfilename[64]; |
Carl-Daniel Hailfinger | 831e8f4 | 2010-05-30 22:24:40 +0000 | [diff] [blame] | 388 | memset(msrfilename, 0, sizeof(msrfilename)); |
| 389 | snprintf(msrfilename, sizeof(msrfilename), "/dev/cpu/%d/msr", cpu); |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 390 | |
| 391 | if (fd_msr != -1) { |
Sean Nelson | 316a29f | 2010-05-07 20:09:04 +0000 | [diff] [blame] | 392 | msg_pinfo("MSR was already initialized\n"); |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 393 | return -1; |
| 394 | } |
| 395 | |
| 396 | fd_msr = open(msrfilename, O_RDWR); |
| 397 | |
| 398 | if (fd_msr < 0) { |
Stefan Tauner | 363fd7e | 2013-04-07 13:08:30 +0000 | [diff] [blame] | 399 | msg_perr("Error while opening %s: %s\n", msrfilename, strerror(errno)); |
Sean Nelson | 316a29f | 2010-05-07 20:09:04 +0000 | [diff] [blame] | 400 | msg_pinfo("Did you run 'modprobe msr'?\n"); |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 401 | return -1; |
| 402 | } |
| 403 | |
| 404 | return 0; |
| 405 | } |
| 406 | |
| 407 | void cleanup_cpu_msr(void) |
| 408 | { |
| 409 | if (fd_msr == -1) { |
Sean Nelson | 316a29f | 2010-05-07 20:09:04 +0000 | [diff] [blame] | 410 | msg_pinfo("No MSR initialized.\n"); |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 411 | return; |
| 412 | } |
| 413 | |
| 414 | close(fd_msr); |
| 415 | |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 416 | /* Clear MSR file descriptor. */ |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 417 | fd_msr = -1; |
| 418 | } |
Stefan Tauner | 6bf5fe7 | 2013-07-13 21:18:32 +0000 | [diff] [blame] | 419 | #elif defined(__OpenBSD__) /* This does only work for certain AMD Geode LX systems see amdmsr(4). */ |
| 420 | #include <sys/ioctl.h> |
| 421 | #include <machine/amdmsr.h> |
| 422 | |
| 423 | static int fd_msr = -1; |
| 424 | |
| 425 | msr_t rdmsr(int addr) |
| 426 | { |
| 427 | struct amdmsr_req args; |
| 428 | |
| 429 | msr_t msr = { 0xffffffff, 0xffffffff }; |
| 430 | |
| 431 | args.addr = (uint32_t)addr; |
| 432 | |
| 433 | if (ioctl(fd_msr, RDMSR, &args) < 0) { |
| 434 | msg_perr("Error while executing RDMSR ioctl: %s\n", strerror(errno)); |
| 435 | close(fd_msr); |
| 436 | exit(1); |
| 437 | } |
| 438 | |
| 439 | msr.lo = args.val & 0xffffffff; |
| 440 | msr.hi = args.val >> 32; |
| 441 | |
| 442 | return msr; |
| 443 | } |
| 444 | |
| 445 | int wrmsr(int addr, msr_t msr) |
| 446 | { |
| 447 | struct amdmsr_req args; |
| 448 | |
| 449 | args.addr = addr; |
| 450 | args.val = (((uint64_t)msr.hi) << 32) | msr.lo; |
| 451 | |
| 452 | if (ioctl(fd_msr, WRMSR, &args) < 0) { |
| 453 | msg_perr("Error while executing WRMSR ioctl: %s\n", strerror(errno)); |
| 454 | close(fd_msr); |
| 455 | exit(1); |
| 456 | } |
| 457 | |
| 458 | return 0; |
| 459 | } |
| 460 | |
| 461 | int setup_cpu_msr(int cpu) |
| 462 | { |
| 463 | char msrfilename[64]; |
| 464 | memset(msrfilename, 0, sizeof(msrfilename)); |
| 465 | snprintf(msrfilename, sizeof(msrfilename), "/dev/amdmsr"); |
| 466 | |
| 467 | if (fd_msr != -1) { |
| 468 | msg_pinfo("MSR was already initialized\n"); |
| 469 | return -1; |
| 470 | } |
| 471 | |
| 472 | fd_msr = open(msrfilename, O_RDWR); |
| 473 | |
| 474 | if (fd_msr < 0) { |
| 475 | msg_perr("Error while opening %s: %s\n", msrfilename, strerror(errno)); |
| 476 | return -1; |
| 477 | } |
| 478 | |
| 479 | return 0; |
| 480 | } |
| 481 | |
| 482 | void cleanup_cpu_msr(void) |
| 483 | { |
| 484 | if (fd_msr == -1) { |
| 485 | msg_pinfo("No MSR initialized.\n"); |
| 486 | return; |
| 487 | } |
| 488 | |
| 489 | close(fd_msr); |
| 490 | |
| 491 | /* Clear MSR file descriptor. */ |
| 492 | fd_msr = -1; |
| 493 | } |
| 494 | |
| 495 | #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) |
Stefan Reinauer | 173e3ea | 2009-08-19 10:46:23 +0000 | [diff] [blame] | 496 | #include <sys/ioctl.h> |
| 497 | |
| 498 | typedef struct { |
| 499 | int msr; |
| 500 | uint64_t data; |
| 501 | } cpu_msr_args_t; |
| 502 | #define CPU_RDMSR _IOWR('c', 1, cpu_msr_args_t) |
| 503 | #define CPU_WRMSR _IOWR('c', 2, cpu_msr_args_t) |
| 504 | |
| 505 | static int fd_msr = -1; |
| 506 | |
| 507 | msr_t rdmsr(int addr) |
| 508 | { |
| 509 | cpu_msr_args_t args; |
| 510 | |
| 511 | msr_t msr = { 0xffffffff, 0xffffffff }; |
| 512 | |
| 513 | args.msr = addr; |
| 514 | |
| 515 | if (ioctl(fd_msr, CPU_RDMSR, &args) < 0) { |
Stefan Tauner | 363fd7e | 2013-04-07 13:08:30 +0000 | [diff] [blame] | 516 | msg_perr("Error while executing CPU_RDMSR ioctl: %s\n", strerror(errno)); |
Stefan Reinauer | 173e3ea | 2009-08-19 10:46:23 +0000 | [diff] [blame] | 517 | close(fd_msr); |
| 518 | exit(1); |
| 519 | } |
| 520 | |
| 521 | msr.lo = args.data & 0xffffffff; |
| 522 | msr.hi = args.data >> 32; |
| 523 | |
| 524 | return msr; |
| 525 | } |
| 526 | |
| 527 | int wrmsr(int addr, msr_t msr) |
| 528 | { |
| 529 | cpu_msr_args_t args; |
| 530 | |
| 531 | args.msr = addr; |
| 532 | args.data = (((uint64_t)msr.hi) << 32) | msr.lo; |
| 533 | |
| 534 | if (ioctl(fd_msr, CPU_WRMSR, &args) < 0) { |
Stefan Tauner | 363fd7e | 2013-04-07 13:08:30 +0000 | [diff] [blame] | 535 | msg_perr("Error while executing CPU_WRMSR ioctl: %s\n", strerror(errno)); |
Stefan Reinauer | 173e3ea | 2009-08-19 10:46:23 +0000 | [diff] [blame] | 536 | close(fd_msr); |
| 537 | exit(1); |
| 538 | } |
| 539 | |
| 540 | return 0; |
| 541 | } |
| 542 | |
| 543 | int setup_cpu_msr(int cpu) |
| 544 | { |
| 545 | char msrfilename[64]; |
Carl-Daniel Hailfinger | 831e8f4 | 2010-05-30 22:24:40 +0000 | [diff] [blame] | 546 | memset(msrfilename, 0, sizeof(msrfilename)); |
| 547 | snprintf(msrfilename, sizeof(msrfilename), "/dev/cpu%d", cpu); |
Stefan Reinauer | 173e3ea | 2009-08-19 10:46:23 +0000 | [diff] [blame] | 548 | |
| 549 | if (fd_msr != -1) { |
Sean Nelson | 316a29f | 2010-05-07 20:09:04 +0000 | [diff] [blame] | 550 | msg_pinfo("MSR was already initialized\n"); |
Stefan Reinauer | 173e3ea | 2009-08-19 10:46:23 +0000 | [diff] [blame] | 551 | return -1; |
| 552 | } |
| 553 | |
| 554 | fd_msr = open(msrfilename, O_RDWR); |
| 555 | |
| 556 | if (fd_msr < 0) { |
Stefan Tauner | 363fd7e | 2013-04-07 13:08:30 +0000 | [diff] [blame] | 557 | msg_perr("Error while opening %s: %s\n", msrfilename, strerror(errno)); |
Sean Nelson | 316a29f | 2010-05-07 20:09:04 +0000 | [diff] [blame] | 558 | msg_pinfo("Did you install ports/sysutils/devcpu?\n"); |
Stefan Reinauer | 173e3ea | 2009-08-19 10:46:23 +0000 | [diff] [blame] | 559 | return -1; |
| 560 | } |
| 561 | |
| 562 | return 0; |
| 563 | } |
| 564 | |
| 565 | void cleanup_cpu_msr(void) |
| 566 | { |
| 567 | if (fd_msr == -1) { |
Sean Nelson | 316a29f | 2010-05-07 20:09:04 +0000 | [diff] [blame] | 568 | msg_pinfo("No MSR initialized.\n"); |
Stefan Reinauer | 173e3ea | 2009-08-19 10:46:23 +0000 | [diff] [blame] | 569 | return; |
| 570 | } |
| 571 | |
| 572 | close(fd_msr); |
| 573 | |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 574 | /* Clear MSR file descriptor. */ |
Stefan Reinauer | 173e3ea | 2009-08-19 10:46:23 +0000 | [diff] [blame] | 575 | fd_msr = -1; |
| 576 | } |
| 577 | |
Stefan Tauner | 6bf5fe7 | 2013-07-13 21:18:32 +0000 | [diff] [blame] | 578 | #elif defined(__MACH__) && defined(__APPLE__) |
| 579 | /* rdmsr() and wrmsr() are provided by DirectHW which needs neither setup nor cleanup. */ |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 580 | int setup_cpu_msr(int cpu) |
| 581 | { |
| 582 | // Always succeed for now |
| 583 | return 0; |
| 584 | } |
| 585 | |
| 586 | void cleanup_cpu_msr(void) |
| 587 | { |
| 588 | // Nothing, yet. |
| 589 | } |
Patrick Georgi | a9095a9 | 2010-09-30 17:03:32 +0000 | [diff] [blame] | 590 | #elif defined(__LIBPAYLOAD__) |
| 591 | msr_t libpayload_rdmsr(int addr) |
| 592 | { |
| 593 | msr_t msr; |
| 594 | unsigned long long val = _rdmsr(addr); |
| 595 | msr.lo = val & 0xffffffff; |
| 596 | msr.hi = val >> 32; |
| 597 | return msr; |
| 598 | } |
| 599 | |
| 600 | int libpayload_wrmsr(int addr, msr_t msr) |
| 601 | { |
| 602 | _wrmsr(addr, msr.lo | ((unsigned long long)msr.hi << 32)); |
Patrick Georgi | 97bc95c | 2011-03-08 07:17:44 +0000 | [diff] [blame] | 603 | return 0; |
Patrick Georgi | a9095a9 | 2010-09-30 17:03:32 +0000 | [diff] [blame] | 604 | } |
Carl-Daniel Hailfinger | 11990da | 2013-07-13 23:21:05 +0000 | [diff] [blame] | 605 | |
| 606 | int setup_cpu_msr(int cpu) |
| 607 | { |
| 608 | return 0; |
| 609 | } |
| 610 | |
| 611 | void cleanup_cpu_msr(void) |
| 612 | { |
| 613 | } |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 614 | #else |
Stefan Tauner | 6bf5fe7 | 2013-07-13 21:18:32 +0000 | [diff] [blame] | 615 | /* default MSR implementation */ |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 616 | msr_t rdmsr(int addr) |
| 617 | { |
| 618 | msr_t ret = { 0xffffffff, 0xffffffff }; |
| 619 | |
| 620 | return ret; |
| 621 | } |
| 622 | |
| 623 | int wrmsr(int addr, msr_t msr) |
| 624 | { |
| 625 | return -1; |
| 626 | } |
| 627 | |
| 628 | int setup_cpu_msr(int cpu) |
| 629 | { |
Sean Nelson | 316a29f | 2010-05-07 20:09:04 +0000 | [diff] [blame] | 630 | msg_pinfo("No MSR support for your OS yet.\n"); |
Stefan Reinauer | 8fa6481 | 2009-08-12 09:27:45 +0000 | [diff] [blame] | 631 | return -1; |
| 632 | } |
| 633 | |
| 634 | void cleanup_cpu_msr(void) |
| 635 | { |
| 636 | // Nothing, yet. |
| 637 | } |
Stefan Tauner | 6bf5fe7 | 2013-07-13 21:18:32 +0000 | [diff] [blame] | 638 | #endif // OS switches for MSR code |
| 639 | #else // x86 |
Carl-Daniel Hailfinger | cceafa2 | 2010-05-26 01:45:41 +0000 | [diff] [blame] | 640 | /* Does MSR exist on non-x86 architectures? */ |
Stefan Tauner | 6bf5fe7 | 2013-07-13 21:18:32 +0000 | [diff] [blame] | 641 | #endif // arch switches for MSR code |