1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (c) 2011 The Chromium OS Authors. 4 */ 5 6 #include <common.h> 7 #include <dm.h> 8 #include <errno.h> 9 #include <linux/libfdt.h> 10 #include <os.h> 11 #include <asm/io.h> 12 #include <asm/setjmp.h> 13 #include <asm/state.h> 14 #include <dm/root.h> 15 16 DECLARE_GLOBAL_DATA_PTR; 17 18 /* Enable access to PCI memory with map_sysmem() */ 19 static bool enable_pci_map; 20 21 #ifdef CONFIG_PCI 22 /* Last device that was mapped into memory, and length of mapping */ 23 static struct udevice *map_dev; 24 unsigned long map_len; 25 #endif 26 sandbox_exit(void)27 void sandbox_exit(void) 28 { 29 /* Do this here while it still has an effect */ 30 os_fd_restore(); 31 if (state_uninit()) 32 os_exit(2); 33 34 if (dm_uninit()) 35 os_exit(2); 36 37 /* This is considered normal termination for now */ 38 os_exit(0); 39 } 40 41 /* delay x useconds */ __udelay(unsigned long usec)42 void __udelay(unsigned long usec) 43 { 44 struct sandbox_state *state = state_get_current(); 45 46 if (!state->skip_delays) 47 os_usleep(usec); 48 } 49 cleanup_before_linux(void)50 int cleanup_before_linux(void) 51 { 52 return 0; 53 } 54 cleanup_before_linux_select(int flags)55 int cleanup_before_linux_select(int flags) 56 { 57 return 0; 58 } 59 60 /** 61 * is_in_sandbox_mem() - Checks if a pointer is within sandbox's emulated DRAM 62 * 63 * This provides a way to check if a pointer is owned by sandbox (and is within 64 * its RAM) or not. Sometimes pointers come from a test which conceptually runs 65 * output sandbox, potentially with direct access to the C-library malloc() 66 * function, or the sandbox stack (which is not actually within the emulated 67 * DRAM. 68 * 69 * Such pointers obviously cannot be mapped into sandbox's DRAM, so we must 70 * detect them an process them separately, by recording a mapping to a tag, 71 * which we can use to map back to the pointer later. 72 * 73 * @ptr: Pointer to check 74 * @return true if this is within sandbox emulated DRAM, false if not 75 */ is_in_sandbox_mem(const void * ptr)76 static bool is_in_sandbox_mem(const void *ptr) 77 { 78 return (const uint8_t *)ptr >= gd->arch.ram_buf && 79 (const uint8_t *)ptr < gd->arch.ram_buf + gd->ram_size; 80 } 81 82 /** 83 * phys_to_virt() - Converts a sandbox RAM address to a pointer 84 * 85 * Sandbox uses U-Boot addresses from 0 to the size of DRAM. These index into 86 * the emulated DRAM buffer used by sandbox. This function converts such an 87 * address to a pointer into this buffer, which can be used to access the 88 * memory. 89 * 90 * If the address is outside this range, it is assumed to be a tag 91 */ phys_to_virt(phys_addr_t paddr)92 void *phys_to_virt(phys_addr_t paddr) 93 { 94 struct sandbox_mapmem_entry *mentry; 95 struct sandbox_state *state; 96 97 /* If the address is within emulated DRAM, calculate the value */ 98 if (paddr < gd->ram_size) 99 return (void *)(gd->arch.ram_buf + paddr); 100 101 /* 102 * Otherwise search out list of tags for the correct pointer previously 103 * created by map_to_sysmem() 104 */ 105 state = state_get_current(); 106 list_for_each_entry(mentry, &state->mapmem_head, sibling_node) { 107 if (mentry->tag == paddr) { 108 debug("%s: Used map from %lx to %p\n", __func__, 109 (ulong)paddr, mentry->ptr); 110 return mentry->ptr; 111 } 112 } 113 114 printf("%s: Cannot map sandbox address %lx (SDRAM from 0 to %lx)\n", 115 __func__, (ulong)paddr, (ulong)gd->ram_size); 116 os_abort(); 117 118 /* Not reached */ 119 return NULL; 120 } 121 find_tag(const void * ptr)122 struct sandbox_mapmem_entry *find_tag(const void *ptr) 123 { 124 struct sandbox_mapmem_entry *mentry; 125 struct sandbox_state *state = state_get_current(); 126 127 list_for_each_entry(mentry, &state->mapmem_head, sibling_node) { 128 if (mentry->ptr == ptr) { 129 debug("%s: Used map from %p to %lx\n", __func__, ptr, 130 mentry->tag); 131 return mentry; 132 } 133 } 134 return NULL; 135 } 136 virt_to_phys(void * ptr)137 phys_addr_t virt_to_phys(void *ptr) 138 { 139 struct sandbox_mapmem_entry *mentry; 140 141 /* 142 * If it is in emulated RAM, don't bother looking for a tag. Just 143 * calculate the pointer using the provides offset into the RAM buffer. 144 */ 145 if (is_in_sandbox_mem(ptr)) 146 return (phys_addr_t)((uint8_t *)ptr - gd->arch.ram_buf); 147 148 mentry = find_tag(ptr); 149 if (!mentry) { 150 /* Abort so that gdb can be used here */ 151 printf("%s: Cannot map sandbox address %p (SDRAM from 0 to %lx)\n", 152 __func__, ptr, (ulong)gd->ram_size); 153 os_abort(); 154 } 155 debug("%s: Used map from %p to %lx\n", __func__, ptr, mentry->tag); 156 157 return mentry->tag; 158 } 159 map_physmem(phys_addr_t paddr,unsigned long len,unsigned long flags)160 void *map_physmem(phys_addr_t paddr, unsigned long len, unsigned long flags) 161 { 162 #if defined(CONFIG_PCI) && !defined(CONFIG_SPL_BUILD) 163 unsigned long plen = len; 164 void *ptr; 165 166 map_dev = NULL; 167 if (enable_pci_map && !pci_map_physmem(paddr, &len, &map_dev, &ptr)) { 168 if (plen != len) { 169 printf("%s: Warning: partial map at %x, wanted %lx, got %lx\n", 170 __func__, (uint)paddr, len, plen); 171 } 172 map_len = len; 173 return ptr; 174 } 175 #endif 176 177 return phys_to_virt(paddr); 178 } 179 unmap_physmem(const void * ptr,unsigned long flags)180 void unmap_physmem(const void *ptr, unsigned long flags) 181 { 182 #ifdef CONFIG_PCI 183 if (map_dev) { 184 pci_unmap_physmem(ptr, map_len, map_dev); 185 map_dev = NULL; 186 } 187 #endif 188 } 189 map_to_sysmem(const void * ptr)190 phys_addr_t map_to_sysmem(const void *ptr) 191 { 192 struct sandbox_mapmem_entry *mentry; 193 194 /* 195 * If it is in emulated RAM, don't bother creating a tag. Just return 196 * the offset into the RAM buffer. 197 */ 198 if (is_in_sandbox_mem(ptr)) 199 return (u8 *)ptr - gd->arch.ram_buf; 200 201 /* 202 * See if there is an existing tag with this pointer. If not, set up a 203 * new one. 204 */ 205 mentry = find_tag(ptr); 206 if (!mentry) { 207 struct sandbox_state *state = state_get_current(); 208 209 mentry = malloc(sizeof(*mentry)); 210 if (!mentry) { 211 printf("%s: Error: Out of memory\n", __func__); 212 os_exit(ENOMEM); 213 } 214 mentry->tag = state->next_tag++; 215 mentry->ptr = (void *)ptr; 216 list_add_tail(&mentry->sibling_node, &state->mapmem_head); 217 debug("%s: Added map from %p to %lx\n", __func__, ptr, 218 (ulong)mentry->tag); 219 } 220 221 /* 222 * Return the tag as the address to use. A later call to map_sysmem() 223 * will return ptr 224 */ 225 return mentry->tag; 226 } 227 sandbox_set_enable_pci_map(int enable)228 void sandbox_set_enable_pci_map(int enable) 229 { 230 enable_pci_map = enable; 231 } 232 flush_dcache_range(unsigned long start,unsigned long stop)233 void flush_dcache_range(unsigned long start, unsigned long stop) 234 { 235 } 236 invalidate_dcache_range(unsigned long start,unsigned long stop)237 void invalidate_dcache_range(unsigned long start, unsigned long stop) 238 { 239 } 240 sandbox_read_fdt_from_file(void)241 int sandbox_read_fdt_from_file(void) 242 { 243 struct sandbox_state *state = state_get_current(); 244 const char *fname = state->fdt_fname; 245 void *blob; 246 loff_t size; 247 int err; 248 int fd; 249 250 blob = map_sysmem(CONFIG_SYS_FDT_LOAD_ADDR, 0); 251 if (!state->fdt_fname) { 252 err = fdt_create_empty_tree(blob, 256); 253 if (!err) 254 goto done; 255 printf("Unable to create empty FDT: %s\n", fdt_strerror(err)); 256 return -EINVAL; 257 } 258 259 err = os_get_filesize(fname, &size); 260 if (err < 0) { 261 printf("Failed to file FDT file '%s'\n", fname); 262 return err; 263 } 264 fd = os_open(fname, OS_O_RDONLY); 265 if (fd < 0) { 266 printf("Failed to open FDT file '%s'\n", fname); 267 return -EACCES; 268 } 269 if (os_read(fd, blob, size) != size) { 270 os_close(fd); 271 return -EIO; 272 } 273 os_close(fd); 274 275 done: 276 gd->fdt_blob = blob; 277 278 return 0; 279 } 280 timer_get_boot_us(void)281 ulong timer_get_boot_us(void) 282 { 283 static uint64_t base_count; 284 uint64_t count = os_get_nsec(); 285 286 if (!base_count) 287 base_count = count; 288 289 return (count - base_count) / 1000; 290 } 291