← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/u-boot/arch/arm/lib/bootm.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/u-boot/arch/arm/lib/bootm.c
 
1
/* Copyright (C) 2011
 
2
 * Corscience GmbH & Co. KG - Simon Schwarz <schwarz@corscience.de>
 
3
 *  - Added prep subcommand support
 
4
 *  - Reorganized source - modeled after powerpc version
 
5
 *
 
6
 * (C) Copyright 2002
 
7
 * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
 
8
 * Marius Groeger <mgroeger@sysgo.de>
 
9
 *
 
10
 * Copyright (C) 2001  Erik Mouw (J.A.K.Mouw@its.tudelft.nl)
 
11
 *
 
12
 * SPDX-License-Identifier:     GPL-2.0+
 
13
 */
 
14
 
 
15
#include <common.h>
 
16
#include <command.h>
 
17
#include <image.h>
 
18
#include <u-boot/zlib.h>
 
19
#include <asm/byteorder.h>
 
20
#include <libfdt.h>
 
21
#include <fdt_support.h>
 
22
#include <asm/bootm.h>
 
23
#include <linux/compiler.h>
 
24
 
 
25
#if defined(CONFIG_ARMV7_NONSEC) || defined(CONFIG_ARMV7_VIRT)
 
26
#include <asm/armv7.h>
 
27
#endif
 
28
 
 
29
DECLARE_GLOBAL_DATA_PTR;
 
30
 
 
31
static struct tag *params;
 
32
 
 
33
static ulong get_sp(void)
 
34
{
 
35
        ulong ret;
 
36
 
 
37
        asm("mov %0, sp" : "=r"(ret) : );
 
38
        return ret;
 
39
}
 
40
 
 
41
void arch_lmb_reserve(struct lmb *lmb)
 
42
{
 
43
        ulong sp;
 
44
 
 
45
        /*
 
46
         * Booting a (Linux) kernel image
 
47
         *
 
48
         * Allocate space for command line and board info - the
 
49
         * address should be as high as possible within the reach of
 
50
         * the kernel (see CONFIG_SYS_BOOTMAPSZ settings), but in unused
 
51
         * memory, which means far enough below the current stack
 
52
         * pointer.
 
53
         */
 
54
        sp = get_sp();
 
55
        debug("## Current stack ends at 0x%08lx ", sp);
 
56
 
 
57
        /* adjust sp by 4K to be safe */
 
58
        sp -= 4096;
 
59
        lmb_reserve(lmb, sp,
 
60
                    gd->bd->bi_dram[0].start + gd->bd->bi_dram[0].size - sp);
 
61
}
 
62
 
 
63
/**
 
64
 * announce_and_cleanup() - Print message and prepare for kernel boot
 
65
 *
 
66
 * @fake: non-zero to do everything except actually boot
 
67
 */
 
68
static void announce_and_cleanup(int fake)
 
69
{
 
70
        printf("\nStarting kernel ...%s\n\n", fake ?
 
71
                "(fake run for tracing)" : "");
 
72
        bootstage_mark_name(BOOTSTAGE_ID_BOOTM_HANDOFF, "start_kernel");
 
73
#ifdef CONFIG_BOOTSTAGE_FDT
 
74
        bootstage_fdt_add_report();
 
75
#endif
 
76
#ifdef CONFIG_BOOTSTAGE_REPORT
 
77
        bootstage_report();
 
78
#endif
 
79
 
 
80
#ifdef CONFIG_USB_DEVICE
 
81
        udc_disconnect();
 
82
#endif
 
83
        cleanup_before_linux();
 
84
}
 
85
 
 
86
static void setup_start_tag (bd_t *bd)
 
87
{
 
88
        params = (struct tag *)bd->bi_boot_params;
 
89
 
 
90
        params->hdr.tag = ATAG_CORE;
 
91
        params->hdr.size = tag_size (tag_core);
 
92
 
 
93
        params->u.core.flags = 0;
 
94
        params->u.core.pagesize = 0;
 
95
        params->u.core.rootdev = 0;
 
96
 
 
97
        params = tag_next (params);
 
98
}
 
