2 * Copyright (c) 2008 Marcel Moolenaar
3 * Copyright (c) 2009 Nathan Whitehorn
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/kernel.h>
37 #include <sys/sched.h>
42 #include <machine/bus.h>
43 #include <machine/cpu.h>
44 #include <machine/hid.h>
45 #include <machine/platformvar.h>
46 #include <machine/rtas.h>
47 #include <machine/smp.h>
48 #include <machine/spr.h>
49 #include <machine/trap.h>
51 #include <dev/ofw/openfirm.h>
52 #include <machine/ofw_machdep.h>
54 #include "platform_if.h"
61 static uint8_t splpar_vpa[MAXCPU][640] __aligned(128); /* XXX: dpcpu */
64 static vm_offset_t realmaxaddr = VM_MAX_ADDRESS;
66 static int chrp_probe(platform_t);
67 static int chrp_attach(platform_t);
68 void chrp_mem_regions(platform_t, struct mem_region *phys, int *physsz,
69 struct mem_region *avail, int *availsz);
70 static vm_offset_t chrp_real_maxaddr(platform_t);
71 static u_long chrp_timebase_freq(platform_t, struct cpuref *cpuref);
72 static int chrp_smp_first_cpu(platform_t, struct cpuref *cpuref);
73 static int chrp_smp_next_cpu(platform_t, struct cpuref *cpuref);
74 static int chrp_smp_get_bsp(platform_t, struct cpuref *cpuref);
75 static void chrp_smp_ap_init(platform_t);
77 static int chrp_smp_start_cpu(platform_t, struct pcpu *cpu);
78 static struct cpu_group *chrp_smp_topo(platform_t plat);
80 static void chrp_reset(platform_t);
82 #include "phyp-hvcall.h"
83 static void phyp_cpu_idle(sbintime_t sbt);
86 static platform_method_t chrp_methods[] = {
87 PLATFORMMETHOD(platform_probe, chrp_probe),
88 PLATFORMMETHOD(platform_attach, chrp_attach),
89 PLATFORMMETHOD(platform_mem_regions, chrp_mem_regions),
90 PLATFORMMETHOD(platform_real_maxaddr, chrp_real_maxaddr),
91 PLATFORMMETHOD(platform_timebase_freq, chrp_timebase_freq),
93 PLATFORMMETHOD(platform_smp_ap_init, chrp_smp_ap_init),
94 PLATFORMMETHOD(platform_smp_first_cpu, chrp_smp_first_cpu),
95 PLATFORMMETHOD(platform_smp_next_cpu, chrp_smp_next_cpu),
96 PLATFORMMETHOD(platform_smp_get_bsp, chrp_smp_get_bsp),
98 PLATFORMMETHOD(platform_smp_start_cpu, chrp_smp_start_cpu),
99 PLATFORMMETHOD(platform_smp_topo, chrp_smp_topo),
102 PLATFORMMETHOD(platform_reset, chrp_reset),
107 static platform_def_t chrp_platform = {
113 PLATFORM_DEF(chrp_platform);
116 chrp_probe(platform_t plat)
118 if (OF_finddevice("/memory") != -1 || OF_finddevice("/memory@0") != -1)
119 return (BUS_PROBE_GENERIC);
125 chrp_attach(platform_t plat)
130 /* XXX: check for /rtas/ibm,hypertas-functions? */
131 if (!(mfmsr() & PSL_HV)) {
132 struct mem_region *phys, *avail;
134 mem_regions(&phys, &nphys, &avail, &navail);
135 realmaxaddr = phys[0].mr_size;
137 pmap_mmu_install("mmu_phyp", BUS_PROBE_SPECIFIC);
138 cpu_idle_hook = phyp_cpu_idle;
140 /* Set up important VPA fields */
141 for (i = 0; i < MAXCPU; i++) {
142 bzero(splpar_vpa[i], sizeof(splpar_vpa));
143 /* First two: VPA size */
145 (uint8_t)((sizeof(splpar_vpa[i]) >> 8) & 0xff);
147 (uint8_t)(sizeof(splpar_vpa[i]) & 0xff);
148 splpar_vpa[i][0xba] = 1; /* Maintain FPRs */
149 splpar_vpa[i][0xbb] = 1; /* Maintain PMCs */
150 splpar_vpa[i][0xfc] = 0xff; /* Maintain full SLB */
151 splpar_vpa[i][0xfd] = 0xff;
152 splpar_vpa[i][0xff] = 1; /* Maintain Altivec */
156 /* Set up hypervisor CPU stuff */
157 chrp_smp_ap_init(plat);
161 /* Some systems (e.g. QEMU) need Open Firmware to stand down */
168 parse_drconf_memory(struct mem_region *ofmem, int *msz,
169 struct mem_region *ofavail, int *asz)
173 int i, idx, len, lasz, lmsz, res;
174 uint32_t flags, lmb_size[2];
180 phandle = OF_finddevice("/ibm,dynamic-reconfiguration-memory");
182 /* No drconf node, return. */
185 res = OF_getencprop(phandle, "ibm,lmb-size", lmb_size,
189 printf("Logical Memory Block size: %d MB\n", lmb_size[1] >> 20);
191 /* Parse the /ibm,dynamic-memory.
192 The first position gives the # of entries. The next two words
193 reflect the address of the memory block. The next four words are
194 the DRC index, reserved, list index and flags.
195 (see PAPR C.6.6.2 ibm,dynamic-reconfiguration-memory)
197 #el Addr DRC-idx res list-idx flags
198 -------------------------------------------------
199 | 4 | 8 | 4 | 4 | 4 | 4 |....
200 -------------------------------------------------
203 len = OF_getproplen(phandle, "ibm,dynamic-memory");
206 /* We have to use a variable length array on the stack
207 since we have very limited stack space.
209 cell_t arr[len/sizeof(cell_t)];
211 res = OF_getencprop(phandle, "ibm,dynamic-memory", arr,
216 /* Number of elements */
219 /* First address, in arr[1], arr[2]*/
222 for (i = 0; i < idx; i++) {
223 base = ((uint64_t)dmem[0] << 32) + dmem[1];
226 /* Use region only if available and not reserved. */
227 if ((flags & 0x8) && !(flags & 0x80)) {
228 ofmem[lmsz].mr_start = base;
229 ofmem[lmsz].mr_size = (vm_size_t)lmb_size[1];
230 ofavail[lasz].mr_start = base;
231 ofavail[lasz].mr_size = (vm_size_t)lmb_size[1];
246 chrp_mem_regions(platform_t plat, struct mem_region *phys, int *physsz,
247 struct mem_region *avail, int *availsz)
249 vm_offset_t maxphysaddr;
252 ofw_mem_regions(phys, physsz, avail, availsz);
253 parse_drconf_memory(phys, physsz, avail, availsz);
256 * On some firmwares (SLOF), some memory may be marked available that
257 * doesn't actually exist. This manifests as an extension of the last
258 * available segment past the end of physical memory, so truncate that
262 for (i = 0; i < *physsz; i++)
263 if (phys[i].mr_start + phys[i].mr_size > maxphysaddr)
264 maxphysaddr = phys[i].mr_start + phys[i].mr_size;
266 for (i = 0; i < *availsz; i++)
267 if (avail[i].mr_start + avail[i].mr_size > maxphysaddr)
268 avail[i].mr_size = maxphysaddr - avail[i].mr_start;
272 chrp_real_maxaddr(platform_t plat)
274 return (realmaxaddr);
278 chrp_timebase_freq(platform_t plat, struct cpuref *cpuref)
283 phandle = cpuref->cr_hwref;
285 OF_getencprop(phandle, "timebase-frequency", &ticks, sizeof(ticks));
288 panic("Unable to determine timebase frequency!");
294 chrp_smp_first_cpu(platform_t plat, struct cpuref *cpuref)
297 phandle_t cpu, dev, root;
302 dev = OF_child(root);
304 res = OF_getprop(dev, "name", buf, sizeof(buf));
305 if (res > 0 && strcmp(buf, "cpus") == 0)
311 * psim doesn't have a name property on the /cpus node,
312 * but it can be found directly
314 dev = OF_finddevice("/cpus");
322 res = OF_getprop(cpu, "device_type", buf, sizeof(buf));
323 if (res > 0 && strcmp(buf, "cpu") == 0)
330 cpuref->cr_hwref = cpu;
331 res = OF_getencprop(cpu, "ibm,ppc-interrupt-server#s", &cpuid,
334 res = OF_getencprop(cpu, "reg", &cpuid, sizeof(cpuid));
337 cpuref->cr_cpuid = cpuid;
343 chrp_smp_next_cpu(platform_t plat, struct cpuref *cpuref)
349 /* Check for whether it should be the next thread */
350 res = OF_getproplen(cpuref->cr_hwref, "ibm,ppc-interrupt-server#s");
352 cell_t interrupt_servers[res/sizeof(cell_t)];
353 OF_getencprop(cpuref->cr_hwref, "ibm,ppc-interrupt-server#s",
354 interrupt_servers, res);
355 for (i = 0; i < res/sizeof(cell_t) - 1; i++) {
356 if (interrupt_servers[i] == cpuref->cr_cpuid) {
357 cpuref->cr_cpuid = interrupt_servers[i+1];
363 /* Next CPU core/package */
364 cpu = OF_peer(cpuref->cr_hwref);
366 res = OF_getprop(cpu, "device_type", buf, sizeof(buf));
367 if (res > 0 && strcmp(buf, "cpu") == 0)
374 cpuref->cr_hwref = cpu;
375 res = OF_getencprop(cpu, "ibm,ppc-interrupt-server#s", &cpuid,
378 res = OF_getencprop(cpu, "reg", &cpuid, sizeof(cpuid));
381 cpuref->cr_cpuid = cpuid;
387 chrp_smp_get_bsp(platform_t plat, struct cpuref *cpuref)
390 phandle_t bsp, chosen;
393 chosen = OF_finddevice("/chosen");
397 res = OF_getencprop(chosen, "cpu", &inst, sizeof(inst));
401 bsp = OF_instance_to_package(inst);
403 /* Pick the primary thread. Can it be any other? */
404 cpuref->cr_hwref = bsp;
405 res = OF_getencprop(bsp, "ibm,ppc-interrupt-server#s", &cpuid,
408 res = OF_getencprop(bsp, "reg", &cpuid, sizeof(cpuid));
411 cpuref->cr_cpuid = cpuid;
418 chrp_smp_start_cpu(platform_t plat, struct pcpu *pc)
421 int result, err, timeout;
423 if (!rtas_exists()) {
424 printf("RTAS uninitialized: unable to start AP %d\n",
429 start_cpu = rtas_token_lookup("start-cpu");
430 if (start_cpu == -1) {
431 printf("RTAS unknown method: unable to start AP %d\n",
439 result = rtas_call_method(start_cpu, 3, 1, pc->pc_cpuid, EXC_RST, pc,
441 if (result < 0 || err != 0) {
442 printf("RTAS error (%d/%d): unable to start AP %d\n",
443 result, err, pc->pc_cpuid);
448 while (!pc->pc_awake && timeout--)
451 return ((pc->pc_awake) ? 0 : EBUSY);
454 static struct cpu_group *
455 chrp_smp_topo(platform_t plat)
457 struct pcpu *pc, *last_pc;
458 int i, ncores, ncpus;
462 for (i = 0; i <= mp_maxid; i++) {
466 if (last_pc == NULL || pc->pc_hwref != last_pc->pc_hwref)
472 if (ncpus % ncores != 0) {
473 printf("WARNING: Irregular SMP topology. Performance may be "
474 "suboptimal (%d CPUS, %d cores)\n", ncpus, ncores);
475 return (smp_topo_none());
478 /* Don't do anything fancier for non-threaded SMP */
480 return (smp_topo_none());
482 return (smp_topo_1level(CG_SHARE_L1, ncpus / ncores, CG_FLAG_SMT));
487 chrp_reset(platform_t platform)
494 phyp_cpu_idle(sbintime_t sbt)
500 mtmsr(msr & ~PSL_EE);
501 if (sched_runnable()) {
506 phyp_hcall(H_CEDE); /* Re-enables interrupts internally */
511 chrp_smp_ap_init(platform_t platform)
513 if (!(mfmsr() & PSL_HV)) {
515 phyp_hcall(H_REGISTER_VPA, 1UL, PCPU_GET(cpuid),
516 splpar_vpa[PCPU_GET(cpuid)]);
518 /* Set interrupt priority */
519 phyp_hcall(H_CPPR, 0xff);
524 chrp_smp_ap_init(platform_t platform)