|
1 /* |
|
2 * Qemu PowerPC 440 Bamboo board emulation |
|
3 * |
|
4 * Copyright 2007 IBM Corporation. |
|
5 * Authors: |
|
6 * Jerone Young <jyoung5@us.ibm.com> |
|
7 * Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com> |
|
8 * Hollis Blanchard <hollisb@us.ibm.com> |
|
9 * |
|
10 * This work is licensed under the GNU GPL license version 2 or later. |
|
11 * |
|
12 */ |
|
13 |
|
14 #include "config.h" |
|
15 #include "qemu-common.h" |
|
16 #include "net.h" |
|
17 #include "hw.h" |
|
18 #include "pci.h" |
|
19 #include "virtio-pci.h" |
|
20 #include "boards.h" |
|
21 #include "sysemu.h" |
|
22 #include "ppc440.h" |
|
23 #include "kvm.h" |
|
24 #include "kvm_ppc.h" |
|
25 #include "device_tree.h" |
|
26 |
|
27 #define BINARY_DEVICE_TREE_FILE "bamboo.dtb" |
|
28 |
|
29 static void *bamboo_load_device_tree(void *addr, |
|
30 uint32_t ramsize, |
|
31 target_phys_addr_t initrd_base, |
|
32 target_phys_addr_t initrd_size, |
|
33 const char *kernel_cmdline) |
|
34 { |
|
35 void *fdt = NULL; |
|
36 #ifdef HAVE_FDT |
|
37 uint32_t mem_reg_property[] = { 0, 0, ramsize }; |
|
38 char *path; |
|
39 int pathlen; |
|
40 int ret; |
|
41 |
|
42 pathlen = snprintf(NULL, 0, "%s/%s", bios_dir, BINARY_DEVICE_TREE_FILE) + 1; |
|
43 path = qemu_malloc(pathlen); |
|
44 if (path == NULL) |
|
45 return NULL; |
|
46 |
|
47 snprintf(path, pathlen, "%s/%s", bios_dir, BINARY_DEVICE_TREE_FILE); |
|
48 |
|
49 fdt = load_device_tree(path, addr); |
|
50 free(path); |
|
51 if (fdt == NULL) |
|
52 goto out; |
|
53 |
|
54 /* Manipulate device tree in memory. */ |
|
55 |
|
56 ret = qemu_devtree_setprop(fdt, "/memory", "reg", mem_reg_property, |
|
57 sizeof(mem_reg_property)); |
|
58 if (ret < 0) |
|
59 fprintf(stderr, "couldn't set /memory/reg\n"); |
|
60 |
|
61 ret = qemu_devtree_setprop_cell(fdt, "/chosen", "linux,initrd-start", |
|
62 initrd_base); |
|
63 if (ret < 0) |
|
64 fprintf(stderr, "couldn't set /chosen/linux,initrd-start\n"); |
|
65 |
|
66 ret = qemu_devtree_setprop_cell(fdt, "/chosen", "linux,initrd-end", |
|
67 (initrd_base + initrd_size)); |
|
68 if (ret < 0) |
|
69 fprintf(stderr, "couldn't set /chosen/linux,initrd-end\n"); |
|
70 |
|
71 ret = qemu_devtree_setprop_string(fdt, "/chosen", "bootargs", |
|
72 kernel_cmdline); |
|
73 if (ret < 0) |
|
74 fprintf(stderr, "couldn't set /chosen/bootargs\n"); |
|
75 |
|
76 if (kvm_enabled()) |
|
77 kvmppc_fdt_update(fdt); |
|
78 |
|
79 out: |
|
80 #endif |
|
81 |
|
82 return fdt; |
|
83 } |
|
84 |
|
85 static void bamboo_init(ram_addr_t ram_size, int vga_ram_size, |
|
86 const char *boot_device, DisplayState *ds, |
|
87 const char *kernel_filename, |
|
88 const char *kernel_cmdline, |
|
89 const char *initrd_filename, |
|
90 const char *cpu_model) |
|
91 { |
|
92 unsigned int pci_irq_nrs[4] = { 28, 27, 26, 25 }; |
|
93 NICInfo *nd; |
|
94 PCIBus *pcibus; |
|
95 CPUState *env; |
|
96 uint64_t elf_entry; |
|
97 uint64_t elf_lowaddr; |
|
98 target_ulong entry = 0; |
|
99 target_ulong loadaddr = 0; |
|
100 target_long kernel_size = 0; |
|
101 target_ulong initrd_base = 0; |
|
102 target_long initrd_size = 0; |
|
103 target_ulong dt_base = 0; |
|
104 void *fdt; |
|
105 int i; |
|
106 |
|
107 /* Setup CPU. */ |
|
108 env = ppc440ep_init(&ram_size, &pcibus, pci_irq_nrs, 1); |
|
109 |
|
110 if (pcibus) { |
|
111 int unit_id = 0; |
|
112 |
|
113 /* Add virtio block devices. */ |
|
114 while ((i = drive_get_index(IF_VIRTIO, 0, unit_id)) != -1) { |
|
115 virtio_blk_init_pci(pcibus, drives_table[i].bdrv); |
|
116 unit_id++; |
|
117 } |
|
118 |
|
119 /* Register network interfaces. */ |
|
120 for (i = 0; i < nb_nics; i++) { |
|
121 nd = &nd_table[i]; |
|
122 if (!nd->model) { |
|
123 /* There are no PCI NICs on the Bamboo board, but there are |
|
124 * PCI slots, so we can pick model whatever we want. */ |
|
125 nd->model = "e1000"; |
|
126 } |
|
127 pci_nic_init(pcibus, nd, -1); |
|
128 } |
|
129 } |
|
130 |
|
131 /* Load kernel. */ |
|
132 if (kernel_filename) { |
|
133 kernel_size = load_uimage(kernel_filename, &entry, &loadaddr, NULL); |
|
134 if (kernel_size < 0) { |
|
135 kernel_size = load_elf(kernel_filename, 0, &elf_entry, &elf_lowaddr, |
|
136 NULL); |
|
137 entry = elf_entry; |
|
138 loadaddr = elf_lowaddr; |
|
139 } |
|
140 /* XXX try again as binary */ |
|
141 if (kernel_size < 0) { |
|
142 fprintf(stderr, "qemu: could not load kernel '%s'\n", |
|
143 kernel_filename); |
|
144 exit(1); |
|
145 } |
|
146 } |
|
147 |
|
148 /* Load initrd. */ |
|
149 if (initrd_filename) { |
|
150 initrd_base = kernel_size + loadaddr; |
|
151 initrd_size = load_image(initrd_filename, phys_ram_base + initrd_base); |
|
152 |
|
153 if (initrd_size < 0) { |
|
154 fprintf(stderr, "qemu: could not load initial ram disk '%s'\n", |
|
155 initrd_filename); |
|
156 exit(1); |
|
157 } |
|
158 } |
|
159 |
|
160 /* If we're loading a kernel directly, we must load the device tree too. */ |
|
161 if (kernel_filename) { |
|
162 if (initrd_base) |
|
163 dt_base = initrd_base + initrd_size; |
|
164 else |
|
165 dt_base = kernel_size + loadaddr; |
|
166 |
|
167 fdt = bamboo_load_device_tree(phys_ram_base + dt_base, ram_size, |
|
168 initrd_base, initrd_size, kernel_cmdline); |
|
169 if (fdt == NULL) { |
|
170 fprintf(stderr, "couldn't load device tree\n"); |
|
171 exit(1); |
|
172 } |
|
173 |
|
174 /* Set initial guest state. */ |
|
175 env->gpr[1] = (16<<20) - 8; |
|
176 env->gpr[3] = dt_base; |
|
177 env->nip = entry; |
|
178 /* XXX we currently depend on KVM to create some initial TLB entries. */ |
|
179 } |
|
180 |
|
181 if (kvm_enabled()) |
|
182 kvmppc_init(); |
|
183 } |
|
184 |
|
185 QEMUMachine bamboo_machine = { |
|
186 .name = "bamboo", |
|
187 .desc = "bamboo", |
|
188 .init = bamboo_init, |
|
189 .ram_require = 8<<20 | RAMSIZE_FIXED, |
|
190 }; |