99
 
 
100
static void setup_memory_tags(bd_t *bd)
 
101
{
 
102
        int i;
 
103
 
 
104
        for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
 
105
                params->hdr.tag = ATAG_MEM;
 
106
                params->hdr.size = tag_size (tag_mem32);
 
107
 
 
108
                params->u.mem.start = bd->bi_dram[i].start;
 
109
                params->u.mem.size = bd->bi_dram[i].size;
 
110
 
 
111
                params = tag_next (params);
 
112
        }
 
113
}
 
114
 
 
115
static void setup_commandline_tag(bd_t *bd, char *commandline)
 
116
{
 
117
        char *p;
 
118
 
 
119
        if (!commandline)
 
120
                return;
 
121
 
 
122
        /* eat leading white space */
 
123
        for (p = commandline; *p == ' '; p++);
 
124
 
 
125
        /* skip non-existent command lines so the kernel will still
 
126
         * use its default command line.
 
127
         */
 
128
        if (*p == '\0')
 
129
                return;
 
130
 
 
131
        params->hdr.tag = ATAG_CMDLINE;
 
132
        params->hdr.size =
 
133
                (sizeof (struct tag_header) + strlen (p) + 1 + 4) >> 2;
 
134
 
 
135
        strcpy (params->u.cmdline.cmdline, p);
 
136
 
 
137
        params = tag_next (params);
 
138
}
 
139
 
 
140
static void setup_initrd_tag(bd_t *bd, ulong initrd_start, ulong initrd_end)
 
141
{
 
142
        /* an ATAG_INITRD node tells the kernel where the compressed
 
143
         * ramdisk can be found. ATAG_RDIMG is a better name, actually.
 
144
         */
 
145
        params->hdr.tag = ATAG_INITRD2;
 
146
        params->hdr.size = tag_size (tag_initrd);
 
147
 
 
148
        params->u.initrd.start = initrd_start;
 
149
        params->u.initrd.size = initrd_end - initrd_start;
 
150
 
 
151
        params = tag_next (params);
 
152
}
 
153
 
 
154
static void setup_serial_tag(struct tag **tmp)
 
155
{
 
156
        struct tag *params = *tmp;
 
157
        struct tag_serialnr serialnr;
 
158
 
 
159
        get_board_serial(&serialnr);
 
160
        params->hdr.tag = ATAG_SERIAL;
 
161
        params->hdr.size = tag_size (tag_serialnr);
 
162
        params->u.serialnr.low = serialnr.low;
 
163
        params->u.serialnr.high= serialnr.high;
 
164
        params = tag_next (params);
 
165
        *tmp = params;
 
166
}
 
167
 
 
168
static void setup_revision_tag(struct tag **in_params)
 
169
{
 
170
        u32 rev = 0;
 
171
 
 
172
        rev = get_board_rev();
 
173
        params->hdr.tag = ATAG_REVISION;
 
174
        params->hdr.size = tag_size (tag_revision);
 
175
        params->u.revision.rev = rev;
 
176
        params = tag_next (params);
 
177
}
 
178
 
 
179
static void setup_end_tag(bd_t *bd)
 
180
{
 
181
        params->hdr.tag = ATAG_NONE;
 
182
        params->hdr.size = 0;
 
183
}
 
184
 
 
185
__weak void setup_board_tags(struct tag **in_params) {}
 
186
 
 
187
static void do_nonsec_virt_switch(void)
 
