sys/powerpc/aim/platform_chrp.c

   1 /*-
   2  * Copyright (c) 2008 Marcel Moolenaar
   3  * Copyright (c) 2009 Nathan Whitehorn
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  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.
  15  *
  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.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/kernel.h>
  34 #include <sys/bus.h>
  35 #include <sys/pcpu.h>
  36 #include <sys/proc.h>
  37 #include <sys/smp.h>
  38
  39 #include <machine/bus.h>
  40 #include <machine/cpu.h>
  41 #include <machine/hid.h>
  42 #include <machine/platformvar.h>
  43 #include <machine/smp.h>
  44 #include <machine/spr.h>
  45
  46 #include <dev/ofw/openfirm.h>
  47 #include <machine/ofw_machdep.h>
  48
  49 #include "platform_if.h"
  50
  51 #ifdef SMP
  52 extern void *ap_pcpu;
  53 #endif
  54
  55 static int chrp_probe(platform_t);
  56 void chrp_mem_regions(platform_t, struct mem_region **phys, int *physsz,
  57     struct mem_region **avail, int *availsz);
  58 static u_long chrp_timebase_freq(platform_t, struct cpuref *cpuref);
  59 static int chrp_smp_first_cpu(platform_t, struct cpuref *cpuref);
  60 static int chrp_smp_next_cpu(platform_t, struct cpuref *cpuref);
  61 static int chrp_smp_get_bsp(platform_t, struct cpuref *cpuref);
  62 static int chrp_smp_start_cpu(platform_t, struct pcpu *cpu);
  63
  64 static platform_method_t chrp_methods[] = {
  65         PLATFORMMETHOD(platform_probe,          chrp_probe),
  66         PLATFORMMETHOD(platform_mem_regions,    chrp_mem_regions),
  67         PLATFORMMETHOD(platform_timebase_freq,  chrp_timebase_freq),
  68
  69         PLATFORMMETHOD(platform_smp_first_cpu,  chrp_smp_first_cpu),
  70         PLATFORMMETHOD(platform_smp_next_cpu,   chrp_smp_next_cpu),
  71         PLATFORMMETHOD(platform_smp_get_bsp,    chrp_smp_get_bsp),
  72         PLATFORMMETHOD(platform_smp_start_cpu,  chrp_smp_start_cpu),
  73
  74         { 0, 0 }
  75 };
  76
  77 static platform_def_t chrp_platform = {
  78         "chrp",
  79         chrp_methods,
  80         0
  81 };
  82
  83 PLATFORM_DEF(chrp_platform);
  84
  85 static int
  86 chrp_probe(platform_t plat)
  87 {
  88         if (OF_finddevice("/memory") != -1)
  89                 return (BUS_PROBE_GENERIC);
  90
  91         return (ENXIO);
  92 }
  93
  94 void
  95 chrp_mem_regions(platform_t plat, struct mem_region **phys, int *physsz,
  96     struct mem_region **avail, int *availsz)
  97 {
  98         ofw_mem_regions(phys,physsz,avail,availsz);
  99 }
 100
 101 static u_long
 102 chrp_timebase_freq(platform_t plat, struct cpuref *cpuref)
 103 {
 104         phandle_t phandle;
 105         long ticks = -1;
 106
 107         phandle = cpuref->cr_hwref;
 108
 109         OF_getprop(phandle, "timebase-frequency", &ticks, sizeof(ticks));
 110
 111         if (ticks <= 0)
 112                 panic("Unable to determine timebase frequency!");
 113
 114         return (ticks);
 115 }
 116
 117
 118 static int
 119 chrp_smp_fill_cpuref(struct cpuref *cpuref, phandle_t cpu)
 120 {
 121         int cpuid, res;
 122
 123         cpuref->cr_hwref = cpu;
 124         res = OF_getprop(cpu, "reg", &cpuid, sizeof(cpuid));
 125
 126         /*
 127          * psim doesn't have a reg property, so assume 0 as for the
 128          * uniprocessor case in the CHRP spec.
 129          */
 130         if (res < 0) {
 131                 cpuid = 0;
 132         }
 133
 134         cpuref->cr_cpuid = cpuid & 0xff;
 135         return (0);
 136 }
 137
 138 static int
 139 chrp_smp_first_cpu(platform_t plat, struct cpuref *cpuref)
 140 {
 141         char buf[8];
 142         phandle_t cpu, dev, root;
 143         int res;
 144
 145         root = OF_peer(0);
 146
 147         dev = OF_child(root);
 148         while (dev != 0) {
 149                 res = OF_getprop(dev, "name", buf, sizeof(buf));
 150                 if (res > 0 && strcmp(buf, "cpus") == 0)
 151                         break;
 152                 dev = OF_peer(dev);
 153         }
 154         if (dev == 0) {
 155                 /*
 156                  * psim doesn't have a name property on the /cpus node,
 157                  * but it can be found directly
 158                  */
 159                 dev = OF_finddevice("/cpus");
 160                 if (dev == 0)
 161                         return (ENOENT);
 162         }
 163
 164         cpu = OF_child(dev);
 165
 166         while (cpu != 0) {
 167                 res = OF_getprop(cpu, "device_type", buf, sizeof(buf));
 168                 if (res > 0 && strcmp(buf, "cpu") == 0)
 169                         break;
 170                 cpu = OF_peer(cpu);
 171         }
 172         if (cpu == 0)
 173                 return (ENOENT);
 174
 175         return (chrp_smp_fill_cpuref(cpuref, cpu));
 176 }
 177
 178 static int
 179 chrp_smp_next_cpu(platform_t plat, struct cpuref *cpuref)
 180 {
 181         char buf[8];
 182         phandle_t cpu;
 183         int res;
 184
 185         cpu = OF_peer(cpuref->cr_hwref);
 186         while (cpu != 0) {
 187                 res = OF_getprop(cpu, "device_type", buf, sizeof(buf));
 188                 if (res > 0 && strcmp(buf, "cpu") == 0)
 189                         break;
 190                 cpu = OF_peer(cpu);
 191         }
 192         if (cpu == 0)
 193                 return (ENOENT);
 194
 195         return (chrp_smp_fill_cpuref(cpuref, cpu));
 196 }
 197
 198 static int
 199 chrp_smp_get_bsp(platform_t plat, struct cpuref *cpuref)
 200 {
 201         ihandle_t inst;
 202         phandle_t bsp, chosen;
 203         int res;
 204
 205         chosen = OF_finddevice("/chosen");
 206         if (chosen == 0)
 207                 return (ENXIO);
 208
 209         res = OF_getprop(chosen, "cpu", &inst, sizeof(inst));
 210         if (res < 0)
 211                 return (ENXIO);
 212
 213         bsp = OF_instance_to_package(inst);
 214         return (chrp_smp_fill_cpuref(cpuref, bsp));
 215 }
 216
 217 static int
 218 chrp_smp_start_cpu(platform_t plat, struct pcpu *pc)
 219 {
 220 #ifdef SMP
 221         phandle_t cpu;
 222         volatile uint8_t *rstvec;
 223         int res, reset, timeout;
 224
 225         cpu = pc->pc_hwref;
 226         res = OF_getprop(cpu, "soft-reset", &reset, sizeof(reset));
 227         if (res < 0)
 228                 return (ENXIO);
 229
 230         ap_pcpu = pc;
 231
 232         rstvec = (uint8_t *)(0x80000000 + reset);
 233
 234         *rstvec = 4;
 235         powerpc_sync();
 236         DELAY(1);
 237         *rstvec = 0;
 238         powerpc_sync();
 239
 240         timeout = 1000;
 241         while (!pc->pc_awake && timeout--)
 242                 DELAY(100);
 243
 244         return ((pc->pc_awake) ? 0 : EBUSY);
 245 #else
 246         /* No SMP support */
 247         return (ENXIO);
 248 #endif
 249 }
 250