sys/powerpc/powermac/platform_powermac.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 #include <vm/vm.h>
  39 #include <vm/pmap.h>
  40
  41 #include <machine/bus.h>
  42 #include <machine/cpu.h>
  43 #include <machine/hid.h>
  44 #include <machine/platformvar.h>
  45 #include <machine/pmap.h>
  46 #include <machine/smp.h>
  47 #include <machine/spr.h>
  48
  49 #include <dev/ofw/openfirm.h>
  50 #include <machine/ofw_machdep.h>
  51
  52 #include "platform_if.h"
  53
  54 #ifdef SMP
  55 extern void *ap_pcpu;
  56 #endif
  57
  58 static int powermac_probe(platform_t);
  59 void powermac_mem_regions(platform_t, struct mem_region **phys, int *physsz,
  60     struct mem_region **avail, int *availsz);
  61 static u_long powermac_timebase_freq(platform_t, struct cpuref *cpuref);
  62 static int powermac_smp_first_cpu(platform_t, struct cpuref *cpuref);
  63 static int powermac_smp_next_cpu(platform_t, struct cpuref *cpuref);
  64 static int powermac_smp_get_bsp(platform_t, struct cpuref *cpuref);
  65 static int powermac_smp_start_cpu(platform_t, struct pcpu *cpu);
  66 static void powermac_reset(platform_t);
  67
  68 static platform_method_t powermac_methods[] = {
  69         PLATFORMMETHOD(platform_probe,          powermac_probe),
  70         PLATFORMMETHOD(platform_mem_regions,    powermac_mem_regions),
  71         PLATFORMMETHOD(platform_timebase_freq,  powermac_timebase_freq),
  72
  73         PLATFORMMETHOD(platform_smp_first_cpu,  powermac_smp_first_cpu),
  74         PLATFORMMETHOD(platform_smp_next_cpu,   powermac_smp_next_cpu),
  75         PLATFORMMETHOD(platform_smp_get_bsp,    powermac_smp_get_bsp),
  76         PLATFORMMETHOD(platform_smp_start_cpu,  powermac_smp_start_cpu),
  77
  78         PLATFORMMETHOD(platform_reset,          powermac_reset),
  79
  80         { 0, 0 }
  81 };
  82
  83 static platform_def_t powermac_platform = {
  84         "powermac",
  85         powermac_methods,
  86         0
  87 };
  88
  89 PLATFORM_DEF(powermac_platform);
  90
  91 static int
  92 powermac_probe(platform_t plat)
  93 {
  94         if (OF_finddevice("/memory") != -1 || OF_finddevice("/memory@0") != -1)
  95                 return (BUS_PROBE_GENERIC);
  96
  97         return (ENXIO);
  98 }
  99
 100 void
 101 powermac_mem_regions(platform_t plat, struct mem_region **phys, int *physsz,
 102     struct mem_region **avail, int *availsz)
 103 {
 104         ofw_mem_regions(phys,physsz,avail,availsz);
 105 }
 106
 107 static u_long
 108 powermac_timebase_freq(platform_t plat, struct cpuref *cpuref)
 109 {
 110         phandle_t phandle;
 111         int32_t ticks = -1;
 112
 113         phandle = cpuref->cr_hwref;
 114
 115         OF_getprop(phandle, "timebase-frequency", &ticks, sizeof(ticks));
 116
 117         if (ticks <= 0)
 118                 panic("Unable to determine timebase frequency!");
 119
 120         return (ticks);
 121 }
 122
 123
 124 static int
 125 powermac_smp_fill_cpuref(struct cpuref *cpuref, phandle_t cpu)
 126 {
 127         cell_t cpuid, res;
 128
 129         cpuref->cr_hwref = cpu;
 130         res = OF_getprop(cpu, "reg", &cpuid, sizeof(cpuid));
 131
 132         /*
 133          * psim doesn't have a reg property, so assume 0 as for the
 134          * uniprocessor case in the CHRP spec.
 135          */
 136         if (res < 0) {
 137                 cpuid = 0;
 138         }
 139
 140         cpuref->cr_cpuid = cpuid & 0xff;
 141         return (0);
 142 }
 143
 144 static int
 145 powermac_smp_first_cpu(platform_t plat, struct cpuref *cpuref)
 146 {
 147         char buf[8];
 148         phandle_t cpu, dev, root;
 149         int res;
 150
 151         root = OF_peer(0);
 152
 153         dev = OF_child(root);
 154         while (dev != 0) {
 155                 res = OF_getprop(dev, "name", buf, sizeof(buf));
 156                 if (res > 0 && strcmp(buf, "cpus") == 0)
 157                         break;
 158                 dev = OF_peer(dev);
 159         }
 160         if (dev == 0) {
 161                 /*
 162                  * psim doesn't have a name property on the /cpus node,
 163                  * but it can be found directly
 164                  */
 165                 dev = OF_finddevice("/cpus");
 166                 if (dev == 0)
 167                         return (ENOENT);
 168         }
 169
 170         cpu = OF_child(dev);
 171
 172         while (cpu != 0) {
 173                 res = OF_getprop(cpu, "device_type", buf, sizeof(buf));
 174                 if (res > 0 && strcmp(buf, "cpu") == 0)
 175                         break;
 176                 cpu = OF_peer(cpu);
 177         }
 178         if (cpu == 0)
 179                 return (ENOENT);
 180
 181         return (powermac_smp_fill_cpuref(cpuref, cpu));
 182 }
 183
 184 static int
 185 powermac_smp_next_cpu(platform_t plat, struct cpuref *cpuref)
 186 {
 187         char buf[8];
 188         phandle_t cpu;
 189         int res;
 190
 191         cpu = OF_peer(cpuref->cr_hwref);
 192         while (cpu != 0) {
 193                 res = OF_getprop(cpu, "device_type", buf, sizeof(buf));
 194                 if (res > 0 && strcmp(buf, "cpu") == 0)
 195                         break;
 196                 cpu = OF_peer(cpu);
 197         }
 198         if (cpu == 0)
 199                 return (ENOENT);
 200
 201         return (powermac_smp_fill_cpuref(cpuref, cpu));
 202 }
 203
 204 static int
 205 powermac_smp_get_bsp(platform_t plat, struct cpuref *cpuref)
 206 {
 207         ihandle_t inst;
 208         phandle_t bsp, chosen;
 209         int res;
 210
 211         chosen = OF_finddevice("/chosen");
 212         if (chosen == 0)
 213                 return (ENXIO);
 214
 215         res = OF_getprop(chosen, "cpu", &inst, sizeof(inst));
 216         if (res < 0)
 217                 return (ENXIO);
 218
 219         bsp = OF_instance_to_package(inst);
 220         return (powermac_smp_fill_cpuref(cpuref, bsp));
 221 }
 222
 223 static int
 224 powermac_smp_start_cpu(platform_t plat, struct pcpu *pc)
 225 {
 226 #ifdef SMP
 227         phandle_t cpu;
 228         volatile uint8_t *rstvec;
 229         static volatile uint8_t *rstvec_virtbase = NULL;
 230         int res, reset, timeout;
 231
 232         cpu = pc->pc_hwref;
 233         res = OF_getprop(cpu, "soft-reset", &reset, sizeof(reset));
 234         if (res < 0) {
 235                 reset = 0x58;
 236
 237                 switch (pc->pc_cpuid) {
 238                 case 0:
 239                         reset += 0x03;
 240                         break;
 241                 case 1:
 242                         reset += 0x04;
 243                         break;
 244                 case 2:
 245                         reset += 0x0f;
 246                         break;
 247                 case 3:
 248                         reset += 0x10;
 249                         break;
 250                 default:
 251                         return (ENXIO);
 252                 }
 253         }
 254
 255         ap_pcpu = pc;
 256
 257         if (rstvec_virtbase == NULL)
 258                 rstvec_virtbase = pmap_mapdev(0x80000000, PAGE_SIZE);
 259
 260         rstvec = rstvec_virtbase + reset;
 261
 262         *rstvec = 4;
 263         powerpc_sync();
 264         (void)(*rstvec);
 265         powerpc_sync();
 266         DELAY(1);
 267         *rstvec = 0;
 268         powerpc_sync();
 269         (void)(*rstvec);
 270         powerpc_sync();
 271
 272         timeout = 10000;
 273         while (!pc->pc_awake && timeout--)
 274                 DELAY(100);
 275
 276         return ((pc->pc_awake) ? 0 : EBUSY);
 277 #else
 278         /* No SMP support */
 279         return (ENXIO);
 280 #endif
 281 }
 282
 283 static void
 284 powermac_reset(platform_t platform)
 285 {
 286         OF_reboot();
 287 }
 288