188
{
 
189
#if defined(CONFIG_ARMV7_NONSEC) || defined(CONFIG_ARMV7_VIRT)
 
190
        if (armv7_switch_nonsec() == 0)
 
191
#ifdef CONFIG_ARMV7_VIRT
 
192
                if (armv7_switch_hyp() == 0)
 
193
                        debug("entered HYP mode\n");
 
194
#else
 
195
                debug("entered non-secure state\n");
 
196
#endif
 
197
#endif
 
198
 
 
199
#ifdef CONFIG_ARM64
 
200
        smp_kick_all_cpus();
 
201
        flush_dcache_all();     /* flush cache before swtiching to EL2 */
 
202
        armv8_switch_to_el2();
 
203
#ifdef CONFIG_ARMV8_SWITCH_TO_EL1
 
204
        armv8_switch_to_el1();
 
205
#endif
 
206
#endif
 
207
}
 
208
 
 
209
/* Subcommand: PREP */
 
210
static void boot_prep_linux(bootm_headers_t *images)
 
211
{
 
212
        char *commandline = getenv("bootargs");
 
213
 
 
214
        if (IMAGE_ENABLE_OF_LIBFDT && images->ft_len) {
 
215
#ifdef CONFIG_OF_LIBFDT
 
216
                debug("using: FDT\n");
 
217
                if (image_setup_linux(images)) {
 
218
                        printf("FDT creation failed! hanging...");
 
219
                        hang();
 
220
                }
 
221
#endif
 
222
        } else if (BOOTM_ENABLE_TAGS) {
 
223
                debug("using: ATAGS\n");
 
224
                setup_start_tag(gd->bd);
 
225
                if (BOOTM_ENABLE_SERIAL_TAG)
 
226
                        setup_serial_tag(&params);
 
227
                if (BOOTM_ENABLE_CMDLINE_TAG)
 
228
                        setup_commandline_tag(gd->bd, commandline);
 
229
                if (BOOTM_ENABLE_REVISION_TAG)
 
230
                        setup_revision_tag(&params);
 
231
                if (BOOTM_ENABLE_MEMORY_TAGS)
 
232
                        setup_memory_tags(gd->bd);
 
233
                if (BOOTM_ENABLE_INITRD_TAG) {
 
234
                        if (images->rd_start && images->rd_end) {
 
235
                                setup_initrd_tag(gd->bd, images->rd_start,
 
236
                                                 images->rd_end);
 
237
                        }
 
238
                }
 
239
                setup_board_tags(&params);
 
240
                setup_end_tag(gd->bd);
 
241
        } else {
 
242
                printf("FDT and ATAGS support not compiled in - hanging\n");
 
243
                hang();
 
244
        }
 
245
        do_nonsec_virt_switch();
 
246
}
 
247
 
 
248
/* Subcommand: GO */
 
249
static void boot_jump_linux(bootm_headers_t *images, int flag)
 
250
{
 
251
#ifdef CONFIG_ARM64
 
252
        void (*kernel_entry)(void *fdt_addr);
 
253
        int fake = (flag & BOOTM_STATE_OS_FAKE_GO);
 
254
 
 
255
        kernel_entry = (void (*)(void *fdt_addr))images->ep;
 
256
 
 
257
        debug("## Transferring control to Linux (at address %lx)...\n",
 
258
                (ulong) kernel_entry);
 
259
        bootstage_mark(BOOTSTAGE_ID_RUN_OS);
 
260
 
 
261
        announce_and_cleanup(fake);
 
262
 
 
263
        if (!fake)
 
264
                kernel_entry(images->ft_addr);
 
265
#else
 
266
        unsigned long machid = gd->bd->bi_arch_number;
 
267
        char *s;
 
268
        void (*kernel_entry)(int zero, int arch, uint params);
 
269
        unsigned long r2;
 
270
        int fake = (flag & BOOTM_STATE_OS_FAKE_GO);
 
271
 
 
272
        kernel_entry = (void (*)(int, int, uint))images->ep;
 
273
 
 
274
        s = getenv("machid");
 
275
        if (s) {
 
276
                strict_strtoul(s, 16, &machid);
 
277
                printf("Using machid 0x%lx from environment\n", machid);
 
278
        }
 
279
 
 
280
        debug("## Transferring control to Linux (at address %08lx)" \
 
281
                "...\n", (ulong) kernel_entry);
 
282
        bootstage_mark(BOOTSTAGE_ID_RUN_OS);
 
283
        announce_and_cleanup(fake);
 
284
 
 
285
        if (IMAGE_ENABLE_OF_LIBFDT && images->ft_len)
 
286
                r2 = (unsigned long)images->ft_addr;
 
287
        else
 
288
                r2 = gd->bd->bi_boot_params;
 
289
 
 
290
        if (!fake)
 
291
                kernel_entry(0, machid, r2);
 
292
#endif
 
293
}
 
