blob: 636d3545b9540d478f07b043b85fd8c6516b10de [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glass3d750d72011-09-26 14:10:39 +00002/*
3 * Copyright (c) 2011 The Chromium OS Authors.
Simon Glass3d750d72011-09-26 14:10:39 +00004 */
Heinrich Schuchardtfa4bf412018-10-14 20:45:32 +02005
Simon Glass57b00a92022-09-06 20:27:10 -06006#define LOG_CATEGORY LOGC_SANDBOX
7
Simon Glass3d750d72011-09-26 14:10:39 +00008#include <common.h>
Simon Glass1ea97892020-05-10 11:40:00 -06009#include <bootstage.h>
Simon Glass63334482019-11-14 12:57:39 -070010#include <cpu_func.h>
Simon Glass141e5a02016-07-04 11:57:48 -060011#include <errno.h>
Simon Glass0f2af882020-05-10 11:40:05 -060012#include <log.h>
Simon Glasscd0684f2011-10-03 19:26:44 +000013#include <os.h>
Simon Glass57b00a92022-09-06 20:27:10 -060014#include <asm/global_data.h>
Simon Glass26b78b22015-02-27 22:06:34 -070015#include <asm/io.h>
Simon Glass9bc15642020-02-03 07:36:16 -070016#include <asm/malloc.h>
Simon Glass5dccd152018-05-16 09:42:22 -060017#include <asm/setjmp.h>
Simon Glass9dd10bf2013-11-10 10:27:03 -070018#include <asm/state.h>
Simon Glass57b00a92022-09-06 20:27:10 -060019#include <dm/ofnode.h>
20#include <linux/delay.h>
21#include <linux/libfdt.h>
Simon Glass3d750d72011-09-26 14:10:39 +000022
23DECLARE_GLOBAL_DATA_PTR;
24
Simon Glass70778bc2015-03-05 12:25:26 -070025/* Enable access to PCI memory with map_sysmem() */
26static bool enable_pci_map;
27
28#ifdef CONFIG_PCI
29/* Last device that was mapped into memory, and length of mapping */
30static struct udevice *map_dev;
31unsigned long map_len;
32#endif
33
Simon Glassd860f222015-07-06 12:54:29 -060034void sandbox_exit(void)
Simon Glass3d750d72011-09-26 14:10:39 +000035{
Simon Glass9c3b7d62015-05-10 21:07:27 -060036 /* Do this here while it still has an effect */
37 os_fd_restore();
Simon Glass9dd10bf2013-11-10 10:27:03 -070038
Simon Glass1b0851f2021-03-15 18:11:24 +130039 if (state_uninit())
Simon Glass19200512014-07-23 06:55:02 -060040 os_exit(2);
41
Simon Glasscd0684f2011-10-03 19:26:44 +000042 /* This is considered normal termination for now */
43 os_exit(0);
Simon Glassdc9f8cd2013-11-10 10:27:00 -070044}
45
Simon Glass3d750d72011-09-26 14:10:39 +000046/* delay x useconds */
47void __udelay(unsigned long usec)
48{
Simon Glassb25fa312015-11-08 23:47:43 -070049 struct sandbox_state *state = state_get_current();
50
51 if (!state->skip_delays)
52 os_usleep(usec);
Simon Glass3d750d72011-09-26 14:10:39 +000053}
54
Simon Glass3d750d72011-09-26 14:10:39 +000055int cleanup_before_linux(void)
56{
57 return 0;
58}
59
Simon Glass770d93f2015-05-13 07:02:26 -060060int cleanup_before_linux_select(int flags)
61{
62 return 0;
63}
64
Simon Glassfc1ebd32018-09-15 00:50:56 -060065/**
66 * is_in_sandbox_mem() - Checks if a pointer is within sandbox's emulated DRAM
67 *
68 * This provides a way to check if a pointer is owned by sandbox (and is within
69 * its RAM) or not. Sometimes pointers come from a test which conceptually runs
70 * output sandbox, potentially with direct access to the C-library malloc()
71 * function, or the sandbox stack (which is not actually within the emulated
72 * DRAM.
73 *
74 * Such pointers obviously cannot be mapped into sandbox's DRAM, so we must
75 * detect them an process them separately, by recording a mapping to a tag,
76 * which we can use to map back to the pointer later.
77 *
78 * @ptr: Pointer to check
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +010079 * Return: true if this is within sandbox emulated DRAM, false if not
Simon Glassfc1ebd32018-09-15 00:50:56 -060080 */
81static bool is_in_sandbox_mem(const void *ptr)
82{
83 return (const uint8_t *)ptr >= gd->arch.ram_buf &&
84 (const uint8_t *)ptr < gd->arch.ram_buf + gd->ram_size;
85}
86
87/**
88 * phys_to_virt() - Converts a sandbox RAM address to a pointer
89 *
90 * Sandbox uses U-Boot addresses from 0 to the size of DRAM. These index into
91 * the emulated DRAM buffer used by sandbox. This function converts such an
92 * address to a pointer into this buffer, which can be used to access the
93 * memory.
94 *
95 * If the address is outside this range, it is assumed to be a tag
96 */
Paul Burton51369252017-09-14 15:05:13 -070097void *phys_to_virt(phys_addr_t paddr)
98{
Simon Glassfc1ebd32018-09-15 00:50:56 -060099 struct sandbox_mapmem_entry *mentry;
100 struct sandbox_state *state;
101
102 /* If the address is within emulated DRAM, calculate the value */
103 if (paddr < gd->ram_size)
104 return (void *)(gd->arch.ram_buf + paddr);
105
106 /*
107 * Otherwise search out list of tags for the correct pointer previously
108 * created by map_to_sysmem()
109 */
110 state = state_get_current();
111 list_for_each_entry(mentry, &state->mapmem_head, sibling_node) {
112 if (mentry->tag == paddr) {
Heinrich Schuchardtfa4bf412018-10-14 20:45:32 +0200113 debug("%s: Used map from %lx to %p\n", __func__,
114 (ulong)paddr, mentry->ptr);
Simon Glassfc1ebd32018-09-15 00:50:56 -0600115 return mentry->ptr;
116 }
117 }
118
119 printf("%s: Cannot map sandbox address %lx (SDRAM from 0 to %lx)\n",
120 __func__, (ulong)paddr, (ulong)gd->ram_size);
121 os_abort();
122
123 /* Not reached */
124 return NULL;
Paul Burton51369252017-09-14 15:05:13 -0700125}
126
Simon Glassfc1ebd32018-09-15 00:50:56 -0600127struct sandbox_mapmem_entry *find_tag(const void *ptr)
Paul Burton51369252017-09-14 15:05:13 -0700128{
Simon Glassfc1ebd32018-09-15 00:50:56 -0600129 struct sandbox_mapmem_entry *mentry;
130 struct sandbox_state *state = state_get_current();
131
132 list_for_each_entry(mentry, &state->mapmem_head, sibling_node) {
133 if (mentry->ptr == ptr) {
134 debug("%s: Used map from %p to %lx\n", __func__, ptr,
135 mentry->tag);
136 return mentry;
137 }
138 }
139 return NULL;
Paul Burton51369252017-09-14 15:05:13 -0700140}
141
Simon Glassfc1ebd32018-09-15 00:50:56 -0600142phys_addr_t virt_to_phys(void *ptr)
143{
144 struct sandbox_mapmem_entry *mentry;
145
146 /*
147 * If it is in emulated RAM, don't bother looking for a tag. Just
148 * calculate the pointer using the provides offset into the RAM buffer.
149 */
150 if (is_in_sandbox_mem(ptr))
151 return (phys_addr_t)((uint8_t *)ptr - gd->arch.ram_buf);
152
153 mentry = find_tag(ptr);
154 if (!mentry) {
155 /* Abort so that gdb can be used here */
156 printf("%s: Cannot map sandbox address %p (SDRAM from 0 to %lx)\n",
157 __func__, ptr, (ulong)gd->ram_size);
158 os_abort();
159 }
Heinrich Schuchardtfa4bf412018-10-14 20:45:32 +0200160 debug("%s: Used map from %p to %lx\n", __func__, ptr, mentry->tag);
Simon Glassfc1ebd32018-09-15 00:50:56 -0600161
162 return mentry->tag;
163}
164
Simon Glass3d750d72011-09-26 14:10:39 +0000165void *map_physmem(phys_addr_t paddr, unsigned long len, unsigned long flags)
166{
Simon Glassf44a3a52016-07-04 11:57:49 -0600167#if defined(CONFIG_PCI) && !defined(CONFIG_SPL_BUILD)
Simon Glass70778bc2015-03-05 12:25:26 -0700168 unsigned long plen = len;
169 void *ptr;
170
171 map_dev = NULL;
172 if (enable_pci_map && !pci_map_physmem(paddr, &len, &map_dev, &ptr)) {
173 if (plen != len) {
174 printf("%s: Warning: partial map at %x, wanted %lx, got %lx\n",
Mario Six61efece2018-02-12 08:05:57 +0100175 __func__, (uint)paddr, len, plen);
Simon Glass70778bc2015-03-05 12:25:26 -0700176 }
177 map_len = len;
178 return ptr;
179 }
180#endif
181
Paul Burton51369252017-09-14 15:05:13 -0700182 return phys_to_virt(paddr);
Simon Glass3d750d72011-09-26 14:10:39 +0000183}
184
Simon Glassfc1ebd32018-09-15 00:50:56 -0600185void unmap_physmem(const void *ptr, unsigned long flags)
Simon Glass70778bc2015-03-05 12:25:26 -0700186{
187#ifdef CONFIG_PCI
188 if (map_dev) {
Simon Glassfc1ebd32018-09-15 00:50:56 -0600189 pci_unmap_physmem(ptr, map_len, map_dev);
Simon Glass70778bc2015-03-05 12:25:26 -0700190 map_dev = NULL;
191 }
192#endif
193}
194
Simon Glassfc1ebd32018-09-15 00:50:56 -0600195phys_addr_t map_to_sysmem(const void *ptr)
Simon Glass70778bc2015-03-05 12:25:26 -0700196{
Simon Glassfc1ebd32018-09-15 00:50:56 -0600197 struct sandbox_mapmem_entry *mentry;
198
199 /*
200 * If it is in emulated RAM, don't bother creating a tag. Just return
201 * the offset into the RAM buffer.
202 */
203 if (is_in_sandbox_mem(ptr))
204 return (u8 *)ptr - gd->arch.ram_buf;
205
206 /*
207 * See if there is an existing tag with this pointer. If not, set up a
208 * new one.
209 */
210 mentry = find_tag(ptr);
211 if (!mentry) {
212 struct sandbox_state *state = state_get_current();
213
214 mentry = malloc(sizeof(*mentry));
215 if (!mentry) {
216 printf("%s: Error: Out of memory\n", __func__);
217 os_exit(ENOMEM);
218 }
219 mentry->tag = state->next_tag++;
220 mentry->ptr = (void *)ptr;
221 list_add_tail(&mentry->sibling_node, &state->mapmem_head);
222 debug("%s: Added map from %p to %lx\n", __func__, ptr,
223 (ulong)mentry->tag);
224 }
225
226 /*
227 * Return the tag as the address to use. A later call to map_sysmem()
228 * will return ptr
229 */
230 return mentry->tag;
Simon Glass70778bc2015-03-05 12:25:26 -0700231}
232
Simon Glass0a341a72019-09-25 08:56:09 -0600233unsigned int sandbox_read(const void *addr, enum sandboxio_size_t size)
234{
235 struct sandbox_state *state = state_get_current();
236
237 if (!state->allow_memio)
238 return 0;
239
240 switch (size) {
241 case SB_SIZE_8:
242 return *(u8 *)addr;
243 case SB_SIZE_16:
244 return *(u16 *)addr;
245 case SB_SIZE_32:
246 return *(u32 *)addr;
247 case SB_SIZE_64:
248 return *(u64 *)addr;
249 }
250
251 return 0;
252}
253
Simon Glassd80cda22019-10-11 16:16:47 -0600254void sandbox_write(void *addr, unsigned int val, enum sandboxio_size_t size)
Simon Glass0a341a72019-09-25 08:56:09 -0600255{
256 struct sandbox_state *state = state_get_current();
257
258 if (!state->allow_memio)
259 return;
260
261 switch (size) {
262 case SB_SIZE_8:
263 *(u8 *)addr = val;
264 break;
265 case SB_SIZE_16:
266 *(u16 *)addr = val;
267 break;
268 case SB_SIZE_32:
269 *(u32 *)addr = val;
270 break;
271 case SB_SIZE_64:
272 *(u64 *)addr = val;
273 break;
274 }
275}
276
277void sandbox_set_enable_memio(bool enable)
278{
279 struct sandbox_state *state = state_get_current();
280
281 state->allow_memio = enable;
282}
283
Simon Glassfc1ebd32018-09-15 00:50:56 -0600284void sandbox_set_enable_pci_map(int enable)
Simon Glasse23d2932013-04-20 08:42:37 +0000285{
Simon Glassfc1ebd32018-09-15 00:50:56 -0600286 enable_pci_map = enable;
Simon Glasse23d2932013-04-20 08:42:37 +0000287}
288
Simon Glass3d750d72011-09-26 14:10:39 +0000289void flush_dcache_range(unsigned long start, unsigned long stop)
290{
291}
Simon Glass26b78b22015-02-27 22:06:34 -0700292
Bin Meng843c2992017-08-22 08:15:18 -0700293void invalidate_dcache_range(unsigned long start, unsigned long stop)
294{
295}
296
Simon Glass9a3adfa2022-04-27 13:47:57 -0600297/**
298 * setup_auto_tree() - Set up a basic device tree to allow sandbox to work
299 *
300 * This is used when no device tree is provided. It creates a simple tree with
301 * just a /binman node.
302 *
303 * @blob: Place to put the created device tree
304 * Returns: 0 on success, -ve FDT error code on failure
305 */
306static int setup_auto_tree(void *blob)
307{
308 int err;
309
310 err = fdt_create_empty_tree(blob, 256);
311 if (err)
312 return err;
313
314 /* Create a /binman node in case CONFIG_BINMAN is enabled */
315 err = fdt_add_subnode(blob, 0, "binman");
316 if (err < 0)
317 return err;
318
319 return 0;
320}
321
Ilias Apalodimasab5348a2021-10-26 09:12:33 +0300322void *board_fdt_blob_setup(int *ret)
Simon Glass26b78b22015-02-27 22:06:34 -0700323{
324 struct sandbox_state *state = state_get_current();
325 const char *fname = state->fdt_fname;
Ilias Apalodimasab5348a2021-10-26 09:12:33 +0300326 void *blob = NULL;
Simon Glass26b78b22015-02-27 22:06:34 -0700327 loff_t size;
328 int err;
329 int fd;
330
331 blob = map_sysmem(CONFIG_SYS_FDT_LOAD_ADDR, 0);
Ilias Apalodimasab5348a2021-10-26 09:12:33 +0300332 *ret = 0;
Simon Glass26b78b22015-02-27 22:06:34 -0700333 if (!state->fdt_fname) {
Simon Glass9a3adfa2022-04-27 13:47:57 -0600334 err = setup_auto_tree(blob);
Simon Glass26b78b22015-02-27 22:06:34 -0700335 if (!err)
336 goto done;
Heinrich Schuchardt6fd60e92022-04-04 22:45:04 +0200337 os_printf("Unable to create empty FDT: %s\n", fdt_strerror(err));
Ilias Apalodimasab5348a2021-10-26 09:12:33 +0300338 *ret = -EINVAL;
339 goto fail;
Simon Glass26b78b22015-02-27 22:06:34 -0700340 }
341
342 err = os_get_filesize(fname, &size);
343 if (err < 0) {
Heinrich Schuchardt6fd60e92022-04-04 22:45:04 +0200344 os_printf("Failed to find FDT file '%s'\n", fname);
Ilias Apalodimasab5348a2021-10-26 09:12:33 +0300345 *ret = err;
346 goto fail;
Simon Glass26b78b22015-02-27 22:06:34 -0700347 }
348 fd = os_open(fname, OS_O_RDONLY);
349 if (fd < 0) {
Heinrich Schuchardt6fd60e92022-04-04 22:45:04 +0200350 os_printf("Failed to open FDT file '%s'\n", fname);
Ilias Apalodimasab5348a2021-10-26 09:12:33 +0300351 *ret = -EACCES;
352 goto fail;
Simon Glass26b78b22015-02-27 22:06:34 -0700353 }
Ilias Apalodimasab5348a2021-10-26 09:12:33 +0300354
Simon Glass26b78b22015-02-27 22:06:34 -0700355 if (os_read(fd, blob, size) != size) {
356 os_close(fd);
Heinrich Schuchardt6fd60e92022-04-04 22:45:04 +0200357 os_printf("Failed to read FDT file '%s'\n", fname);
Ilias Apalodimasab5348a2021-10-26 09:12:33 +0300358 *ret = -EIO;
359 goto fail;
Simon Glass26b78b22015-02-27 22:06:34 -0700360 }
361 os_close(fd);
362
363done:
Ilias Apalodimasab5348a2021-10-26 09:12:33 +0300364 return blob;
365fail:
366 return NULL;
Simon Glass26b78b22015-02-27 22:06:34 -0700367}
Simon Glass38e79742017-05-22 05:05:23 -0600368
369ulong timer_get_boot_us(void)
370{
371 static uint64_t base_count;
372 uint64_t count = os_get_nsec();
373
374 if (!base_count)
375 base_count = count;
376
377 return (count - base_count) / 1000;
378}
Simon Glass57b00a92022-09-06 20:27:10 -0600379
380int sandbox_load_other_fdt(void **fdtp, int *sizep)
381{
382 const char *orig;
383 int ret, size;
384 void *fdt = *fdtp;
385
386 ret = state_load_other_fdt(&orig, &size);
387 if (ret) {
388 log_err("Cannot read other FDT\n");
389 return log_msg_ret("ld", ret);
390 }
391
392 if (!*fdtp) {
393 fdt = os_malloc(size);
394 if (!fdt)
395 return log_msg_ret("mem", -ENOMEM);
396 *sizep = size;
397 }
398
399 memcpy(fdt, orig, *sizep);
400 *fdtp = fdt;
401
402 return 0;
403}