294
 
 
295
/* Main Entry point for arm bootm implementation
 
296
 *
 
297
 * Modeled after the powerpc implementation
 
298
 * DIFFERENCE: Instead of calling prep and go at the end
 
299
 * they are called if subcommand is equal 0.
 
300
 */
 
301
int do_bootm_linux(int flag, int argc, char *argv[], bootm_headers_t *images)
 
302
{
 
303
        /* No need for those on ARM */
 
304
        if (flag & BOOTM_STATE_OS_BD_T || flag & BOOTM_STATE_OS_CMDLINE)
 
305
                return -1;
 
306
 
 
307
        if (flag & BOOTM_STATE_OS_PREP) {
 
308
                boot_prep_linux(images);
 
309
                return 0;
 
310
        }
 
311
 
 
312
        if (flag & (BOOTM_STATE_OS_GO | BOOTM_STATE_OS_FAKE_GO)) {
 
313
                boot_jump_linux(images, flag);
 
314
                return 0;
 
315
        }
 
316
 
 
317
        boot_prep_linux(images);
 
318
        boot_jump_linux(images, flag);
 
319
        return 0;
 
320
}
 
321
 
 
322
#ifdef CONFIG_CMD_BOOTZ
 
323
 
 
324
struct zimage_header {
 
325
        uint32_t        code[9];
 
326
        uint32_t        zi_magic;
 
327
        uint32_t        zi_start;
 
328
        uint32_t        zi_end;
 
329
};
 
330
 
 
331
#define LINUX_ARM_ZIMAGE_MAGIC  0x016f2818
 
332
 
 
333
int bootz_setup(ulong image, ulong *start, ulong *end)
 
334
{
 
335
        struct zimage_header *zi;
 
336
 
 
337
        zi = (struct zimage_header *)map_sysmem(image, 0);
 
338
        if (zi->zi_magic != LINUX_ARM_ZIMAGE_MAGIC) {
 
339
                puts("Bad Linux ARM zImage magic!\n");
 
340
                return 1;
 
341
        }
 
342
 
 
343
        *start = zi->zi_start;
 
344
        *end = zi->zi_end;
 
345
 
 
346
        printf("Kernel image @ %#08lx [ %#08lx - %#08lx ]\n", image, *start,
 
347
              *end);
 
348
 
 
349
        return 0;
 
350
}
 
351
 
 
352
#endif  /* CONFIG_CMD_BOOTZ */
 
353
 
 
354
#if defined(CONFIG_BOOTM_VXWORKS)
 
355
void boot_prep_vxworks(bootm_headers_t *images)
 
356
{
 
357
#if defined(CONFIG_OF_LIBFDT)
 
358
        int off;
 
359
 
 
360
        if (images->ft_addr) {
 
361
                off = fdt_path_offset(images->ft_addr, "/memory");
 
362
                if (off < 0) {
 
363
                        if (arch_fixup_memory_node(images->ft_addr))
 
364
                                puts("## WARNING: fixup memory failed!\n");
 
365
                }
 
366
        }
 
367
#endif
 
368
        cleanup_before_linux();
 
369
}
 
370
void boot_jump_vxworks(bootm_headers_t *images)
 
371
{
 
372
        /* ARM VxWorks requires device tree physical address to be passed */
 
373
        ((void (*)(void *))images->ep)(images->ft_addr);
 
374
}
 
375
#endif