1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/config/powerpc64.mk	Fri Jul 14 10:47:50 2006 +0100
     1.3 @@ -0,0 +1,4 @@
     1.4 +CONFIG_POWERPC := y
     1.5 +
     1.6 +CFLAGS += -DELFSIZE=64
     1.7 +LIBDIR := lib

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/tools/libxc/xc_ppc_linux_build.c	Fri Jul 14 10:47:50 2006 +0100
     2.3 @@ -0,0 +1,408 @@
     2.4 +/*
     2.5 + * This program is free software; you can redistribute it and/or modify
     2.6 + * it under the terms of the GNU General Public License as published by
     2.7 + * the Free Software Foundation; either version 2 of the License, or
     2.8 + * (at your option) any later version.
     2.9 + *
    2.10 + * This program is distributed in the hope that it will be useful,
    2.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    2.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    2.13 + * GNU General Public License for more details.
    2.14 + *
    2.15 + * You should have received a copy of the GNU General Public License
    2.16 + * along with this program; if not, write to the Free Software
    2.17 + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
    2.18 + *
    2.19 + * Copyright (C) IBM Corporation 2006
    2.20 + *
    2.21 + * Authors: Hollis Blanchard <hollisb@us.ibm.com>
    2.22 + */
    2.23 +
    2.24 +#include <stdio.h>
    2.25 +#include <stdint.h>
    2.26 +#include <stdlib.h>
    2.27 +#include <string.h>
    2.28 +#include <unistd.h>
    2.29 +#include <fcntl.h>
    2.30 +#include <sys/types.h>
    2.31 +#include <inttypes.h>
    2.32 +
    2.33 +#include <xen/dom0_ops.h>
    2.34 +#include <xen/memory.h>
    2.35 +#include <xc_private.h>
    2.36 +#include <xg_private.h>
    2.37 +#include <xenctrl.h>
    2.38 +
    2.39 +/* XXX 64M hack */
    2.40 +#define MEMSIZE (64UL << 20)
    2.41 +#define INITRD_ADDR (24UL << 20)
    2.42 +
    2.43 +int verbose;
    2.44 +#define VERBOSE(stuff, ...) \
    2.45 +    if (verbose) \
    2.46 +        stuff __VA_ARGS__;
    2.47 +
    2.48 +#define ALIGN_UP(addr,size) (((addr)+((size)-1))&(~((size)-1)))
    2.49 +
    2.50 +#define max(x,y) ({ \
    2.51 +        const typeof(x) _x = (x);       \
    2.52 +        const typeof(y) _y = (y);       \
    2.53 +        (void) (&_x == &_y);            \
    2.54 +        _x > _y ? _x : _y; })
    2.55 +
    2.56 +static void *load_file(const char *path, unsigned long *filesize)
    2.57 +{
    2.58 +    void *img;
    2.59 +    ssize_t size;
    2.60 +    int fd;
    2.61 +
    2.62 +    VERBOSE(printf("load_file(%s)\n", path));
    2.63 +
    2.64 +    fd = open(path, O_RDONLY);
    2.65 +    if (fd < 0) {
    2.66 +        perror(path);
    2.67 +        return NULL;
    2.68 +    }
    2.69 +
    2.70 +    size = lseek(fd, 0, SEEK_END);
    2.71 +    if (size < 0) {
    2.72 +        perror(path);
    2.73 +        close(fd);
    2.74 +        return NULL;
    2.75 +    }
    2.76 +    lseek(fd, 0, SEEK_SET);
    2.77 +
    2.78 +    img = malloc(size);
    2.79 +    if (img == NULL) {
    2.80 +        perror(path);
    2.81 +        close(fd);
    2.82 +        return NULL;
    2.83 +    }
    2.84 +
    2.85 +    size = read(fd, img, size);
    2.86 +    if (size <= 0) {
    2.87 +        perror(path);
    2.88 +        close(fd);
    2.89 +        free(img);
    2.90 +        return NULL;
    2.91 +    }
    2.92 +
    2.93 +    if (filesize)
    2.94 +        *filesize = size;
    2.95 +    close(fd);
    2.96 +    return img;
    2.97 +}
    2.98 +
    2.99 +static int init_boot_vcpu(
   2.100 +    int xc_handle,
   2.101 +    int domid,
   2.102 +    struct domain_setup_info *dsi,
   2.103 +    unsigned long dtb,
   2.104 +    unsigned long kaddr)
   2.105 +{
   2.106 +    vcpu_guest_context_t ctxt;
   2.107 +    int rc;
   2.108 +
   2.109 +    memset(&ctxt.user_regs, 0x55, sizeof(ctxt.user_regs));
   2.110 +    ctxt.user_regs.pc = dsi->v_kernentry;
   2.111 +    ctxt.user_regs.msr = 0;
   2.112 +    ctxt.user_regs.gprs[1] = 32<<20; /* XXX arbitrary stack address */
   2.113 +    ctxt.user_regs.gprs[3] = dtb;
   2.114 +    ctxt.user_regs.gprs[4] = kaddr;
   2.115 +    ctxt.user_regs.gprs[5] = 0;
   2.116 +
   2.117 +    VERBOSE(printf("xc_vcpu_setvcpucontext:\n"
   2.118 +                 "  pc 0x%"PRIx64", msr 0x016%"PRIx64"\n"
   2.119 +                 "  r1-5 %016"PRIx64" %016"PRIx64" %016"PRIx64" %016"PRIx64
   2.120 +                 " %016"PRIx64"\n",
   2.121 +                 ctxt.user_regs.pc, ctxt.user_regs.msr,
   2.122 +                 ctxt.user_regs.gprs[1],
   2.123 +                 ctxt.user_regs.gprs[2],
   2.124 +                 ctxt.user_regs.gprs[3],
   2.125 +                 ctxt.user_regs.gprs[4],
   2.126 +                 ctxt.user_regs.gprs[5]));
   2.127 +    rc = xc_vcpu_setcontext(xc_handle, domid, 0, &ctxt);
   2.128 +    if (rc < 0)
   2.129 +        perror("setdomaininfo");
   2.130 +
   2.131 +    return rc;
   2.132 +}
   2.133 +
   2.134 +static int install_image(
   2.135 +        int xc_handle,
   2.136 +        int domid,
   2.137 +        xen_pfn_t *page_array,
   2.138 +        void *image,
   2.139 +        unsigned long paddr,
   2.140 +        unsigned long size)
   2.141 +{
   2.142 +    uint8_t *img = image;
   2.143 +    int i;
   2.144 +    int rc = 0;
   2.145 +
   2.146 +    if (paddr & ~PAGE_MASK) {
   2.147 +        printf("*** unaligned address\n");
   2.148 +        return -1;
   2.149 +    }
   2.150 +
   2.151 +    for (i = 0; i < size; i += PAGE_SIZE) {
   2.152 +        void *page = img + i;
   2.153 +        xen_pfn_t pfn = (paddr + i) >> PAGE_SHIFT;
   2.154 +        xen_pfn_t mfn = page_array[pfn];
   2.155 +
   2.156 +        rc = xc_copy_to_domain_page(xc_handle, domid, mfn, page);
   2.157 +        if (rc < 0) {
   2.158 +            perror("xc_copy_to_domain_page");
   2.159 +            break;
   2.160 +        }
   2.161 +    }
   2.162 +    return rc;
   2.163 +}
   2.164 +
   2.165 +/* XXX be more flexible about placement in memory */
   2.166 +static int load_dtb(
   2.167 +    int xc_handle,
   2.168 +    int domid,
   2.169 +    const char *dtb_path,
   2.170 +    unsigned long dtb_addr,
   2.171 +    struct domain_setup_info *dsi,
   2.172 +    xen_pfn_t *page_array)
   2.173 +{
   2.174 +    uint8_t *img;
   2.175 +    unsigned long dtb_size;
   2.176 +    int rc = 0;
   2.177 +
   2.178 +    img = load_file(dtb_path, &dtb_size);
   2.179 +    if (img == NULL) {
   2.180 +        rc = -1;
   2.181 +        goto out;
   2.182 +    }
   2.183 +
   2.184 +    VERBOSE(printf("copying device tree to 0x%lx[0x%lx]\n",
   2.185 +            dtb_addr, dtb_size));
   2.186 +    rc = install_image(xc_handle, domid, page_array, img, dtb_addr, dtb_size);
   2.187 +
   2.188 +out:
   2.189 +    free(img);
   2.190 +    return rc;
   2.191 +}
   2.192 +
   2.193 +unsigned long spin_list[] = {
   2.194 +#if 0
   2.195 +    0x100,
   2.196 +    0x200,
   2.197 +    0x300,
   2.198 +    0x380,
   2.199 +    0x400,
   2.200 +    0x480,
   2.201 +    0x500,
   2.202 +    0x700,
   2.203 +    0x900,
   2.204 +    0xc00,
   2.205 +#endif
   2.206 +    0
   2.207 +};
   2.208 +
   2.209 +/* XXX yes, this is a hack */
   2.210 +static void hack_kernel_img(char *img)
   2.211 +{
   2.212 +    const off_t file_offset = 0x10000;
   2.213 +    unsigned long *addr = spin_list;
   2.214 +
   2.215 +    while (*addr) {
   2.216 +        uint32_t *instruction = (uint32_t *)(img + *addr + file_offset);
   2.217 +        printf("installing spin loop at %lx (%x)\n", *addr, *instruction);
   2.218 +        *instruction = 0x48000000;
   2.219 +        addr++;
   2.220 +    }
   2.221 +}
   2.222 +
   2.223 +static int load_kernel(
   2.224 +    int xc_handle,
   2.225 +    int domid,
   2.226 +    const char *kernel_path,
   2.227 +    struct domain_setup_info *dsi,
   2.228 +    xen_pfn_t *page_array)
   2.229 +{
   2.230 +    struct load_funcs load_funcs;
   2.231 +    char *kernel_img;
   2.232 +    unsigned long kernel_size;
   2.233 +    int rc;
   2.234 +
   2.235 +    /* load the kernel ELF file */
   2.236 +    kernel_img = load_file(kernel_path, &kernel_size);
   2.237 +    if (kernel_img == NULL) {
   2.238 +        rc = -1;
   2.239 +        goto out;
   2.240 +    }
   2.241 +
   2.242 +    hack_kernel_img(kernel_img);
   2.243 +
   2.244 +    VERBOSE(printf("probe_elf\n"));
   2.245 +    rc = probe_elf(kernel_img, kernel_size, &load_funcs);
   2.246 +    if (rc < 0) {
   2.247 +        rc = -1;
   2.248 +        printf("%s is not an ELF file\n", kernel_path);
   2.249 +        goto out;
   2.250 +    }
   2.251 +
   2.252 +    VERBOSE(printf("parseimage\n"));
   2.253 +    rc = (load_funcs.parseimage)(kernel_img, kernel_size, dsi);
   2.254 +    if (rc < 0) {
   2.255 +        rc = -1;
   2.256 +        goto out;
   2.257 +    }
   2.258 +
   2.259 +    VERBOSE(printf("loadimage\n"));
   2.260 +    (load_funcs.loadimage)(kernel_img, kernel_size, xc_handle, domid,
   2.261 +            page_array, dsi);
   2.262 +
   2.263 +    VERBOSE(printf("  v_start     %016"PRIx64"\n", dsi->v_start));
   2.264 +    VERBOSE(printf("  v_end       %016"PRIx64"\n", dsi->v_end));
   2.265 +    VERBOSE(printf("  v_kernstart %016"PRIx64"\n", dsi->v_kernstart));
   2.266 +    VERBOSE(printf("  v_kernend   %016"PRIx64"\n", dsi->v_kernend));
   2.267 +    VERBOSE(printf("  v_kernentry %016"PRIx64"\n", dsi->v_kernentry));
   2.268 +
   2.269 +out:
   2.270 +    free(kernel_img);
   2.271 +    return rc;
   2.272 +}
   2.273 +
   2.274 +static int load_initrd(
   2.275 +    int xc_handle,
   2.276 +    int domid,
   2.277 +    xen_pfn_t *page_array,
   2.278 +    const char *initrd_path,
   2.279 +    unsigned long *base,
   2.280 +    unsigned long *len)
   2.281 +{
   2.282 +    uint8_t *initrd_img;
   2.283 +    int rc = -1;
   2.284 +
   2.285 +    /* load the initrd file */
   2.286 +    initrd_img = load_file(initrd_path, len);
   2.287 +    if (initrd_img == NULL)
   2.288 +        return -1;
   2.289 +
   2.290 +    VERBOSE(printf("copying initrd to 0x%lx[0x%lx]\n", INITRD_ADDR, *len));
   2.291 +    if (install_image(xc_handle, domid, page_array, initrd_img, INITRD_ADDR,
   2.292 +                *len))
   2.293 +        goto out;
   2.294 +
   2.295 +    *base = INITRD_ADDR;
   2.296 +    rc = 0;
   2.297 +
   2.298 +out:
   2.299 +    free(initrd_img);
   2.300 +    return rc;
   2.301 +}
   2.302 +
   2.303 +static unsigned long create_start_info(start_info_t *si,
   2.304 +        unsigned int console_evtchn, unsigned int store_evtchn)
   2.305 +{
   2.306 +    unsigned long eomem;
   2.307 +    unsigned long si_addr;
   2.308 +
   2.309 +    memset(si, 0, sizeof(*si));
   2.310 +    snprintf(si->magic, sizeof(si->magic), "xen-%d.%d-powerpc64HV", 3, 0);
   2.311 +
   2.312 +    eomem = MEMSIZE;
   2.313 +    si->nr_pages = eomem >> PAGE_SHIFT;
   2.314 +    si->shared_info = eomem - (PAGE_SIZE * 1);
   2.315 +    si->store_mfn = si->nr_pages - 2;
   2.316 +    si->store_evtchn = store_evtchn;
   2.317 +    si->console_mfn = si->nr_pages - 3;
   2.318 +    si->console_evtchn = console_evtchn;
   2.319 +    si_addr = eomem - (PAGE_SIZE * 4);
   2.320 +
   2.321 +    return si_addr;
   2.322 +}
   2.323 +
   2.324 +static int get_page_array(int xc_handle, int domid, xen_pfn_t **page_array)
   2.325 +{
   2.326 +    int nr_pages;
   2.327 +    int rc;
   2.328 +
   2.329 +    VERBOSE(printf("xc_get_tot_pages\n"));
   2.330 +    nr_pages = xc_get_tot_pages(xc_handle, domid);
   2.331 +    VERBOSE(printf("  0x%x\n", nr_pages));
   2.332 +
   2.333 +    *page_array = malloc(nr_pages * sizeof(xen_pfn_t));
   2.334 +    if (*page_array == NULL) {
   2.335 +        perror("malloc");
   2.336 +        return -1;
   2.337 +    }
   2.338 +
   2.339 +    VERBOSE(printf("xc_get_pfn_list\n"));
   2.340 +    rc = xc_get_pfn_list(xc_handle, domid, *page_array, nr_pages);
   2.341 +    if (rc != nr_pages) {
   2.342 +        perror("Could not get the page frame list");
   2.343 +        return -1;
   2.344 +    }
   2.345 +
   2.346 +    return 0;
   2.347 +}
   2.348 +
   2.349 +int xc_linux_build(int xc_handle,
   2.350 +                   uint32_t domid,
   2.351 +                   const char *image_name,
   2.352 +                   const char *initrd_name,
   2.353 +                   const char *cmdline,
   2.354 +                   const char *features,
   2.355 +                   unsigned long flags,
   2.356 +                   unsigned int store_evtchn,
   2.357 +                   unsigned long *store_mfn,
   2.358 +                   unsigned int console_evtchn,
   2.359 +                   unsigned long *console_mfn)
   2.360 +{
   2.361 +    struct domain_setup_info dsi;
   2.362 +    xen_pfn_t *page_array = NULL;
   2.363 +    unsigned long kern_addr;
   2.364 +    unsigned long dtb_addr;
   2.365 +    unsigned long si_addr;
   2.366 +    unsigned long initrd_base = 0;
   2.367 +    unsigned long initrd_len = 0;
   2.368 +    start_info_t si;
   2.369 +    int rc = 0;
   2.370 +
   2.371 +    if (get_page_array(xc_handle, domid, &page_array)) {
   2.372 +        rc = -1;
   2.373 +        goto out;
   2.374 +    }
   2.375 +
   2.376 +    if (load_kernel(xc_handle, domid, image_name, &dsi, page_array)) {
   2.377 +        rc = -1;
   2.378 +        goto out;
   2.379 +    }
   2.380 +    kern_addr = 0;
   2.381 +
   2.382 +    if (initrd_name && initrd_name[0] != '\0' &&
   2.383 +        load_initrd(xc_handle, domid, page_array, initrd_name, &initrd_base,
   2.384 +                &initrd_len)) {
   2.385 +        rc = -1;
   2.386 +        goto out;
   2.387 +    }
   2.388 +    /* XXX install initrd addr/len into device tree */
   2.389 +
   2.390 +    dtb_addr = (16 << 20);
   2.391 +    if (load_dtb(xc_handle, domid, "DomU.dtb", dtb_addr, &dsi, page_array)) {
   2.392 +        dtb_addr = 0;
   2.393 +    }
   2.394 +
   2.395 +    si_addr = create_start_info(&si, store_evtchn, console_evtchn);
   2.396 +    *console_mfn = si.console_mfn;
   2.397 +    *store_mfn = si.store_mfn;
   2.398 +    if (install_image(xc_handle, domid, page_array, &si, si_addr,
   2.399 +                sizeof(start_info_t))) {
   2.400 +        rc = -1;
   2.401 +        goto out;
   2.402 +    }
   2.403 +
   2.404 +    if (init_boot_vcpu(xc_handle, domid, &dsi, dtb_addr, kern_addr)) {
   2.405 +        rc = -1;
   2.406 +        goto out;
   2.407 +    }
   2.408 +
   2.409 +out:
   2.410 +    return rc;
   2.411 +}

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/xen/arch/powerpc/0opt.c	Fri Jul 14 10:47:50 2006 +0100
     3.3 @@ -0,0 +1,28 @@
     3.4 +/*
     3.5 + * This program is free software; you can redistribute it and/or modify
     3.6 + * it under the terms of the GNU General Public License as published by
     3.7 + * the Free Software Foundation; either version 2 of the License, or
     3.8 + * (at your option) any later version.
     3.9 + *
    3.10 + * This program is distributed in the hope that it will be useful,
    3.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    3.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    3.13 + * GNU General Public License for more details.
    3.14 + *
    3.15 + * You should have received a copy of the GNU General Public License
    3.16 + * along with this program; if not, write to the Free Software
    3.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
    3.18 + *
    3.19 + * Copyright (C) IBM Corp. 2005
    3.20 + *
    3.21 + * Authors: Jimi Xenidis <jimix@watson.ibm.com>
    3.22 + */
    3.23 +
    3.24 +#include <xen/config.h>
    3.25 +#include <asm/misc.h>
    3.26 +
    3.27 +extern void __cmpxchg_called_with_bad_pointer(void);
    3.28 +void __cmpxchg_called_with_bad_pointer(void)
    3.29 +{
    3.30 +    trap();
    3.31 +}

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/xen/arch/powerpc/Makefile	Fri Jul 14 10:47:50 2006 +0100
     4.3 @@ -0,0 +1,117 @@
     4.4 +ifneq ($(DOM0_IMAGE),)
     4.5 +builtin_dom0 := y
     4.6 +endif
     4.7 +
     4.8 +subdir-$(HAS_PPC64) += powerpc64
     4.9 +subdir-y += papr
    4.10 +
    4.11 +obj-y += audit.o
    4.12 +obj-y += bitops.o
    4.13 +obj-y += boot_of.o
    4.14 +obj-y += dart.o
    4.15 +obj-y += dart_u3.o
    4.16 +obj-y += dart_u4.o
    4.17 +obj-y += delay.o
    4.18 +obj-y += dom0_ops.o
    4.19 +obj-y += domain_build.o
    4.20 +obj-y += domain.o
    4.21 +obj-y += exceptions.o
    4.22 +obj-y += external.o
    4.23 +obj-y += float.o
    4.24 +obj-y += hcalls.o
    4.25 +obj-y += htab.o
    4.26 +obj-y += iommu.o
    4.27 +obj-y += irq.o
    4.28 +obj-y += mambo.o
    4.29 +obj-y += mm.o
    4.30 +obj-y += mpic.o
    4.31 +obj-y += mpic_init.o
    4.32 +obj-y += of-devtree.o
    4.33 +obj-y += of-devwalk.o
    4.34 +obj-y += ofd_fixup.o
    4.35 +obj-y += physdev.o
    4.36 +obj-y += rtas.o
    4.37 +obj-y += setup.o
    4.38 +obj-y += smp.o
    4.39 +obj-y += time.o
    4.40 +obj-y += usercopy.o
    4.41 +
    4.42 +obj-$(debug) += 0opt.o
    4.43 +obj-$(crash_debug) += gdbstub.o
    4.44 +obj-$(builtin_dom0) += dom0.o
    4.45 +
    4.46 +obj-y += firmware_image.o
    4.47 +
    4.48 +obj-y += elf32.o
    4.49 +
    4.50 +# These are extra warnings like for the arch/ppc directory but may not
    4.51 +# allow the rest of the tree to build.
    4.52 +PPC_C_WARNINGS += -Wundef -Wmissing-prototypes -Wmissing-declarations
    4.53 +CFLAGS += $(PPC_C_WARNINGS)
    4.54 +
    4.55 +LINK=0x3000000
    4.56 +boot32_link_base = $(LINK)
    4.57 +xen_link_offset  = 100
    4.58 +xen_link_base    = $(patsubst %000,%$(xen_link_offset),$(LINK))
    4.59 +
    4.60 +#
    4.61 +# The following flags are fed to gcc in order to link several
    4.62 +# objects into a single ELF segment and to not link in any additional
    4.63 +# objects that gcc would normally like to
    4.64 +#
    4.65 +OMAGIC = -N -nodefaultlibs -nostartfiles
    4.66 +
    4.67 +firmware: of_handler/built_in.o $(TARGET_SUBARCH)/memcpy.o of-devtree.o
    4.68 +	$(CC) $(CFLAGS) $(OMAGIC) -e __ofh_start -Wl,-Ttext,0x0 $^ -o $@
    4.69 +
    4.70 +firmware_image: firmware
    4.71 +	$(CROSS_COMPILE)objcopy --output-target=binary $< $@
    4.72 +
    4.73 +firmware_image.o: firmware_image
    4.74 +	$(CROSS_COMPILE)objcopy --input-target=binary \
    4.75 +		--output-target=elf64-powerpc \
    4.76 +		--binary-architecture=powerpc \
    4.77 +		--redefine-sym _binary_$<_start=$(@:%.o=%)_start \
    4.78 +		--redefine-sym _binary_$<_end=$(@:%.o=%)_end \
    4.79 +		--redefine-sym _binary_$<_size=$(@:%.o=%)_size  $< $@
    4.80 +
    4.81 +#
    4.82 +# Hacks for included C files
    4.83 +#
    4.84 +irq.o: ../x86/irq.c
    4.85 +physdev.o: ../x86/physdev.c
    4.86 +
    4.87 +HDRS += $(wildcard *.h)
    4.88 +
    4.89 +start.o: boot/start.S
    4.90 +	$(CC) $(CFLAGS) -D__ASSEMBLY__ -c $< -o $@
    4.91 +
    4.92 +$(TARGET)-syms: start.o $(ALL_OBJS) xen.lds
    4.93 +	$(CC) $(CFLAGS) $(OMAGIC) -Wl,-Ttext,$(xen_link_base),-T,xen.lds start.o $(ALL_OBJS) -o $@
    4.94 +
    4.95 +$(TARGET).bin: $(TARGET)-syms
    4.96 +	$(CROSS_COMPILE)objcopy --output-target=binary $< $@
    4.97 +
    4.98 +$(TARGET).bin.o: $(TARGET).bin
    4.99 +	$(CROSS_COMPILE)objcopy --input-target=binary \
   4.100 +		--output-target=elf32-powerpc \
   4.101 +		--binary-architecture=powerpc  $< $@
   4.102 +
   4.103 +boot32.o: boot/boot32.S
   4.104 +	$(CC) -m32 -Wa,-a32,-mppc64bridge \
   4.105 +		-D__ASSEMBLY__ -D__BRIDGE64__ $(CFLAGS) -c $< -o $@
   4.106 +
   4.107 +$(TARGET): boot32.o $(TARGET).bin.o
   4.108 +	$(CC) -m32 -N -Wl,-melf32ppclinux -static -nostdlib \
   4.109 +		-Wl,-Ttext,$(boot32_link_base)  -Wl,-Tdata,$(xen_link_base) \
   4.110 +		$(CFLAGS) $^ -o $@
   4.111 +
   4.112 +asm-offsets.s: $(TARGET_SUBARCH)/asm-offsets.c $(HDRS)
   4.113 +	$(CC) $(CFLAGS) -S -o $@ $<
   4.114 +
   4.115 +dom0.bin: $(DOM0_IMAGE)
   4.116 +	cp $< $@
   4.117 +
   4.118 +clean::
   4.119 +	$(MAKE) -f $(BASEDIR)/Rules.mk -C of_handler clean
   4.120 +	rm -f firmware firmware_image dom0.bin

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/xen/arch/powerpc/Rules.mk	Fri Jul 14 10:47:50 2006 +0100
     5.3 @@ -0,0 +1,51 @@
     5.4 +HAS_PPC64 := y
     5.5 +
     5.6 +CC := $(CROSS_COMPILE)gcc
     5.7 +LD := $(CROSS_COMPILE)ld
     5.8 +
     5.9 +# These are goodess that applies to all source.
    5.10 +C_WARNINGS := -Wpointer-arith -Wredundant-decls
    5.11 +
    5.12 +# _no_ common code can have packed data structures or we are in touble.
    5.13 +C_WARNINGS += -Wpacked
    5.14 +
    5.15 +CFLAGS := -m64 -ffreestanding -fno-builtin -fno-common -fno-strict-aliasing
    5.16 +CFLAGS += -iwithprefix include -Wall -Werror -pipe
    5.17 +CFLAGS += -I$(BASEDIR)/include
    5.18 +CFLAGS += -I$(BASEDIR)/include/asm-powerpc/mach-generic
    5.19 +CFLAGS += -I$(BASEDIR)/include/asm-powerpc/mach-default
    5.20 +CFLAGS += $(C_WARNINGS)
    5.21 +CFLAGS += -msoft-float -O2
    5.22 +CFLAGS-$(debug) += -O0 # last one wins
    5.23 +CFLAGS-$(papr_vterm) += -DPAPR_VDEVICE -DPAPR_VTERM
    5.24 +
    5.25 +LDFLAGS += -m elf64ppc
    5.26 +
    5.27 +#
    5.28 +# command to embed a binary inside a .o
    5.29 +#
    5.30 +%.o: %.bin
    5.31 +	$(CROSS_COMPILE)objcopy --input-target=binary \
    5.32 +		--output-target=elf64-powerpc \
    5.33 +		--binary-architecture=powerpc \
    5.34 +		--redefine-sym _binary_$*_bin_start=$*_start \
    5.35 +		--redefine-sym _binary_$*_bin_end=$*_end \
    5.36 +		--redefine-sym _binary_$*_bin_size=$*_size \
    5.37 +		$< $@
    5.38 +
    5.39 +# Test for at least GCC v3.2.x.
    5.40 +gcc-ver = $(shell $(CC) -dumpversion | sed -e 's/^\(.\)\.\(.\)\.\(.\)/\$(1)/')
    5.41 +ifeq ($(call gcc-ver,1),1)
    5.42 +$(error gcc-1.x.x unsupported - upgrade to at least gcc-3.2.x)
    5.43 +endif
    5.44 +ifeq ($(call gcc-ver,1),2)
    5.45 +$(error gcc-2.x.x unsupported - upgrade to at least gcc-3.2.x)
    5.46 +endif
    5.47 +ifeq ($(call gcc-ver,1),3)
    5.48 +ifeq ($(call gcc-ver,2),0)
    5.49 +$(error gcc-3.0.x unsupported - upgrade to at least gcc-3.2.x)
    5.50 +endif
    5.51 +ifeq ($(call gcc-ver,2),1)
    5.52 +$(error gcc-3.1.x unsupported - upgrade to at least gcc-3.2.x)
    5.53 +endif
    5.54 +endif

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/xen/arch/powerpc/audit.c	Fri Jul 14 10:47:50 2006 +0100
     6.3 @@ -0,0 +1,45 @@
     6.4 +/*
     6.5 + * This program is free software; you can redistribute it and/or modify
     6.6 + * it under the terms of the GNU General Public License as published by
     6.7 + * the Free Software Foundation; either version 2 of the License, or
     6.8 + * (at your option) any later version.
     6.9 + *
    6.10 + * This program is distributed in the hope that it will be useful,
    6.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    6.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    6.13 + * GNU General Public License for more details.
    6.14 + *
    6.15 + * You should have received a copy of the GNU General Public License
    6.16 + * along with this program; if not, write to the Free Software
    6.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
    6.18 + *
    6.19 + * Copyright (C) IBM Corp. 2005
    6.20 + *
    6.21 + * Authors: Hollis Blanchard <hollisb@us.ibm.com>
    6.22 + */
    6.23 +
    6.24 +#ifndef NDEBUG
    6.25 +#include <xen/lib.h>
    6.26 +#include <xen/sched.h>
    6.27 +
    6.28 +extern void audit_domain(struct domain *d);
    6.29 +extern void audit_domains(void);
    6.30 +extern void audit_domains_key(unsigned char key);
    6.31 +
    6.32 +void audit_domain(struct domain *d)
    6.33 +{
    6.34 +    panic("%s unimplemented\n", __func__);
    6.35 +}
    6.36 +
    6.37 +void audit_domains(void)
    6.38 +{
    6.39 +    struct domain *d;
    6.40 +    for_each_domain ( d )
    6.41 +        audit_domain(d);
    6.42 +}
    6.43 +
    6.44 +void audit_domains_key(unsigned char key)
    6.45 +{
    6.46 +    audit_domains();
    6.47 +}
    6.48 +#endif

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/xen/arch/powerpc/bitops.c	Fri Jul 14 10:47:50 2006 +0100
     7.3 @@ -0,0 +1,94 @@
     7.4 +/* from linux/arch/powerpc/lib/bitops.c */
     7.5 +
     7.6 +#include <asm/types.h>
     7.7 +#include <asm/bitops.h>
     7.8 +
     7.9 +#define BITOP_WORD(nr)      ((nr) / BITS_PER_LONG)
    7.10 +
    7.11 +/**
    7.12 + * find_next_bit - find the next set bit in a memory region
    7.13 + * @addr: The address to base the search on
    7.14 + * @offset: The bitnumber to start searching at
    7.15 + * @size: The maximum size to search
    7.16 + */
    7.17 +unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
    7.18 +			    unsigned long offset)
    7.19 +{
    7.20 +	const unsigned long *p = addr + BITOP_WORD(offset);
    7.21 +	unsigned long result = offset & ~(BITS_PER_LONG-1);
    7.22 +	unsigned long tmp;
    7.23 +
    7.24 +	if (offset >= size)
    7.25 +		return size;
    7.26 +	size -= result;
    7.27 +	offset %= BITS_PER_LONG;
    7.28 +	if (offset) {
    7.29 +		tmp = *(p++);
    7.30 +		tmp &= (~0UL << offset);
    7.31 +		if (size < BITS_PER_LONG)
    7.32 +			goto found_first;
    7.33 +		if (tmp)
    7.34 +			goto found_middle;
    7.35 +		size -= BITS_PER_LONG;
    7.36 +		result += BITS_PER_LONG;
    7.37 +	}
    7.38 +	while (size & ~(BITS_PER_LONG-1)) {
    7.39 +		if ((tmp = *(p++)))
    7.40 +			goto found_middle;
    7.41 +		result += BITS_PER_LONG;
    7.42 +		size -= BITS_PER_LONG;
    7.43 +	}
    7.44 +	if (!size)
    7.45 +		return result;
    7.46 +	tmp = *p;
    7.47 +
    7.48 +found_first:
    7.49 +	tmp &= (~0UL >> (BITS_PER_LONG - size));
    7.50 +	if (tmp == 0UL)		/* Are any bits set? */
    7.51 +		return result + size;	/* Nope. */
    7.52 +found_middle:
    7.53 +	return result + __ffs(tmp);
    7.54 +}
    7.55 +
    7.56 +/*
    7.57 + * This implementation of find_{first,next}_zero_bit was stolen from
    7.58 + * Linus' asm-alpha/bitops.h.
    7.59 + */
    7.60 +unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
    7.61 +				 unsigned long offset)
    7.62 +{
    7.63 +	const unsigned long *p = addr + BITOP_WORD(offset);
    7.64 +	unsigned long result = offset & ~(BITS_PER_LONG-1);
    7.65 +	unsigned long tmp;
    7.66 +
    7.67 +	if (offset >= size)
    7.68 +		return size;
    7.69 +	size -= result;
    7.70 +	offset %= BITS_PER_LONG;
    7.71 +	if (offset) {
    7.72 +		tmp = *(p++);
    7.73 +		tmp |= ~0UL >> (BITS_PER_LONG - offset);
    7.74 +		if (size < BITS_PER_LONG)
    7.75 +			goto found_first;
    7.76 +		if (~tmp)
    7.77 +			goto found_middle;
    7.78 +		size -= BITS_PER_LONG;
    7.79 +		result += BITS_PER_LONG;
    7.80 +	}
    7.81 +	while (size & ~(BITS_PER_LONG-1)) {
    7.82 +		if (~(tmp = *(p++)))
    7.83 +			goto found_middle;
    7.84 +		result += BITS_PER_LONG;
    7.85 +		size -= BITS_PER_LONG;
    7.86 +	}
    7.87 +	if (!size)
    7.88 +		return result;
    7.89 +	tmp = *p;
    7.90 +
    7.91 +found_first:
    7.92 +	tmp |= ~0UL << size;
    7.93 +	if (tmp == ~0UL)	/* Are any bits zero? */
    7.94 +		return result + size;	/* Nope. */
    7.95 +found_middle:
    7.96 +	return result + ffz(tmp);
    7.97 +}

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/xen/arch/powerpc/boot/boot32.S	Fri Jul 14 10:47:50 2006 +0100
     8.3 @@ -0,0 +1,75 @@
     8.4 +/*
     8.5 + * Copyright (C) 2005 Jimi Xenidis <jimix@watson.ibm.com>, IBM Corporation
     8.6 + *
     8.7 + * This program is free software; you can redistribute it and/or modify
     8.8 + * it under the terms of the GNU General Public License as published by
     8.9 + * the Free Software Foundation; either version 2 of the License, or
    8.10 + * (at your option) any later version.
    8.11 + * 
    8.12 + * This program is distributed in the hope that it will be useful,
    8.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    8.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    8.15 + * GNU General Public License for more details.
    8.16 + * 
    8.17 + * You should have received a copy of the GNU General Public License
    8.18 + * along with this program; if not, write to the Free Software
    8.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
    8.20 + *
    8.21 + */
    8.22 +	
    8.23 +### 32 bit strapping code so Of will like us
    8.24 +	.section	".text"
    8.25 +	.align 3
    8.26 +	.globl _start
    8.27 +		
    8.28 +_start:
    8.29 +	## Double word align the MSR value below
    8.30 +	nop
    8.31 +	bl _real_start
    8.32 +	## static value for MSR
    8.33 +	.llong 0x9000000000001000
    8.34 +
    8.35 +	## see also docs/reference/ppc/msr.txt
    8.36 +##bit C  Hex               Name Desc
    8.37 +##  0 63 80000000 00000000 SF   64-bit Mode
    8.38 +##  3 60 10000000 00000000 HV   Hypervisor State iff PR = 0 in hypervisor state.
    8.39 +## 51 12 00000000 00001000 ME   Machine Check Enable
    8.40 +
    8.41 +_real_start:		
    8.42 +	# pass the original msr as argument to hype_init
    8.43 +	mfmsr   8
    8.44 +
    8.45 +	## Set PC
    8.46 +	li	21, 0
    8.47 +	oris	21, 21, _hype64@h
    8.48 +	ori	21, 21, _hype64@l
    8.49 +#ifdef __BRIDGE64__
    8.50 +	## In 64bit we use rfid to switch from 32bit to 64 bit
    8.51 +	mtsrr0	21
    8.52 +
    8.53 +	## Set MSR
    8.54 +	mflr	21
    8.55 +	ld	22, 0(21)
    8.56 +	mtsrr1	22
    8.57 +	bl __leap
    8.58 +	/* should never return */
    8.59 +	trap
    8.60 +__leap:		
    8.61 +	rfid
    8.62 +#else
    8.63 +	mtctr 21
    8.64 +	bctrl
    8.65 +	/* should never return */
    8.66 +	trap
    8.67 +#endif
    8.68 +
    8.69 +	
    8.70 +_real_end:
    8.71 +	.data
    8.72 +	.align 3
    8.73 +	## Hypervisor starts here, at the first data address
    8.74 +	## linker magic positions _hype64 0x100 after _start
    8.75 +	## hype/ppc64/Makefile.isa 
    8.76 +_hype64:		
    8.77 +
    8.78 +

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/xen/arch/powerpc/boot/start.S	Fri Jul 14 10:47:50 2006 +0100
     9.3 @@ -0,0 +1,51 @@
     9.4 +/*
     9.5 + * Copyright (C) 2005 Jimi Xenidis <jimix@watson.ibm.com>, IBM Corporation
     9.6 + *
     9.7 + * This program is free software; you can redistribute it and/or modify
     9.8 + * it under the terms of the GNU General Public License as published by
     9.9 + * the Free Software Foundation; either version 2 of the License, or
    9.10 + * (at your option) any later version.
    9.11 + * 
    9.12 + * This program is distributed in the hope that it will be useful,
    9.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    9.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    9.15 + * GNU General Public License for more details.
    9.16 + * 
    9.17 + * You should have received a copy of the GNU General Public License
    9.18 + * along with this program; if not, write to the Free Software
    9.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
    9.20 + *
    9.21 + */
    9.22 +
    9.23 +#include <asm/config.h>
    9.24 +#include <asm/processor.h>
    9.25 +#include <asm/page.h>
    9.26 +
    9.27 +    .globl _start
    9.28 +_start:
    9.29 +    /* load up the stack */
    9.30 +    SET_REG_TO_LABEL(r1, cpu0_stack)
    9.31 +
    9.32 +    /* call the init function */
    9.33 +    LOADADDR(r21,__start_xen_ppc)
    9.34 +
    9.35 +#ifdef __PPC64__
    9.36 +    ld r2, 8(r21)
    9.37 +    ld r21, 0(r21)
    9.38 +#endif
    9.39 +    mtctr r21
    9.40 +    bctrl
    9.41 +    /* should never return */
    9.42 +    trap
    9.43 +
    9.44 +    /* Note! GDB 6.3 makes the very stupid assumption that PC > SP means we are
    9.45 +     * in a Linux signal trampoline, and it begins groping for a struct
    9.46 +     * rt_sigframe on the stack. Naturally, this fails miserably for our
    9.47 +     * backtrace. To work around this behavior, we must make certain that our
    9.48 +     * stack is always above our text, e.g. in the data section. */
    9.49 +    .data /* DO NOT REMOVE; see GDB note above */
    9.50 +    .align 4
    9.51 +cpu0_stack_bottom:
    9.52 +    .space STACK_SIZE
    9.53 +cpu0_stack:
    9.54 +    .space STACK_FRAME_OVERHEAD

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/xen/arch/powerpc/boot_of.c	Fri Jul 14 10:47:50 2006 +0100
    10.3 @@ -0,0 +1,1016 @@
    10.4 +/*
    10.5 + * This program is free software; you can redistribute it and/or modify
    10.6 + * it under the terms of the GNU General Public License as published by
    10.7 + * the Free Software Foundation; either version 2 of the License, or
    10.8 + * (at your option) any later version.
    10.9 + *
   10.10 + * This program is distributed in the hope that it will be useful,
   10.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   10.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   10.13 + * GNU General Public License for more details.
   10.14 + *
   10.15 + * You should have received a copy of the GNU General Public License
   10.16 + * along with this program; if not, write to the Free Software
   10.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   10.18 + *
   10.19 + * Copyright (C) IBM Corp. 2005
   10.20 + *
   10.21 + * Authors: Jimi Xenidis <jimix@watson.ibm.com>
   10.22 + */
   10.23 +
   10.24 +#include <xen/config.h>
   10.25 +#include <xen/init.h>
   10.26 +#include <xen/lib.h>
   10.27 +#include <xen/multiboot.h>
   10.28 +#include <xen/compile.h>
   10.29 +#include <xen/spinlock.h>
   10.30 +#include <xen/serial.h>
   10.31 +#include <xen/time.h>
   10.32 +#include <asm/page.h>
   10.33 +#include <asm/io.h>
   10.34 +#include "exceptions.h"
   10.35 +#include "of-devtree.h"
   10.36 +
   10.37 +static ulong of_vec;
   10.38 +static ulong of_msr;
   10.39 +static int of_out;
   10.40 +static ofdn_t boot_cpu;
   10.41 +static char bootargs[256];
   10.42 +
   10.43 +extern struct ns16550_defaults ns16550;
   10.44 +
   10.45 +#undef OF_DEBUG
   10.46 +
   10.47 +#ifdef OF_DEBUG
   10.48 +#define DBG(args...) of_printf(args)
   10.49 +#else
   10.50 +#define DBG(args...)
   10.51 +#endif
   10.52 +
   10.53 +#define of_panic(MSG...) \
   10.54 +    do { of_printf(MSG); of_printf("\nHANG\n"); for (;;); } while (0)
   10.55 +
   10.56 +struct of_service {
   10.57 +    u32 ofs_service;
   10.58 +    u32 ofs_nargs;
   10.59 +    u32 ofs_nrets;
   10.60 +    u32 ofs_args[10];
   10.61 +};
   10.62 +
   10.63 +static int bof_chosen;
   10.64 +
   10.65 +static struct of_service s;
   10.66 +extern s32 prom_call(void *arg, ulong rtas_base, ulong func, ulong msr);
   10.67 +
   10.68 +static int __init of_call(
   10.69 +    const char *service, u32 nargs, u32 nrets, s32 rets[], ...)
   10.70 +{
   10.71 +    int rc;
   10.72 +
   10.73 +    if (of_vec != 0) {
   10.74 +        va_list args;
   10.75 +        int i;
   10.76 +
   10.77 +        memset(&s, 0, sizeof (s));
   10.78 +        s.ofs_service = (ulong)service;
   10.79 +        s.ofs_nargs = nargs;
   10.80 +        s.ofs_nrets = nrets;
   10.81 +        s.ofs_nargs = nargs;
   10.82 +
   10.83 +        /* copy all the params into the args array */
   10.84 +        va_start(args, rets);
   10.85 +
   10.86 +        for (i = 0; i < nargs; i++) {
   10.87 +            s.ofs_args[i] = va_arg(args, u32);
   10.88 +        }
   10.89 +
   10.90 +        va_end(args);
   10.91 +
   10.92 +        rc = prom_call(&s, 0, of_vec, of_msr);
   10.93 +
   10.94 +        /* yes always to the copy, just in case */
   10.95 +        for (i = 0; i < nrets; i++) {
   10.96 +            rets[i] = s.ofs_args[i + nargs];
   10.97 +        }
   10.98 +    } else {
   10.99 +        rc = OF_FAILURE;
  10.100 +    }
  10.101 +    return rc;
  10.102 +}
  10.103 +
  10.104 +/* popular OF methods */
  10.105 +static int __init _of_write(int ih, const char *addr, u32 len)
  10.106 +{
  10.107 +    int rets[1] = { OF_FAILURE };
  10.108 +    if (of_call("write", 3, 1, rets, ih, addr, len) == OF_FAILURE) {
  10.109 +        return OF_FAILURE;
  10.110 +    }
  10.111 +    return rets[0];
  10.112 +}
  10.113 +
  10.114 +/* popular OF methods */
  10.115 +static int __init of_write(int ih, const char *addr, u32 len)
  10.116 +{
  10.117 +    int rc;
  10.118 +    int i = 0;
  10.119 +    int sum = 0;
  10.120 +
  10.121 +    while (i < len) {
  10.122 +        if (addr[i] == '\n') {
  10.123 +            if (i > 0) {
  10.124 +                rc = _of_write(ih, addr, i);
  10.125 +                if (rc == OF_FAILURE)
  10.126 +                    return rc;
  10.127 +                sum += rc;
  10.128 +            }
  10.129 +            rc = _of_write(ih, "\r\n", 2);
  10.130 +            if (rc == OF_FAILURE)
  10.131 +                return rc;
  10.132 +            sum += rc;
  10.133 +            i++;
  10.134 +            addr += i;
  10.135 +            len -= i;
  10.136 +            i = 0;
  10.137 +            continue;
  10.138 +        }
  10.139 +        i++;
  10.140 +    }
  10.141 +    if (len > 0) {
  10.142 +        rc = _of_write(ih, addr, len);
  10.143 +        if (rc == OF_FAILURE)
  10.144 +            return rc;
  10.145 +        sum += rc;
  10.146 +    }
  10.147 +            
  10.148 +    return sum;
  10.149 +}
  10.150 +
  10.151 +static int of_printf(const char *fmt, ...)
  10.152 +    __attribute__ ((format (printf, 1, 2)));
  10.153 +static int __init of_printf(const char *fmt, ...)
  10.154 +{
  10.155 +    static char buf[1024];
  10.156 +    va_list args;
  10.157 +    int sz;
  10.158 +
  10.159 +    if (of_out == 0) {
  10.160 +        return OF_FAILURE;
  10.161 +    }
  10.162 +
  10.163 +    va_start(args, fmt);
  10.164 +
  10.165 +    sz = vsnprintf(buf, sizeof (buf), fmt, args);
  10.166 +    if (sz <= sizeof (buf)) {
  10.167 +        of_write(of_out, buf, sz);
  10.168 +    } else {
  10.169 +        static const char trunc[] = "\n(TRUNCATED)\n";
  10.170 +
  10.171 +        sz = sizeof (buf);
  10.172 +        of_write(of_out, buf, sz);
  10.173 +        of_write(of_out, trunc, sizeof (trunc));
  10.174 +    }
  10.175 +    return sz;
  10.176 +}
  10.177 +
  10.178 +static int __init of_finddevice(const char *devspec)
  10.179 +{
  10.180 +    int rets[1] = { OF_FAILURE };
  10.181 +
  10.182 +    of_call("finddevice", 1, 1, rets, devspec);
  10.183 +    if (rets[0] == OF_FAILURE) {
  10.184 +        DBG("finddevice %s -> FAILURE %d\n",devspec,rets[0]);
  10.185 +        return OF_FAILURE;
  10.186 +    }
  10.187 +    DBG("finddevice %s -> %d\n",devspec, rets[0]);
  10.188 +    return rets[0];
  10.189 +}
  10.190 +
  10.191 +static int __init of_getprop(int ph, const char *name, void *buf, u32 buflen)
  10.192 +{
  10.193 +    int rets[1] = { OF_FAILURE };
  10.194 +
  10.195 +    of_call("getprop", 4, 1, rets, ph, name, buf, buflen);
  10.196 +
  10.197 +    if (rets[0] == OF_FAILURE) {
  10.198 +        DBG("getprop 0x%x %s -> FAILURE\n", ph, name);
  10.199 +        return OF_FAILURE;
  10.200 +    }
  10.201 +
  10.202 +    DBG("getprop 0x%x %s -> 0x%x (%s)\n", ph, name, rets[0], (char *)buf);
  10.203 +    return rets[0];
  10.204 +}
  10.205 +
  10.206 +static int __init of_setprop(
  10.207 +    int ph, const char *name, const void *buf, u32 buflen)
  10.208 +{
  10.209 +    int rets[1] = { OF_FAILURE };
  10.210 +
  10.211 +    of_call("setprop", 4, 1, rets, ph, name, buf, buflen);
  10.212 +
  10.213 +    if (rets[0] == OF_FAILURE) {
  10.214 +        DBG("setprop 0x%x %s -> FAILURE\n", ph, name);
  10.215 +        return OF_FAILURE;
  10.216 +    }
  10.217 +
  10.218 +    DBG("setprop 0x%x %s -> %s\n", ph, name, (char *)buf);
  10.219 +    return rets[0];
  10.220 +}
  10.221 +
  10.222 +/*
  10.223 + * returns 0 if there are no children (of spec)
  10.224 + */
  10.225 +static int __init of_getchild(int ph)
  10.226 +{
  10.227 +    int rets[1] = { OF_FAILURE };
  10.228 +
  10.229 +    of_call("child", 1, 1, rets, ph);
  10.230 +    DBG("getchild 0x%x -> 0x%x\n", ph, rets[0]);
  10.231 +
  10.232 +    return rets[0];
  10.233 +}
  10.234 +
  10.235 +/*
  10.236 + * returns 0 is there are no peers
  10.237 + */
  10.238 +static int __init of_getpeer(int ph)
  10.239 +{
  10.240 +    int rets[1] = { OF_FAILURE };
  10.241 +
  10.242 +    of_call("peer", 1, 1, rets, ph);
  10.243 +    DBG("getpeer 0x%x -> 0x%x\n", ph, rets[0]);
  10.244 +
  10.245 +    return rets[0];
  10.246 +}
  10.247 +
  10.248 +static int __init of_getproplen(int ph, const char *name)
  10.249 +{
  10.250 +    int rets[1] = { OF_FAILURE };
  10.251 +
  10.252 +    of_call("getproplen", 2, 1, rets, ph, name);
  10.253 +    if (rets[0] == OF_FAILURE) {
  10.254 +        DBG("getproplen 0x%x %s -> FAILURE\n", ph, name);
  10.255 +        return OF_FAILURE;
  10.256 +    }
  10.257 +    DBG("getproplen 0x%x %s -> 0x%x\n", ph, name, rets[0]);
  10.258 +    return rets[0];
  10.259 +}
  10.260 +
  10.261 +static int __init of_package_to_path(int ph, char *buffer, u32 buflen)
  10.262 +{
  10.263 +    int rets[1] = { OF_FAILURE };
  10.264 +
  10.265 +    of_call("package-to-path", 3, 1, rets, ph, buffer, buflen);
  10.266 +    if (rets[0] == OF_FAILURE) {
  10.267 +        DBG("%s 0x%x -> FAILURE\n", __func__, ph);
  10.268 +        return OF_FAILURE;
  10.269 +    }
  10.270 +    DBG("%s 0x%x %s -> 0x%x\n", __func__, ph, buffer, rets[0]);
  10.271 +    if (rets[0] <= buflen)
  10.272 +        buffer[rets[0]] = '\0';
  10.273 +    return rets[0];
  10.274 +}
  10.275 +
  10.276 +static int __init of_nextprop(int ph, const char *name, void *buf)
  10.277 +{
  10.278 +    int rets[1] = { OF_FAILURE };
  10.279 +
  10.280 +    of_call("nextprop", 3, 1, rets, ph, name, buf);
  10.281 +
  10.282 +    if (rets[0] == OF_FAILURE) {
  10.283 +        DBG("nextprop 0x%x %s -> FAILURE\n", ph, name);
  10.284 +        return OF_FAILURE;
  10.285 +    }
  10.286 +
  10.287 +    DBG("nextprop 0x%x %s -> %s\n", ph, name, (char *)buf);
  10.288 +    return rets[0];
  10.289 +}
  10.290 +
  10.291 +static int __init of_instance_to_path(int ih, char *buffer, u32 buflen)
  10.292 +{
  10.293 +    int rets[1] = { OF_FAILURE };
  10.294 +
  10.295 +    if (of_call("instance-to-path", 3, 1, rets, ih, buffer, buflen)
  10.296 +         == OF_FAILURE)
  10.297 +        return OF_FAILURE;
  10.298 +
  10.299 +    if (rets[0] <= buflen)
  10.300 +        buffer[rets[0]] = '\0';
  10.301 +    return rets[0];
  10.302 +}
  10.303 +
  10.304 +static int __init of_start_cpu(int cpu, u32 pc, u32 reg)
  10.305 +{
  10.306 +    int rets[1] = { OF_FAILURE };
  10.307 +
  10.308 +    if ( of_call("start-cpu", 3, 0, rets, cpu, pc, reg) == OF_FAILURE )
  10.309 +        return OF_FAILURE;
  10.310 +
  10.311 +    return rets[0];
  10.312 +}
  10.313 +
  10.314 +static void __init of_test(const char *of_method_name)
  10.315 +{
  10.316 +    int rets[1] = { OF_FAILURE };
  10.317 +    
  10.318 +    of_call("test", 1, 1, rets, of_method_name);
  10.319 +    if (rets[0] == OF_FAILURE ) {
  10.320 +        of_printf("Warning: possibly no OF method %s.\n"
  10.321 +                  "(Ignore this warning on PIBS.)\n", of_method_name);
  10.322 +    }
  10.323 +}
  10.324 +
  10.325 +static int __init of_claim(void * virt, u32 size)
  10.326 +{
  10.327 +    int rets[1] = { OF_FAILURE };
  10.328 +    
  10.329 +    of_call("claim", 3, 1, rets, virt, size, 0/*align*/);
  10.330 +    if (rets[0] == OF_FAILURE) {
  10.331 +        DBG("%s 0x%p 0x%08x -> FAIL\n", __func__, virt, size);
  10.332 +        return OF_FAILURE;
  10.333 +    }
  10.334 +
  10.335 +    DBG("%s 0x%p 0x%08x -> 0x%x\n", __func__, virt, size, rets[0]);
  10.336 +    return rets[0];
  10.337 +}
  10.338 +
  10.339 +static int __init of_instance_to_package(int ih)
  10.340 +{
  10.341 +    int rets[1] = { OF_FAILURE };
  10.342 +
  10.343 +    of_call("instance-to-package", 1, 1, rets, ih);
  10.344 +    if (rets[0] == OF_FAILURE)
  10.345 +        return OF_FAILURE;
  10.346 +
  10.347 +    return rets[0];
  10.348 +}
  10.349 +
  10.350 +static int __init of_getparent(int ph)
  10.351 +{
  10.352 +    int rets[1] = { OF_FAILURE };
  10.353 +
  10.354 +    of_call("parent", 1, 1, rets, ph);
  10.355 +
  10.356 +    DBG("getparent 0x%x -> 0x%x\n", ph, rets[0]);
  10.357 +    return rets[0];
  10.358 +}
  10.359 +
  10.360 +static void boot_of_probemem(multiboot_info_t *mbi)
  10.361 +{
  10.362 +    int root;
  10.363 +    int p;
  10.364 +    u32 addr_cells = 1;
  10.365 +    u32 size_cells = 1;
  10.366 +    int rc;
  10.367 +    int mcount = 0;
  10.368 +    static memory_map_t mmap[16];
  10.369 +
  10.370 +    root = of_finddevice("/");
  10.371 +    p = of_getchild(root);
  10.372 +
  10.373 +    /* code is writen to assume sizes of 1 */
  10.374 +    of_getprop(root, "#address-cells", &addr_cells, sizeof (addr_cells));
  10.375 +    of_getprop(root, "#size-cells", &size_cells, sizeof (size_cells));
  10.376 +    DBG("%s: address_cells=%d  size_cells=%d\n",
  10.377 +                    __func__, addr_cells, size_cells);
  10.378 +    
  10.379 +    do {
  10.380 +        const char memory[] = "memory";
  10.381 +        char type[32];
  10.382 +
  10.383 +        type[0] = '\0';
  10.384 +
  10.385 +        of_getprop(p, "device_type", type, sizeof (type));
  10.386 +        if (strncmp(type, memory, sizeof (memory)) == 0) {
  10.387 +            u32 reg[48];  
  10.388 +            u32 al, ah, ll, lh;
  10.389 +            int r;
  10.390 +
  10.391 +            rc = of_getprop(p, "reg", reg, sizeof (reg));
  10.392 +            if (rc == OF_FAILURE) {
  10.393 +                of_panic("no reg property for memory node: 0x%x.\n", p);
  10.394 +            }
  10.395 +            int l = rc/sizeof(u32); /* number reg element */
  10.396 +            DBG("%s: number of bytes in property 'reg' %d\n",
  10.397 +                            __func__, rc);
  10.398 +            
  10.399 +            r = 0;
  10.400 +            while (r < l) {
  10.401 +                al = ah = ll = lh = 0;
  10.402 +                if (addr_cells == 2) {
  10.403 +                    ah = reg[r++];
  10.404 +                    if (r >= l)
  10.405 +                        break;  /* partial line.  Skip  */
  10.406 +                    al = reg[r++];
  10.407 +                    if (r >= l)
  10.408 +                        break;  /* partial line.  Skip */
  10.409 +                } else {
  10.410 +                    al = reg[r++];
  10.411 +                    if (r >= l)
  10.412 +                        break;  /* partial line.  Skip */
  10.413 +                }
  10.414 +                if (size_cells == 2) {
  10.415 +                    lh = reg[r++];
  10.416 +                    if (r >= l)
  10.417 +                        break;  /* partial line.  Skip */
  10.418 +                    ll = reg[r++];
  10.419 +                } else {
  10.420 +                    ll = reg[r++];
  10.421 +                }
  10.422 +
  10.423 +                if ((ll != 0) || (lh != 0)) {
  10.424 +                    mmap[mcount].size = 20; /* - size field */
  10.425 +                    mmap[mcount].type = 1; /* Regular ram */
  10.426 +                    mmap[mcount].length_high = lh;
  10.427 +                    mmap[mcount].length_low = ll;
  10.428 +                    mmap[mcount].base_addr_high = ah;
  10.429 +                    mmap[mcount].base_addr_low = al;
  10.430 +                    of_printf("%s: memory 0x%016lx[0x%08lx]\n",
  10.431 +                      __func__,
  10.432 +                      (u64)(((u64)mmap[mcount].base_addr_high << 32)
  10.433 +                            | mmap[mcount].base_addr_low),
  10.434 +                      (u64)(((u64)mmap[mcount].length_high << 32)
  10.435 +                            | mmap[mcount].length_low));
  10.436 +                    ++mcount;
  10.437 +                }
  10.438 +            }
  10.439 +        }
  10.440 +        p = of_getpeer(p);
  10.441 +    } while (p != OF_FAILURE && p != 0);
  10.442 +
  10.443 +    if (mcount > 0) {
  10.444 +        mbi->flags |= MBI_MEMMAP;
  10.445 +        mbi->mmap_length = sizeof (mmap[0]) * mcount;
  10.446 +        mbi->mmap_addr = (ulong)mmap;
  10.447 +    }
  10.448 +}
  10.449 +
  10.450 +static void boot_of_bootargs(multiboot_info_t *mbi)
  10.451 +{
  10.452 +    int rc;
  10.453 +
  10.454 +    rc = of_getprop(bof_chosen, "bootargs", &bootargs, sizeof (bootargs));
  10.455 +    if (rc == OF_FAILURE) {
  10.456 +        strcpy(bootargs, "xen");
  10.457 +    }
  10.458 +
  10.459 +    mbi->flags |= MBI_CMDLINE;
  10.460 +    mbi->cmdline = (u32)bootargs;
  10.461 +
  10.462 +    of_printf("bootargs = %s\n", bootargs);
  10.463 +}
  10.464 +
  10.465 +static int save_props(void *m, ofdn_t n, int pkg)
  10.466 +{
  10.467 +    int ret;
  10.468 +    char name[128];
  10.469 +    int result = 1;
  10.470 +    int found_name = 0;
  10.471 +    int found_device_type = 0;
  10.472 +    const char name_str[] = "name";
  10.473 +    const char devtype_str[] = "device_type";
  10.474 +
  10.475 +    /* get first */
  10.476 +    result = of_nextprop(pkg, 0, name);
  10.477 +
  10.478 +    while (result > 0) {
  10.479 +        int sz;
  10.480 +        u64 obj[1024];
  10.481 +
  10.482 +        sz = of_getproplen(pkg, name);
  10.483 +        if (sz >= 0) {
  10.484 +            ret = OF_SUCCESS;
  10.485 +        } else {
  10.486 +            ret = OF_FAILURE;
  10.487 +        }
  10.488 +
  10.489 +        if (ret == OF_SUCCESS) {
  10.490 +            int actual = 0;
  10.491 +            ofdn_t pos;
  10.492 +
  10.493 +            if (sz > 0) {
  10.494 +                if (sz > sizeof (obj)) {
  10.495 +                    of_panic("obj array not big enough for 0x%x\n", sz);
  10.496 +                }
  10.497 +                actual = of_getprop(pkg, name, obj, sz);
  10.498 +                if (actual > sz) of_panic("obj too small");
  10.499 +            }
  10.500 +
  10.501 +            if (strncmp(name, name_str, sizeof(name_str)) == 0) {
  10.502 +                found_name = 1;
  10.503 +            }
  10.504 +
  10.505 +            if (strncmp(name, devtype_str, sizeof(devtype_str)) == 0) {
  10.506 +                found_device_type = 1;
  10.507 +            }
  10.508 +
  10.509 +            pos = ofd_prop_add(m, n, name, obj, actual);
  10.510 +            if (pos == 0) of_panic("prop_create");
  10.511 +        }
  10.512 +
  10.513 +        result = of_nextprop(pkg, name, name);
  10.514 +    }
  10.515 +
  10.516 +    return 1;
  10.517 +}
  10.518 +
  10.519 +
  10.520 +static void do_pkg(void *m, ofdn_t n, int p, char *path, size_t psz)
  10.521 +{
  10.522 +    int pnext;
  10.523 +    ofdn_t nnext;
  10.524 +    int sz;
  10.525 +
  10.526 +retry:
  10.527 +    save_props(m, n, p);
  10.528 +
  10.529 +    /* do children first */
  10.530 +    pnext = of_getchild(p);
  10.531 +
  10.532 +    if (pnext != 0) {
  10.533 +        sz = of_package_to_path(pnext, path, psz);
  10.534 +        if (sz == OF_FAILURE) of_panic("bad path\n");
  10.535 +
  10.536 +        nnext = ofd_node_child_create(m, n, path, sz);
  10.537 +        if (nnext == 0) of_panic("out of mem\n");
  10.538 +
  10.539 +        do_pkg(m, nnext, pnext, path, psz);
  10.540 +    }
  10.541 +
  10.542 +    /* do peer */
  10.543 +    pnext = of_getpeer(p);
  10.544 +
  10.545 +    if (pnext != 0) {
  10.546 +        sz = of_package_to_path(pnext, path, psz);
  10.547 +
  10.548 +        nnext = ofd_node_peer_create(m, n, path, sz);
  10.549 +        if (nnext <= 0) of_panic("out of space in OFD tree.\n");
  10.550 +
  10.551 +        n = nnext;
  10.552 +        p = pnext;
  10.553 +        goto retry;
  10.554 +    }
  10.555 +}
  10.556 +
  10.557 +static int pkg_save(void *mem)
  10.558 +{
  10.559 +    int root;
  10.560 +    char path[256];
  10.561 +    int r;
  10.562 +
  10.563 +    path[0]='/';
  10.564 +    path[1]='\0';
  10.565 +
  10.566 +    /* get root */
  10.567 +    root = of_getpeer(0);
  10.568 +    if (root == OF_FAILURE) of_panic("no root package\n");
  10.569 +
  10.570 +    do_pkg(mem, OFD_ROOT, root, path, sizeof(path));
  10.571 +
  10.572 +    r = (((ofdn_t *)mem)[1] + 1) * sizeof (u64);
  10.573 +
  10.574 +    of_printf("%s: saved device tree in 0x%x bytes\n", __func__, r);
  10.575 +
  10.576 +    return r;
  10.577 +}
  10.578 +
  10.579 +static int boot_of_fixup_refs(void *mem)
  10.580 +{
  10.581 +    static const char *fixup_props[] = {
  10.582 +        "interrupt-parent",
  10.583 +    };
  10.584 +    int i;
  10.585 +    int count = 0;
  10.586 +
  10.587 +    for (i = 0; i < ARRAY_SIZE(fixup_props); i++) {
  10.588 +        ofdn_t c;
  10.589 +        const char *name = fixup_props[i];
  10.590 +
  10.591 +        c = ofd_node_find_by_prop(mem, OFD_ROOT, name, NULL, 0);
  10.592 +        while (c > 0) {
  10.593 +            const char *path;
  10.594 +            int rp;
  10.595 +            int ref;
  10.596 +            ofdn_t dp;
  10.597 +            int rc;
  10.598 +            ofdn_t upd;
  10.599 +            char ofpath[256];
  10.600 +
  10.601 +            path = ofd_node_path(mem, c);
  10.602 +            if (path == NULL) of_panic("no path to found prop: %s\n", name);
  10.603 +
  10.604 +            rp = of_finddevice(path);
  10.605 +            if (rp == OF_FAILURE)
  10.606 +                of_panic("no real device for: name %s, path %s\n",
  10.607 +                          name, path);
  10.608 +            /* Note: In theory 0 is a valid node handle but it is highly
  10.609 +             * unlikely.
  10.610 +             */
  10.611 +            if (rp == 0) {
  10.612 +                of_panic("%s: of_finddevice returns 0 for path %s\n",
  10.613 +                                    __func__, path);
  10.614 +            } 
  10.615 +
  10.616 +            rc = of_getprop(rp, name, &ref, sizeof(ref));
  10.617 +            if ((rc == OF_FAILURE) || (rc == 0))
  10.618 +                of_panic("no prop: name %s, path %s, device 0x%x\n",
  10.619 +                         name, path, rp);
  10.620 +
  10.621 +            rc = of_package_to_path(ref, ofpath, sizeof (ofpath));
  10.622 +            if (rc == OF_FAILURE)
  10.623 +                of_panic("no package: name %s, path %s, device 0x%x,\n"
  10.624 +                         "ref 0x%x\n", name, path, rp, ref);
  10.625 +
  10.626 +            dp = ofd_node_find(mem, ofpath);
  10.627 +            if (dp <= 0) of_panic("no ofd node for OF node[0x%x]: %s\n",
  10.628 +                                  ref, ofpath);
  10.629 +
  10.630 +            ref = dp;
  10.631 +
  10.632 +            upd = ofd_prop_add(mem, c, name, &ref, sizeof(ref));
  10.633 +            if (upd <= 0) of_panic("update failed: %s\n", name);
  10.634 +
  10.635 +#ifdef DEBUG
  10.636 +            of_printf("%s: %s/%s -> %s\n", __func__,
  10.637 +                    path, name, ofpath);
  10.638 +#endif
  10.639 +            ++count;
  10.640 +            c = ofd_node_find_next(mem, c);
  10.641 +        }
  10.642 +    }
  10.643 +    return count;
  10.644 +}
  10.645 +
  10.646 +static int boot_of_fixup_chosen(void *mem)
  10.647 +{
  10.648 +    int ch;
  10.649 +    ofdn_t dn;
  10.650 +    ofdn_t dc;
  10.651 +    int val;
  10.652 +    int rc;
  10.653 +    char ofpath[256];
  10.654 +
  10.655 +    ch = of_finddevice("/chosen");
  10.656 +    if (ch == OF_FAILURE) of_panic("/chosen not found\n");
  10.657 +
  10.658 +    rc = of_getprop(ch, "cpu", &val, sizeof (val));
  10.659 +
  10.660 +    if (rc != OF_FAILURE) {
  10.661 +        rc = of_instance_to_path(val, ofpath, sizeof (ofpath));
  10.662 +
  10.663 +        if (rc > 0) {
  10.664 +            dn = ofd_node_find(mem, ofpath);
  10.665 +            if (dn <= 0) of_panic("no node for: %s\n", ofpath);
  10.666 +
  10.667 +            boot_cpu = dn;
  10.668 +            val = dn;
  10.669 +
  10.670 +            dn = ofd_node_find(mem, "/chosen");
  10.671 +            if (dn <= 0) of_panic("no /chosen node\n");
  10.672 +
  10.673 +            dc = ofd_prop_add(mem, dn, "cpu", &val, sizeof (val));
  10.674 +            if (dc <= 0) of_panic("could not fix /chosen/cpu\n");
  10.675 +            rc = 1;
  10.676 +        } else {
  10.677 +            of_printf("*** can't find path to booting cpu, "
  10.678 +                    "SMP is disabled\n");
  10.679 +            boot_cpu = -1;
  10.680 +        }
  10.681 +    }
  10.682 +    return rc;
  10.683 +}
  10.684 +
  10.685 +static ulong space_base;
  10.686 +static ulong find_space(u32 size, ulong align, multiboot_info_t *mbi)
  10.687 +{
  10.688 +    memory_map_t *map = (memory_map_t *)((ulong)mbi->mmap_addr);
  10.689 +    ulong eomem = ((u64)map->length_high << 32) | (u64)map->length_low;
  10.690 +    ulong base;
  10.691 +
  10.692 +    of_printf("%s base=0x%016lx  eomem=0x%016lx  size=0x%08x  align=0x%lx\n",
  10.693 +                    __func__, space_base, eomem, size, align);
  10.694 +    base = ALIGN_UP(space_base, PAGE_SIZE);
  10.695 +    if ((base + size) >= 0x4000000) return 0;
  10.696 +    if (base + size > eomem) of_panic("not enough RAM\n");
  10.697 +
  10.698 +    if (size == 0) return base;
  10.699 +    if (of_claim((void*)base, size) != OF_FAILURE) {
  10.700 +        space_base = base + size;
  10.701 +        return base;
  10.702 +    } else {
  10.703 +        for(base += 0x100000; (base+size) < 0x4000000; base += 0x100000) {
  10.704 +            of_printf("Trying 0x%016lx\n", base);
  10.705 +            if (of_claim((void*)base, size) != OF_FAILURE) {
  10.706 +                space_base = base + size;
  10.707 +                return base;
  10.708 +            }
  10.709 +        }
  10.710 +        return 0;
  10.711 +    }
  10.712 +}
  10.713 +
  10.714 +/* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges
  10.715 + * property.  The values are bad, and it doesn't even have the
  10.716 + * right number of cells. */
  10.717 +
  10.718 +static void __init boot_of_fix_maple(void)
  10.719 +{
  10.720 +    int isa;
  10.721 +    const char *ranges = "ranges";
  10.722 +    u32 isa_ranges[3];
  10.723 +    const u32 isa_test[] = { 0x00000001, 0xf4000000, 0x00010000 };
  10.724 +    const u32 isa_fixed[] = {
  10.725 +        0x00000001,
  10.726 +        0x00000000,
  10.727 +        0x00000000, /* 0xf4000000, matt says this */
  10.728 +        0x00000000,
  10.729 +        0x00000000,
  10.730 +        0x00010000
  10.731 +    };
  10.732 +
  10.733 +    isa = of_finddevice("/ht@0/isa@4");
  10.734 +    if (isa != OF_FAILURE) {
  10.735 +        if (of_getproplen(isa, ranges) == sizeof (isa_test)) {
  10.736 +            of_getprop(isa, ranges, isa_ranges, sizeof (isa_ranges));
  10.737 +            if (memcmp(isa_ranges, isa_test, sizeof (isa_test)) == 0) {
  10.738 +                int rc;
  10.739 +
  10.740 +                of_printf("OF: fixing bogus ISA range on maple\n");
  10.741 +                rc = of_setprop(isa, ranges, isa_fixed, sizeof (isa_fixed));
  10.742 +                if (rc == OF_FAILURE) {
  10.743 +                    of_panic("of_setprop() failed\n");
  10.744 +                }
  10.745 +            }
  10.746 +        }
  10.747 +    }
  10.748 +}
  10.749 +    
  10.750 +static int __init boot_of_serial(void *oftree)
  10.751 +{
  10.752 +    int n;
  10.753 +    int p;
  10.754 +    int rc;
  10.755 +    u32 val[3];
  10.756 +    char buf[128];
  10.757 +
  10.758 +    n = of_instance_to_package(of_out);
  10.759 +    if (n == OF_FAILURE) {
  10.760 +        of_panic("instance-to-package of /chosen/stdout: failed\n");
  10.761 +    }
  10.762 +
  10.763 +    /* prune this from the oftree */
  10.764 +    rc = of_package_to_path(n, buf, sizeof(buf));
  10.765 +    if (rc == OF_FAILURE) {
  10.766 +        of_panic("package-to-path of /chosen/stdout: failed\n");
  10.767 +    }
  10.768 +    of_printf("Pruning from devtree: %s\n"
  10.769 +              "  since Xen will be using it for console\n", buf);
  10.770 +    rc = ofd_prune_path(oftree, buf);
  10.771 +    if (rc < 0) {
  10.772 +        of_panic("prune path \"%s\" failed\n", buf);
  10.773 +    }
  10.774 +    
  10.775 +
  10.776 +    p = of_getparent(n);
  10.777 +    if (p == OF_FAILURE) {
  10.778 +        of_panic("no parent for: 0x%x\n", n);
  10.779 +    }
  10.780 +
  10.781 +    buf[0] = '\0';
  10.782 +    of_getprop(p, "device_type", buf, sizeof (buf));
  10.783 +    if (strstr(buf, "isa") == NULL) {
  10.784 +        of_panic("only ISA UARTS supported\n");
  10.785 +    }
  10.786 +
  10.787 +    /* should get this from devtree */
  10.788 +    isa_io_base = 0xf4000000;
  10.789 +    of_printf("%s: ISA base: 0x%lx\n", __func__, isa_io_base);
  10.790 +
  10.791 +    buf[0] = '\0';
  10.792 +    of_getprop(n, "device_type", buf, sizeof (buf));
  10.793 +    if (strstr(buf, "serial") == NULL) {
  10.794 +        of_panic("only UARTS supported\n");
  10.795 +    }
  10.796 +
  10.797 +    rc = of_getprop(n, "reg", val, sizeof (val));
  10.798 +    if (rc == OF_FAILURE) {
  10.799 +        of_panic("%s: no location for serial port\n", __func__);
  10.800 +    }
  10.801 +    ns16550.io_base = val[1];
  10.802 +
  10.803 +    ns16550.baud = BAUD_AUTO;
  10.804 +    ns16550.data_bits = 8;
  10.805 +    ns16550.parity = 'n';
  10.806 +    ns16550.stop_bits = 1;
  10.807 +
  10.808 +    rc = of_getprop(n, "interrupts", val, sizeof (val));
  10.809 +    if (rc == OF_FAILURE) {
  10.810 +        of_printf("%s: no ISRC, forcing poll mode\n", __func__);
  10.811 +        ns16550.irq = 0;
  10.812 +    } else {
  10.813 +        ns16550.irq = val[0];
  10.814 +        of_printf("%s: ISRC=0x%x, but forcing poll mode\n",
  10.815 +                  __func__, ns16550.irq);
  10.816 +        ns16550.irq = 0;
  10.817 +    }
  10.818 +
  10.819 +    return 1;
  10.820 +}
  10.821 +
  10.822 +static void boot_of_module(ulong r3, ulong r4, multiboot_info_t *mbi)
  10.823 +{
  10.824 +    static module_t mods[3];
  10.825 +    void *oftree;
  10.826 +    ulong oftree_sz = 48 * PAGE_SIZE;
  10.827 +    char *mod0_start;
  10.828 +    ulong mod0_size;
  10.829 +    ulong mod0;
  10.830 +    static const char sepr[] = " -- ";
  10.831 +    extern char dom0_start[] __attribute__ ((weak));
  10.832 +    extern char dom0_size[] __attribute__ ((weak));
  10.833 +    const char *p;
  10.834 +
  10.835 +    if ((r3 > 0) && (r4 > 0)) {
  10.836 +        /* was it handed to us in registers ? */
  10.837 +        mod0_start = (void *)r3;
  10.838 +        mod0_size = r4;
  10.839 +    } else {
  10.840 +        /* see if it is in the boot params */
  10.841 +        p = strstr((char *)((ulong)mbi->cmdline), "dom0_start=");
  10.842 +        if ( p != NULL) {
  10.843 +            p += 11;
  10.844 +            mod0_start = (char *)simple_strtoul(p, NULL, 0);
  10.845 +
  10.846 +            p = strstr((char *)((ulong)mbi->cmdline), "dom0_size=");
  10.847 +            p += 10;
  10.848 +            mod0_size = simple_strtoul(p, NULL, 0);
  10.849 +
  10.850 +            of_printf("mod0: %o %c %c %c\n",
  10.851 +                      mod0_start[0],
  10.852 +                      mod0_start[1],
  10.853 +                      mod0_start[2],
  10.854 +                      mod0_start[3]);
  10.855 +
  10.856 +        } else if ( ((ulong)dom0_start != 0) && ((ulong)dom0_size != 0) ) {
  10.857 +            /* was it linked in ? */
  10.858 +        
  10.859 +            mod0_start = dom0_start;
  10.860 +            mod0_size = (ulong)dom0_size;
  10.861 +            of_printf("%s: linked in module copied after _end "
  10.862 +                      "(start 0x%p size 0x%lx)\n",
  10.863 +                      __func__, mod0_start, mod0_size);
  10.864 +        } else {
  10.865 +            mod0_start = _end;
  10.866 +            mod0_size = 0;
  10.867 +        }
  10.868 +    }
  10.869 +
  10.870 +    space_base = (ulong)_end;
  10.871 +    mod0 = find_space(mod0_size, PAGE_SIZE, mbi);
  10.872 +
  10.873 +    /* three cases
  10.874 +     * 1) mod0_size is not 0 and the image can be copied
  10.875 +     * 2) mod0_size is not 0 and the image cannot be copied
  10.876 +     * 3) mod0_size is 0
  10.877 +     */
  10.878 +    if (mod0_size > 0) {
  10.879 +        if (mod0 != 0) {
  10.880 +            memcpy((void *)mod0, mod0_start, mod0_size);
  10.881 +            mods[0].mod_start = mod0;
  10.882 +            mods[0].mod_end = mod0 + mod0_size;
  10.883 +        } else {
  10.884 +            of_panic("No space to copy mod0\n");
  10.885 +        }
  10.886 +    } else {
  10.887 +        mods[0].mod_start = mod0;
  10.888 +        mods[0].mod_end = mod0;
  10.889 +    }
  10.890 +
  10.891 +    of_printf("%s: mod[0] @ 0x%016x[0x%x]\n", __func__,
  10.892 +              mods[0].mod_start, mods[0].mod_end);
  10.893 +    p = strstr((char *)(ulong)mbi->cmdline, sepr);
  10.894 +    if (p != NULL) {
  10.895 +        p += sizeof (sepr) - 1;
  10.896 +        mods[0].string = (u32)(ulong)p;
  10.897 +        of_printf("%s: mod[0].string: %s\n", __func__, p);
  10.898 +    }
  10.899 +
  10.900 +    /* snapshot the tree */
  10.901 +    oftree = (void*)find_space(oftree_sz, PAGE_SIZE, mbi);
  10.902 +    if (oftree == 0) of_panic("Could not allocate OFD tree\n");
  10.903 +
  10.904 +    of_printf("creating oftree\n");
  10.905 +    of_test("package-to-path");
  10.906 +    ofd_create(oftree, oftree_sz);
  10.907 +    pkg_save(oftree);
  10.908 +
  10.909 +    boot_of_fixup_refs(oftree);
  10.910 +    boot_of_fixup_chosen(oftree);
  10.911 +
  10.912 +    ofd_walk(oftree, OFD_ROOT, /* add_hype_props */ NULL, 2);
  10.913 +
  10.914 +    mods[1].mod_start = (ulong)oftree;
  10.915 +    mods[1].mod_end = mods[1].mod_start + oftree_sz;
  10.916 +    of_printf("%s: mod[1] @ 0x%016x[0x%x]\n", __func__,
  10.917 +              mods[1].mod_start, mods[1].mod_end);
  10.918 +
  10.919 +
  10.920 +    mbi->flags |= MBI_MODULES;
  10.921 +    mbi->mods_count = 2;
  10.922 +    mbi->mods_addr = (u32)mods;
  10.923 +
  10.924 +    boot_of_serial(oftree);
  10.925 +}
  10.926 +
  10.927 +static int __init boot_of_cpus(void)
  10.928 +{
  10.929 +    int cpus;
  10.930 +    int cpu;
  10.931 +    int result;
  10.932 +    u32 cpu_clock[2];
  10.933 +
  10.934 +    cpus = of_finddevice("/cpus");
  10.935 +    cpu = of_getchild(cpus);
  10.936 +    result = of_getprop(cpu, "timebase-frequency", &timebase_freq,
  10.937 +            sizeof(timebase_freq));
  10.938 +    if (result == OF_FAILURE) {
  10.939 +        of_panic("Couldn't get timebase frequency!\n");
  10.940 +    }
  10.941 +    of_printf("OF: timebase-frequency = %d Hz\n", timebase_freq);
  10.942 +
  10.943 +    result = of_getprop(cpu, "clock-frequency", &cpu_clock, sizeof(cpu_clock));
  10.944 +    if (result == OF_FAILURE || (result !=4 && result != 8)) {
  10.945 +        of_panic("Couldn't get clock frequency!\n");
  10.946 +    }
  10.947 +    cpu_khz = cpu_clock[0];
  10.948 +    if (result == 8) {
  10.949 +        cpu_khz <<= 32;
  10.950 +        cpu_khz |= cpu_clock[1];
  10.951 +    }
  10.952 +    cpu_khz /= 1000;
  10.953 +    of_printf("OF: clock-frequency = %ld KHz\n", cpu_khz);
  10.954 +
  10.955 +    /* FIXME: should not depend on the boot CPU bring the first child */
  10.956 +    cpu = of_getpeer(cpu);
  10.957 +    while (cpu > 0) {
  10.958 +        of_start_cpu(cpu, (ulong)spin_start, 0);
  10.959 +        cpu = of_getpeer(cpu);
  10.960 +    }
  10.961 +    return 1;
  10.962 +}
  10.963 +
  10.964 +static int __init boot_of_rtas(void)
  10.965 +{
  10.966 +    return 1;
  10.967 +}
  10.968 +
  10.969 +multiboot_info_t __init *boot_of_init(
  10.970 +        ulong r3, ulong r4, ulong vec, ulong r6, ulong r7, ulong orig_msr)
  10.971 +{
  10.972 +    static multiboot_info_t mbi;
  10.973 +
  10.974 +    of_vec = vec;
  10.975 +    of_msr = orig_msr;
  10.976 +
  10.977 +    bof_chosen = of_finddevice("/chosen");
  10.978 +    of_getprop(bof_chosen, "stdout", &of_out, sizeof (of_out));
  10.979 +
  10.980 +    of_printf("%s\n", "---------------------------------------------------");
  10.981 +    of_printf("OF: Xen/PPC version %d.%d%s (%s@%s) (%s) %s\n",
  10.982 +              XEN_VERSION, XEN_SUBVERSION, XEN_EXTRAVERSION,
  10.983 +              XEN_COMPILE_BY, XEN_COMPILE_DOMAIN,
  10.984 +              XEN_COMPILER, XEN_COMPILE_DATE);
  10.985 +
  10.986 +    of_printf("%s args: 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n"
  10.987 +            "boot msr: 0x%lx\n",
  10.988 +            __func__,
  10.989 +            r3, r4, vec, r6, r7, orig_msr);
  10.990 +
  10.991 +    if ((vec >= (ulong)_start) && (vec <= (ulong)_end)) {
  10.992 +        of_printf("Hmm.. OF[0x%lx] seems to have stepped on our image "
  10.993 +                "that ranges: %p .. %p.\n HANG!\n",
  10.994 +                vec, _start, _end);
  10.995 +    }
  10.996 +    of_printf("%s: _start %p _end %p 0x%lx\n", __func__, _start, _end, r6);
  10.997 +
  10.998 +    boot_of_fix_maple();
  10.999 +    boot_of_probemem(&mbi);
 10.1000 +    boot_of_bootargs(&mbi);
 10.1001 +    boot_of_module(r3, r4, &mbi);
 10.1002 +    boot_of_cpus();
 10.1003 +    boot_of_rtas();
 10.1004 +
 10.1005 +    /* end of OF */
 10.1006 +    of_call("quiesce", 0, 0, NULL);
 10.1007 +
 10.1008 +    return &mbi;
 10.1009 +}
 10.1010 +
 10.1011 +/*
 10.1012 + * Local variables:
 10.1013 + * mode: C
 10.1014 + * c-set-style: "BSD"
 10.1015 + * c-basic-offset: 4
 10.1016 + * tab-width: 4
 10.1017 + * indent-tabs-mode: nil
 10.1018 + * End:
 10.1019 + */

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/xen/arch/powerpc/dart.c	Fri Jul 14 10:47:50 2006 +0100
    11.3 @@ -0,0 +1,299 @@
    11.4 +/*
    11.5 + * This program is free software; you can redistribute it and/or modify
    11.6 + * it under the terms of the GNU General Public License as published by
    11.7 + * the Free Software Foundation; either version 2 of the License, or
    11.8 + * (at your option) any later version.
    11.9 + *
   11.10 + * This program is distributed in the hope that it will be useful,
   11.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   11.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   11.13 + * GNU General Public License for more details.
   11.14 + *
   11.15 + * You should have received a copy of the GNU General Public License
   11.16 + * along with this program; if not, write to the Free Software
   11.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   11.18 + *
   11.19 + * Copyright (C) IBM Corp. 2005
   11.20 + *
   11.21 + * Authors: Jimi Xenidis <jimix@watson.ibm.com>
   11.22 + */
   11.23 +
   11.24 +#include <xen/config.h>
   11.25 +#include <xen/types.h>
   11.26 +#include <xen/mm.h>
   11.27 +#include <asm/cache.h>
   11.28 +#include <xen/init.h>
   11.29 +#include "tce.h"
   11.30 +#include "iommu.h"
   11.31 +#include "dart.h"
   11.32 +#include "oftree.h"
   11.33 +#include "of-devtree.h"
   11.34 +
   11.35 +#undef DEBUG
   11.36 +#ifdef DEBUG
   11.37 +#define DBG(fmt...) printk(fmt)
   11.38 +static int dbg_after;
   11.39 +#define DBG_SET_AFTER dbg_after = 1;
   11.40 +#define DBG_AFTER(fmt...) if (dbg_after) DBG(fmt)
   11.41 +#else
   11.42 +#define DBG(fmt...)
   11.43 +#define DBG_SET_AFTER
   11.44 +#define DBG_AFTER(fmt...)
   11.45 +#endif
   11.46 +
   11.47 +/* Max size of 512 pages */
   11.48 +#define U3_LOG_MAX_PAGES 9
   11.49 +
   11.50 +#define DART_DEF_BASE   0xf8033000UL
   11.51 +#define DART_NONE 0
   11.52 +#define DART_U3 3
   11.53 +#define DART_U4 4
   11.54 +#define DART_WRITE 0x1
   11.55 +#define DART_READ 0x2
   11.56 +
   11.57 +static ulong dummy_page;
   11.58 +static ulong dart_entries;
   11.59 +static struct dart_ops *dops;
   11.60 +static u32 *dart_table;
   11.61 +
   11.62 +union dart_entry {
   11.63 +    u32 de_word;
   11.64 +    struct {
   11.65 +        u32 de_v:1;             /* valid */
   11.66 +        u32 de_rp:1;             /* read protected*/
   11.67 +        u32 de_wp:1;             /* write protected*/
   11.68 +        u32 _de_res:5;
   11.69 +        u32 de_ppn:24;         /* 24 bit Physical Page Number
   11.70 +                                 * representing address [28:51] */
   11.71 +    } de_bits;
   11.72 +};
   11.73 +
   11.74 +struct dma_window {
   11.75 +    u32 dw_liobn;
   11.76 +    u32 dw_base_hi;
   11.77 +    u64 dw_base;
   11.78 +    u64 dw_size;
   11.79 +};
   11.80 +
   11.81 +struct dart_info {
   11.82 +    struct dma_window di_window;
   11.83 +    ulong di_base;
   11.84 +    int di_model;
   11.85 +};
   11.86 +
   11.87 +static u32 dart_encode(int perm, ulong rpn)
   11.88 +{
   11.89 +    union dart_entry e;
   11.90 +
   11.91 +    e.de_word = 0;
   11.92 +    e.de_bits.de_v = 1;
   11.93 +    e.de_bits.de_ppn = rpn;
   11.94 +
   11.95 +    /* protect the page */
   11.96 +    e.de_bits.de_rp = 1;
   11.97 +    e.de_bits.de_wp = 1;
   11.98 +    if (perm & DART_READ) {
   11.99 +        e.de_bits.de_rp = 0;
  11.100 +    }
  11.101 +    if (perm & DART_WRITE) {
  11.102 +        e.de_bits.de_wp = 0;
  11.103 +    }
  11.104 +
  11.105 +    return e.de_word;
  11.106 +}
  11.107 +
  11.108 +static void dart_fill(ulong index, int perm, ulong rpg, ulong num_pg)
  11.109 +{
  11.110 +    u32 volatile *entry = dart_table + index;
  11.111 +    ulong i = 0;
  11.112 +    ulong last_flush = 0;
  11.113 +
  11.114 +    while (1) {
  11.115 +        entry[i] = dart_encode(perm, rpg);
  11.116 +        ++i;
  11.117 +        ++rpg;
  11.118 +        if (i == num_pg) break;
  11.119 +
  11.120 +        if (((ulong)&entry[i]) % CACHE_LINE_SIZE == 0) {
  11.121 +            last_flush = (ulong)&entry[i - 1];
  11.122 +            dcbst(last_flush);
  11.123 +        }
  11.124 +    }
  11.125 +    dcbst((ulong) &entry[i - 1]);
  11.126 +}
  11.127 +
  11.128 +static void dart_clear(ulong index, ulong num_pg)
  11.129 +{
  11.130 +    u32 *entry = dart_table + index;
  11.131 +    ulong i = 0;
  11.132 +    ulong rpg = dummy_page;
  11.133 +    ulong last_flush = 0;
  11.134 +
  11.135 +    while (1) {
  11.136 +        entry[i] = dart_encode(DART_READ | DART_WRITE, rpg);
  11.137 +        ++i;
  11.138 +        if (i == num_pg) break;
  11.139 +
  11.140 +        if (((ulong)&entry[i]) % CACHE_LINE_SIZE == 0) {
  11.141 +            last_flush = (ulong)&entry[i - 1];
  11.142 +            dcbst(last_flush);
  11.143 +        }
  11.144 +    }
  11.145 +    dcbst((ulong)&entry[i - 1]);
  11.146 +}
  11.147 +
  11.148 +static int dart_put(ulong ioba, union tce tce)
  11.149 +{
  11.150 +    ulong index = ioba >> PAGE_SHIFT;
  11.151 +
  11.152 +    if (index > dart_entries) {
  11.153 +        return -1;
  11.154 +    }
  11.155 +
  11.156 +    if (tce.tce_bits.tce_vlps  != 0 || tce.tce_bits.tce_lpx != 0) {
  11.157 +        panic("no support for large TCEs\n");
  11.158 +    }
  11.159 +
  11.160 +    if (tce.tce_bits.tce_read == 0 &&
  11.161 +        tce.tce_bits.tce_write == 0) {
  11.162 +        /* the TCE table is inited by the domain by a bunch of 0
  11.163 +         * perminssion puts.  We are only interesting in debugging the
  11.164 +         * ones after the first put */
  11.165 +        DBG_AFTER(">DART[0x%lx] clear\n", index);
  11.166 +        dart_clear(index, 1);
  11.167 +    } else {
  11.168 +        unsigned perm = 0;
  11.169 +
  11.170 +        if (tce.tce_bits.tce_read)
  11.171 +            perm |= DART_READ;
  11.172 +        if (tce.tce_bits.tce_write)
  11.173 +            perm |= DART_WRITE;
  11.174 +
  11.175 +        DBG("<DART[0x%lx]: ioba: 0x%lx perm:%x[%c%c] rpn:0x%lx\n",
  11.176 +            index, ioba, perm,
  11.177 +            (perm & DART_READ) ? 'R' : '-',
  11.178 +            (perm & DART_WRITE) ? 'W' : '-',
  11.179 +            (ulong)tce.tce_bits.tce_rpn);
  11.180 +        DBG_SET_AFTER;
  11.181 +
  11.182 +        dart_fill(index, perm, tce.tce_bits.tce_rpn, 1);
  11.183 +    }
  11.184 +    dops->do_inv_entry(tce.tce_bits.tce_rpn);
  11.185 +    
  11.186 +    return 0;
  11.187 +}
  11.188 +
  11.189 +static int find_dart(struct dart_info *di)
  11.190 +{
  11.191 +    int rc;
  11.192 +    void *ofd_p;
  11.193 +    ofdn_t n;
  11.194 +    char compat[128];
  11.195 +
  11.196 +
  11.197 +    if (on_mambo()) {
  11.198 +        /* mambo has no dart */
  11.199 +        DBG("%s: Mambo does not support a dart\n", __func__);
  11.200 +        return -1;
  11.201 +    }
  11.202 +
  11.203 +    ofd_p = (void *)oftree;
  11.204 +    n = ofd_node_find(ofd_p, "/ht");
  11.205 +    if (n <= 0)
  11.206 +        return -1;
  11.207 +
  11.208 +    /* get the defaults from the HT node model */
  11.209 +    rc = ofd_getprop(ofd_p, n, "compatible", compat, sizeof (compat));
  11.210 +    if (rc <= 0)
  11.211 +        return -1;
  11.212 +
  11.213 +    di->di_base = DART_DEF_BASE;
  11.214 +
  11.215 +    if (strstr(compat, "u3")) {
  11.216 +        di->di_model = DART_U3;
  11.217 +    } else if (strstr(compat, "u4")) {
  11.218 +        di->di_model = DART_U4;
  11.219 +    } else {
  11.220 +        DBG("%s: not a U3 or U4\n", __func__);
  11.221 +        return -1;
  11.222 +    }
  11.223 +    /* FIXME: this should actually be the HT reg value */
  11.224 +    di->di_window.dw_liobn = 0;
  11.225 +    di->di_window.dw_base_hi = 0;
  11.226 +    di->di_window.dw_base = 0;
  11.227 +
  11.228 +    /* lets see if the devtree has more info */
  11.229 +    n = ofd_node_find(ofd_p, "/dart");
  11.230 +    if (n > 0) {
  11.231 +        ulong base;
  11.232 +
  11.233 +        rc = ofd_getprop(ofd_p, n, "compatible", compat, sizeof (compat));
  11.234 +        if (rc > 0) {
  11.235 +            if (strstr(compat, "u4")) {
  11.236 +                di->di_model = DART_U4;
  11.237 +            }
  11.238 +        }
  11.239 +
  11.240 +        rc = ofd_getprop(ofd_p, n, "reg", &base, sizeof (base));
  11.241 +        if (rc > 0) {
  11.242 +            di->di_base = base;
  11.243 +        }
  11.244 +    }
  11.245 +    return 0;
  11.246 +}
  11.247 +
  11.248 +static int init_dart(void)
  11.249 +{
  11.250 +    ulong log_pgs;
  11.251 +    void *ofd_p;
  11.252 +    ofdn_t n;
  11.253 +    struct dart_info di;
  11.254 +
  11.255 +    if (find_dart(&di))
  11.256 +        return 0;
  11.257 +
  11.258 +    /* Max size of 512 pages == 2MB == 1<<21. That siz is good enough for U4 */
  11.259 +    log_pgs = U3_LOG_MAX_PAGES;
  11.260 +    dart_table = alloc_xenheap_pages(log_pgs);
  11.261 +    BUG_ON(dart_table == NULL);
  11.262 +
  11.263 +    dart_entries = (1UL << (log_pgs + PAGE_SHIFT)) / sizeof (union dart_entry);
  11.264 +    di.di_window.dw_size = dart_entries << PAGE_SHIFT;
  11.265 +
  11.266 +    /* Linux uses a dummy page, filling "empty" DART entries with a
  11.267 +       reference to this page to capture stray DMA's */
  11.268 +    dummy_page = (ulong)alloc_xenheap_pages(1);
  11.269 +    memset((void *)dummy_page, 0, PAGE_SIZE);
  11.270 +    dummy_page >>= PAGE_SHIFT;
  11.271 +
  11.272 +    printk("Initializing DART 0x%lx: tbl: %p[0x%lx] entries: 0x%lx\n",
  11.273 +           di.di_base, dart_table, 1UL << log_pgs, dart_entries);
  11.274 +           
  11.275 +    /* register this iommu */
  11.276 +    iommu_register(di.di_window.dw_liobn, dart_put);
  11.277 +
  11.278 +    switch (di.di_model) {
  11.279 +    case DART_U3:
  11.280 +        dops = u3_init(di.di_base, (ulong)dart_table, 1UL << log_pgs);
  11.281 +        break;
  11.282 +    case DART_U4:
  11.283 +        dops = u4_init(di.di_base, (ulong)dart_table, 1UL << log_pgs);
  11.284 +        break;
  11.285 +    }
  11.286 +
  11.287 +    dart_clear(0, dart_entries);
  11.288 +    dops->do_inv_all();
  11.289 +
  11.290 +    /* fix up the devtree */
  11.291 +    ofd_p = (void *)oftree;
  11.292 +    n = ofd_node_find(ofd_p, "/ht");
  11.293 +    if (n > 0) {
  11.294 +        di.di_window.dw_size = dart_entries << PAGE_SHIFT;
  11.295 +        ofd_prop_add(ofd_p, n, "ibm,dma-window", &di.di_window,
  11.296 +                     sizeof (di.di_window));
  11.297 +    } else {
  11.298 +        panic("%s: no /ht node\n", __func__);
  11.299 +    }
  11.300 +    return 0;
  11.301 +}
  11.302 +__initcall(init_dart);

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/xen/arch/powerpc/dart.h	Fri Jul 14 10:47:50 2006 +0100
    12.3 @@ -0,0 +1,36 @@
    12.4 +/*
    12.5 + * This program is free software; you can redistribute it and/or modify
    12.6 + * it under the terms of the GNU General Public License as published by
    12.7 + * the Free Software Foundation; either version 2 of the License, or
    12.8 + * (at your option) any later version.
    12.9 + *
   12.10 + * This program is distributed in the hope that it will be useful,
   12.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   12.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   12.13 + * GNU General Public License for more details.
   12.14 + *
   12.15 + * You should have received a copy of the GNU General Public License
   12.16 + * along with this program; if not, write to the Free Software
   12.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   12.18 + *
   12.19 + * Copyright (C) IBM Corp. 2005
   12.20 + *
   12.21 + * Authors: Jimi Xenidis <jimix@watson.ibm.com>
   12.22 + */
   12.23 +
   12.24 +#ifndef _DART_H
   12.25 +#define _DART_H
   12.26 +
   12.27 +#include <xen/config.h>
   12.28 +#include <xen/types.h>
   12.29 +
   12.30 +struct dart_ops {
   12.31 +    void (*do_inv_all)(void);
   12.32 +    void (*do_inv_entry)(ulong pg);
   12.33 +};
   12.34 +
   12.35 +extern struct dart_ops *u3_init(ulong base, ulong table, ulong dart_pages);
   12.36 +extern struct dart_ops *u4_init(ulong base, ulong table, ulong dart_pages);
   12.37 +
   12.38 +#endif /* _DART_H */
   12.39 +

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/xen/arch/powerpc/dart_u3.c	Fri Jul 14 10:47:50 2006 +0100
    13.3 @@ -0,0 +1,108 @@
    13.4 +/*
    13.5 + * This program is free software; you can redistribute it and/or modify
    13.6 + * it under the terms of the GNU General Public License as published by
    13.7 + * the Free Software Foundation; either version 2 of the License, or
    13.8 + * (at your option) any later version.
    13.9 + *
   13.10 + * This program is distributed in the hope that it will be useful,
   13.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   13.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   13.13 + * GNU General Public License for more details.
   13.14 + *
   13.15 + * You should have received a copy of the GNU General Public License
   13.16 + * along with this program; if not, write to the Free Software
   13.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   13.18 + *
   13.19 + * Copyright (C) IBM Corp. 2005
   13.20 + *
   13.21 + * Authors: Jimi Xenidis <jimix@watson.ibm.com>
   13.22 + */
   13.23 +
   13.24 +#undef DEBUG
   13.25 +
   13.26 +#include <xen/config.h>
   13.27 +#include <xen/types.h>
   13.28 +#include <xen/sched.h>
   13.29 +#include <xen/mm.h>
   13.30 +#include <public/xen.h>
   13.31 +#include <asm/io.h>
   13.32 +#include <asm/current.h>
   13.33 +#include "tce.h"
   13.34 +#include "iommu.h"
   13.35 +#include "dart.h"
   13.36 +
   13.37 +union dart_ctl {
   13.38 +    u32 dc_word;
   13.39 +    struct {
   13.40 +        u32 dc_base:20;
   13.41 +        u32 dc_stop_access:1;
   13.42 +        u32 dc_invtlb:1;
   13.43 +        u32 dc_enable:1;
   13.44 +        u32 dc_size:9;
   13.45 +    } reg;
   13.46 +};
   13.47 +
   13.48 +static u32 volatile *dart_ctl_reg;
   13.49 +
   13.50 +static void u3_inv_all(void)
   13.51 +{
   13.52 +    union dart_ctl dc;
   13.53 +    ulong r = 0;
   13.54 +    int l = 0;
   13.55 +
   13.56 +    for (;;) {
   13.57 +        dc.dc_word = in_32(dart_ctl_reg);
   13.58 +        dc.reg.dc_invtlb = 1;
   13.59 +        out_32(dart_ctl_reg, dc.dc_word);
   13.60 +
   13.61 +    do {
   13.62 +        dc.dc_word = in_32(dart_ctl_reg);
   13.63 +        r++;
   13.64 +    } while ((dc.reg.dc_invtlb == 1) && (r < (1 << l)));
   13.65 +
   13.66 +        if (r == (1 << l)) {
   13.67 +            if (l < 4) {
   13.68 +                l++;
   13.69 +                dc.dc_word = in_32(dart_ctl_reg);
   13.70 +                dc.reg.dc_invtlb = 0;
   13.71 +                out_32(dart_ctl_reg, dc.dc_word);
   13.72 +                continue;
   13.73 +            } else {
   13.74 +                panic(" broken U3???\n");
   13.75 +            }
   13.76 +        }
   13.77 +        return;
   13.78 +    }
   13.79 +}
   13.80 +
   13.81 +static void u3_inv_entry(ulong pg)
   13.82 +{
   13.83 +    /* sadly single entry invalidation has been reported not to work */
   13.84 +    u3_inv_all();
   13.85 +}
   13.86 +
   13.87 +static struct dart_ops u3_ops = {
   13.88 +    .do_inv_all = u3_inv_all,
   13.89 +    .do_inv_entry = u3_inv_entry,
   13.90 +};
   13.91 +
   13.92 +struct dart_ops *u3_init(ulong base, ulong table, ulong dart_pages)
   13.93 +{
   13.94 +    union dart_ctl dc;
   13.95 +
   13.96 +    dart_ctl_reg = (u32 *)base;
   13.97 +
   13.98 +    dc.dc_word = 0;
   13.99 +
  13.100 +    dc.reg.dc_base = table >> PAGE_SHIFT;
  13.101 +    dc.reg.dc_size = dart_pages;
  13.102 +    dc.reg.dc_enable = 1;
  13.103 +
  13.104 +
  13.105 +    printk("Initializing DART Model U3: reg: %p word: %x\n",
  13.106 +           dart_ctl_reg, dc.dc_word);
  13.107 +
  13.108 +    out_32(dart_ctl_reg, dc.dc_word);
  13.109 +
  13.110 +    return &u3_ops;
  13.111 +}

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/xen/arch/powerpc/dart_u4.c	Fri Jul 14 10:47:50 2006 +0100
    14.3 @@ -0,0 +1,177 @@
    14.4 +/*
    14.5 + * This program is free software; you can redistribute it and/or modify
    14.6 + * it under the terms of the GNU General Public License as published by
    14.7 + * the Free Software Foundation; either version 2 of the License, or
    14.8 + * (at your option) any later version.
    14.9 + *
   14.10 + * This program is distributed in the hope that it will be useful,
   14.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   14.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   14.13 + * GNU General Public License for more details.
   14.14 + *
   14.15 + * You should have received a copy of the GNU General Public License
   14.16 + * along with this program; if not, write to the Free Software
   14.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   14.18 + *
   14.19 + * Copyright (C) IBM Corp. 2005
   14.20 + *
   14.21 + * Authors: Jimi Xenidis <jimix@watson.ibm.com>
   14.22 + */
   14.23 +
   14.24 +#undef DEBUG
   14.25 +
   14.26 +#include <xen/config.h>
   14.27 +#include <xen/types.h>
   14.28 +#include <xen/sched.h>
   14.29 +#include <xen/init.h>
   14.30 +#include <xen/mm.h>
   14.31 +#include <public/xen.h>
   14.32 +#include <asm/io.h>
   14.33 +#include <asm/current.h>
   14.34 +#include "tce.h"
   14.35 +#include "iommu.h"
   14.36 +#include "dart.h"
   14.37 +
   14.38 +#define TOO_MANY_RETRIES ~0
   14.39 +
   14.40 +union dart_ctl {
   14.41 +    u32 dc_word;
   14.42 +    struct {
   14.43 +        u32 dc_darten:1;      /* DART Enable (0:disabled) */
   14.44 +        u32 dc_ione:1;        /* Invalidate one DART TLB entry (using ILPN) */
   14.45 +        u32 dc_iall:1;        /* Invalidate all DART TLB entries */
   14.46 +        u32 dc_idle:1;        /* DART is idle */
   14.47 +        u32 dc_peen:1;        /* Parity Checking is enabled */
   14.48 +        u32 dc_ilpn:27;       /* 27-bit Logical Page Address for 
   14.49 +                               * invalidating one TLB entry */
   14.50 +    } dc_bits;
   14.51 +};
   14.52 +
   14.53 +union dart_base {
   14.54 +    u32 db_word;
   14.55 +    struct {
   14.56 +        u32 _db_resv:8;
   14.57 +        u32 db_dartbase:24;     /* Base Address of DART (4K byte Alignment) */
   14.58 +    } db_bits;
   14.59 +};
   14.60 +
   14.61 +union dart_size {
   14.62 +    u32 ds_word;
   14.63 +    struct {
   14.64 +        u32 _ds_resv:15;
   14.65 +        u32 ds_dartsize:17;     /* Size of Dart in 4K-Byte Pages */
   14.66 +    } ds_bits;
   14.67 +};
   14.68 +
   14.69 +union dart_excp {
   14.70 +    u32 de_word;
   14.71 +    struct {
   14.72 +        u32 de_rqsrc:1;    /* Request Source.  [0:PCIE, 1:HT] */
   14.73 +        u32 de_lpn:27;     /* 27Ðbit Logical Address of Exception [25:51] */
   14.74 +        u32 de_rqop:1;     /* Request operation.  [0:Read, 1:Write] */
   14.75 +        u32 de_xcd:3;      /* Exception code */
   14.76 +    } de_bits;
   14.77 +};
   14.78 +
   14.79 +struct dart {
   14.80 +    /* 0x00 */
   14.81 +    union dart_ctl d_dartcntl;
   14.82 +    u32 _pad0x04_0x10[3];
   14.83 +    /* 0x10 */
   14.84 +    union dart_base d_dartbase;
   14.85 +    u32 _pad0x14_0x20[3];
   14.86 +    /* 0x20 */
   14.87 +    union dart_size d_dartsize;
   14.88 +    u32 _pad0x24_0x30[3];
   14.89 +    /* 0x30 */
   14.90 +    union dart_excp d_dartexcp;
   14.91 +    u32 _pad0x34_0x40[3];
   14.92 +};
   14.93 +
   14.94 +static volatile struct dart *dart;
   14.95 +
   14.96 +static void u4_inv_all(void)
   14.97 +{
   14.98 +    union dart_ctl dc;
   14.99 +    ulong r = 0;
  14.100 +    int l = 0;
  14.101 +
  14.102 +    for (;;) {
  14.103 +        dc.dc_word = in_32(&dart->d_dartcntl.dc_word);
  14.104 +        dc.dc_bits.dc_iall = 1;
  14.105 +        out_32(&dart->d_dartcntl.dc_word, dc.dc_word);
  14.106 +
  14.107 +        do {
  14.108 +            dc.dc_word = in_32(&dart->d_dartcntl.dc_word);
  14.109 +            r++;
  14.110 +        } while ((dc.dc_bits.dc_iall == 1) && (r < (1 << l)));
  14.111 +
  14.112 +        if (r == (1 << l)) {
  14.113 +            if (l < 4) {
  14.114 +                l++;
  14.115 +                dc.dc_word = in_32(&dart->d_dartcntl.dc_word);
  14.116 +                dc.dc_bits.dc_iall = 0;
  14.117 +                out_32(&dart->d_dartcntl.dc_word, dc.dc_word);
  14.118 +                continue;
  14.119 +            } else {
  14.120 +                panic(" broken U4???\n");
  14.121 +            }
  14.122 +        }
  14.123 +        return;
  14.124 +    }
  14.125 +}
  14.126 +
  14.127 +static void u4_inv_entry(ulong pgn)
  14.128 +{
  14.129 +    union dart_ctl dc;
  14.130 +    ulong retries = 0;
  14.131 +
  14.132 +    dc.dc_word = in_32(&dart->d_dartcntl.dc_word);
  14.133 +    dc.dc_bits.dc_ilpn = pgn;
  14.134 +    dc.dc_bits.dc_ione = 1;
  14.135 +    out_32(&dart->d_dartcntl.dc_word, dc.dc_word);
  14.136 +
  14.137 +    /* wait for completion */
  14.138 +    /* FIXME: since we do this from the HV do we need to wait?! */
  14.139 +    do {
  14.140 +        dc.dc_word = in_32(&dart->d_dartcntl.dc_word);
  14.141 +        retries++;
  14.142 +        if (retries > 1000000)
  14.143 +            panic("WAY! too long\n");
  14.144 +    } while (dc.dc_bits.dc_ione != 0);
  14.145 +}
  14.146 +
  14.147 +static struct dart_ops u4_ops = {
  14.148 +    .do_inv_all = u4_inv_all,
  14.149 +    .do_inv_entry = u4_inv_entry,
  14.150 +};
  14.151 +
  14.152 +struct dart_ops *u4_init(ulong base, ulong table, ulong dart_pages)
  14.153 +{
  14.154 +    union dart_base db;
  14.155 +    union dart_size ds;
  14.156 +    union dart_ctl dc;
  14.157 +
  14.158 +    dart = (struct dart *)base;
  14.159 +
  14.160 +    db.db_word = 0;
  14.161 +    db.db_bits.db_dartbase = table >> PAGE_SHIFT;
  14.162 +
  14.163 +    ds.ds_word = 0;
  14.164 +    ds.ds_bits.ds_dartsize = dart_pages;
  14.165 +
  14.166 +    dc.dc_word = in_32(&dart->d_dartcntl.dc_word);
  14.167 +    if (dc.dc_bits.dc_darten == 1) {
  14.168 +        panic("%s: dart is already enabled: 0x%x\n", __func__, dc.dc_word);
  14.169 +    }
  14.170 +    dc.dc_bits.dc_darten = 1;   /* enable it */
  14.171 +
  14.172 +    printk("Initializing DART Model U4: ctl: 0x%x base: 0x%x size: 0x%x\n",
  14.173 +           dc.dc_word, db.db_word, ds.ds_word);
  14.174 +
  14.175 +    out_32(&dart->d_dartbase.db_word, db.db_word);
  14.176 +    out_32(&dart->d_dartsize.ds_word, ds.ds_word);
  14.177 +    out_32(&dart->d_dartcntl.dc_word, dc.dc_word);
  14.178 +
  14.179 +    return &u4_ops;
  14.180 +}

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/xen/arch/powerpc/delay.c	Fri Jul 14 10:47:50 2006 +0100
    15.3 @@ -0,0 +1,37 @@
    15.4 +/*
    15.5 + * This program is free software; you can redistribute it and/or modify
    15.6 + * it under the terms of the GNU General Public License as published by
    15.7 + * the Free Software Foundation; either version 2 of the License, or
    15.8 + * (at your option) any later version.
    15.9 + *
   15.10 + * This program is distributed in the hope that it will be useful,
   15.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   15.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   15.13 + * GNU General Public License for more details.
   15.14 + *
   15.15 + * You should have received a copy of the GNU General Public License
   15.16 + * along with this program; if not, write to the Free Software
   15.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   15.18 + *
   15.19 + * Copyright (C) IBM Corp. 2005
   15.20 + *
   15.21 + * Authors: Jimi Xenidis <jimix@watson.ibm.com>
   15.22 + */
   15.23 +
   15.24 +#include <xen/config.h>
   15.25 +#include <xen/delay.h>
   15.26 +#include <xen/time.h>
   15.27 +#include <asm/processor.h>
   15.28 +
   15.29 +void udelay(unsigned long usecs)
   15.30 +{
   15.31 +    ulong ticks = usecs * ticks_per_usec;
   15.32 +    ulong s;
   15.33 +    ulong e;
   15.34 +
   15.35 +    s = get_timebase();
   15.36 +    do {
   15.37 +        asm volatile("or 1,1,1"); /* also puts the thread to low priority */
   15.38 +        e = get_timebase();
   15.39 +    } while ((e-s) < ticks);
   15.40 +}

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/xen/arch/powerpc/dom0_ops.c	Fri Jul 14 10:47:50 2006 +0100
    16.3 @@ -0,0 +1,87 @@
    16.4 +/*
    16.5 + * This program is free software; you can redistribute it and/or modify
    16.6 + * it under the terms of the GNU General Public License as published by
    16.7 + * the Free Software Foundation; either version 2 of the License, or
    16.8 + * (at your option) any later version.
    16.9 + *
   16.10 + * This program is distributed in the hope that it will be useful,
   16.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   16.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   16.13 + * GNU General Public License for more details.
   16.14 + *
   16.15 + * You should have received a copy of the GNU General Public License
   16.16 + * along with this program; if not, write to the Free Software
   16.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   16.18 + *
   16.19 + * Copyright (C) IBM Corp. 2005
   16.20 + *
   16.21 + * Authors: Jimi Xenidis <jimix@watson.ibm.com>
   16.22 + */
   16.23 +
   16.24 +#include <xen/config.h>
   16.25 +#include <xen/types.h>
   16.26 +#include <xen/lib.h>
   16.27 +#include <xen/sched.h>
   16.28 +#include <xen/guest_access.h>
   16.29 +#include <public/xen.h>
   16.30 +#include <public/dom0_ops.h>
   16.31 +
   16.32 +extern void arch_getdomaininfo_ctxt(struct vcpu *v, vcpu_guest_context_t *c);
   16.33 +extern long arch_do_dom0_op(struct dom0_op *op, XEN_GUEST_HANDLE(dom0_op_t) u_dom0_op);
   16.34 +
   16.35 +void arch_getdomaininfo_ctxt(struct vcpu *v, vcpu_guest_context_t *c)
   16.36 +{ 
   16.37 +    memcpy(&c->user_regs, &v->arch.ctxt, sizeof(struct cpu_user_regs));
   16.38 +    /* XXX fill in rest of vcpu_guest_context_t */
   16.39 +}
   16.40 +
   16.41 +long arch_do_dom0_op(struct dom0_op *op, XEN_GUEST_HANDLE(dom0_op_t) u_dom0_op)
   16.42 +{
   16.43 +    long ret = 0;
   16.44 +
   16.45 +    switch (op->cmd) {
   16.46 +    case DOM0_GETMEMLIST: {
   16.47 +        /* XXX 64M hackage */
   16.48 +        const int memsize = (64UL<<20);
   16.49 +        int domain_pfns = memsize>>12;
   16.50 +        int max_pfns = op->u.getmemlist.max_pfns;
   16.51 +        int domid = op->u.getmemlist.domain;
   16.52 +        int i;
   16.53 +
   16.54 +        for (i = 0; (i < max_pfns) && (i < domain_pfns); i++) {
   16.55 +            xen_pfn_t mfn = (((domid + 1) * memsize) >> 12) + i;
   16.56 +            if (copy_to_guest_offset(op->u.getmemlist.buffer, i, &mfn, 1)) {
   16.57 +                ret = -EFAULT;
   16.58 +                break;
   16.59 +            }
   16.60 +        }
   16.61 +        op->u.getmemlist.num_pfns = i;
   16.62 +        copy_to_guest(u_dom0_op, op, 1);
   16.63 +    }
   16.64 +    break;
   16.65 +
   16.66 +    case DOM0_PHYSINFO:
   16.67 +    {
   16.68 +        dom0_physinfo_t *pi = &op->u.physinfo;
   16.69 +
   16.70 +        pi->threads_per_core = 1;
   16.71 +        pi->cores_per_socket = 1;
   16.72 +        pi->sockets_per_node = 1;
   16.73 +        pi->nr_nodes         = 1;
   16.74 +        pi->total_pages      = total_pages;
   16.75 +        pi->free_pages       = avail_domheap_pages();
   16.76 +        pi->cpu_khz          = cpu_khz;
   16.77 +        memset(pi->hw_cap, 0, sizeof(pi->hw_cap));
   16.78 +        ret = 0;
   16.79 +        if ( copy_to_guest(u_dom0_op, op, 1) )
   16.80 +            ret = -EFAULT;
   16.81 +    }
   16.82 +    break;
   16.83 +
   16.84 +    default:
   16.85 +        ret = -ENOSYS;
   16.86 +        break;
   16.87 +    }
   16.88 +
   16.89 +    return ret;
   16.90 +}

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/xen/arch/powerpc/domain.c	Fri Jul 14 10:47:50 2006 +0100
    17.3 @@ -0,0 +1,251 @@
    17.4 +/*
    17.5 + * This program is free software; you can redistribute it and/or modify
    17.6 + * it under the terms of the GNU General Public License as published by
    17.7 + * the Free Software Foundation; either version 2 of the License, or
    17.8 + * (at your option) any later version.
    17.9 + *
   17.10 + * This program is distributed in the hope that it will be useful,
   17.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   17.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   17.13 + * GNU General Public License for more details.
   17.14 + *
   17.15 + * You should have received a copy of the GNU General Public License
   17.16 + * along with this program; if not, write to the Free Software
   17.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   17.18 + *
   17.19 + * Copyright (C) IBM Corp. 2005, 2006
   17.20 + *
   17.21 + * Authors: Jimi Xenidis <jimix@watson.ibm.com>
   17.22 + */
   17.23 +
   17.24 +#include <stdarg.h>
   17.25 +#include <xen/config.h>
   17.26 +#include <xen/lib.h>
   17.27 +#include <xen/sched.h>
   17.28 +#include <xen/mm.h>
   17.29 +#include <xen/serial.h>
   17.30 +#include <xen/domain.h>
   17.31 +#include <xen/console.h>
   17.32 +#include <xen/reboot.h>
   17.33 +#include <asm/htab.h>
   17.34 +#include <asm/current.h>
   17.35 +#include <asm/hcalls.h>
   17.36 +
   17.37 +extern void idle_loop(void);
   17.38 +
   17.39 +#define next_arg(fmt, args) ({                                              \
   17.40 +    unsigned long __arg;                                                    \
   17.41 +    switch ( *(fmt)++ )                                                     \
   17.42 +    {                                                                       \
   17.43 +    case 'i': __arg = (unsigned long)va_arg(args, unsigned int);  break;    \
   17.44 +    case 'l': __arg = (unsigned long)va_arg(args, unsigned long); break;    \
   17.45 +    case 'p': __arg = (unsigned long)va_arg(args, void *);        break;    \
   17.46 +    case 'h': __arg = (unsigned long)va_arg(args, void *);        break;    \
   17.47 +    default:  __arg = 0; BUG();                                             \
   17.48 +    }                                                                       \
   17.49 +    __arg;                                                                  \
   17.50 +})
   17.51 +
   17.52 +unsigned long hypercall_create_continuation(unsigned int op,
   17.53 +        const char *format, ...)
   17.54 +{
   17.55 +    struct cpu_user_regs *regs = guest_cpu_user_regs();
   17.56 +    const char *p = format;
   17.57 +    va_list args;
   17.58 +    int gprnum = 4;
   17.59 +    int i;
   17.60 +
   17.61 +    va_start(args, format);
   17.62 +
   17.63 +    regs->pc -= 4; /* re-execute 'sc' */
   17.64 +
   17.65 +    for (i = 0; *p != '\0'; i++) {
   17.66 +        regs->gprs[gprnum++] = next_arg(p, args);
   17.67 +    }
   17.68 +
   17.69 +    va_end(args);
   17.70 +
   17.71 +    /* As luck would have it, we use the same register for hcall opcodes and
   17.72 +     * for hcall return values. The return value from this function is placed
   17.73 +     * in r3 on return, so modifying regs->gprs[3] would have no effect. */
   17.74 +    return XEN_MARK(op);
   17.75 +}
   17.76 +
   17.77 +int arch_domain_create(struct domain *d)
   17.78 +{
   17.79 +
   17.80 +    if (d->domain_id == IDLE_DOMAIN_ID) {
   17.81 +        d->shared_info = (void *)alloc_xenheap_page();
   17.82 +        clear_page(d->shared_info);
   17.83 +
   17.84 +        return 0;
   17.85 +    }
   17.86 +
   17.87 +    /* XXX the hackage... hardcode 64M domains */
   17.88 +    d->arch.rma_base = (64<<20) * (d->domain_id + 1);
   17.89 +    d->arch.rma_size = (64<<20);
   17.90 +
   17.91 +    printk("clearing RMO: 0x%lx[0x%lx]\n", d->arch.rma_base, d->arch.rma_size);
   17.92 +    memset((void*)d->arch.rma_base, 0, d->arch.rma_size);
   17.93 +
   17.94 +    htab_alloc(d, LOG_DEFAULT_HTAB_BYTES);
   17.95 +
   17.96 +    d->shared_info = (shared_info_t *)
   17.97 +        (rma_addr(&d->arch, RMA_SHARED_INFO) + d->arch.rma_base);
   17.98 +
   17.99 +    d->arch.large_page_sizes = 1;
  17.100 +    d->arch.large_page_shift[0] = 24; /* 16 M for 970s */
  17.101 +
  17.102 +    return 0;
  17.103 +}
  17.104 +
  17.105 +void arch_domain_destroy(struct domain *d)
  17.106 +{
  17.107 +    unimplemented();
  17.108 +}
  17.109 +
  17.110 +void machine_halt(void)
  17.111 +{
  17.112 +    printf("machine_halt called: spinning....\n");
  17.113 +    console_start_sync();
  17.114 +    while(1);
  17.115 +}
  17.116 +
  17.117 +void machine_restart(char * __unused)
  17.118 +{
  17.119 +    printf("machine_restart called: spinning....\n");
  17.120 +    console_start_sync();
  17.121 +    while(1);
  17.122 +}
  17.123 +
  17.124 +struct vcpu *alloc_vcpu_struct(struct domain *d, unsigned int vcpu_id)
  17.125 +{
  17.126 +    struct vcpu *v;
  17.127 +
  17.128 +    if ( (v = xmalloc(struct vcpu)) == NULL )
  17.129 +        return NULL;
  17.130 +
  17.131 +    memset(v, 0, sizeof(*v));
  17.132 +    v->vcpu_id = vcpu_id;
  17.133 +
  17.134 +    return v;
  17.135 +}
  17.136 +
  17.137 +void free_vcpu_struct(struct vcpu *v)
  17.138 +{
  17.139 +    BUG_ON(v->next_in_list != NULL);
  17.140 +    if ( v->vcpu_id != 0 )
  17.141 +        v->domain->vcpu[v->vcpu_id - 1]->next_in_list = NULL;
  17.142 +    xfree(v);
  17.143 +}
  17.144 +
  17.145 +int arch_set_info_guest(struct vcpu *v, vcpu_guest_context_t *c)
  17.146 +{ 
  17.147 +    memcpy(&v->arch.ctxt, &c->user_regs, sizeof(c->user_regs));
  17.148 +
  17.149 +    set_bit(_VCPUF_initialised, &v->vcpu_flags);
  17.150 +
  17.151 +    cpu_init_vcpu(v);
  17.152 +
  17.153 +    return 0;
  17.154 +}
  17.155 +
  17.156 +void dump_pageframe_info(struct domain *d)
  17.157 +{
  17.158 +    struct page_info *page;
  17.159 +
  17.160 +    printk("Memory pages belonging to domain %u:\n", d->domain_id);
  17.161 +
  17.162 +    if ( d->tot_pages >= 10 )
  17.163 +    {
  17.164 +        printk("    DomPage list too long to display\n");
  17.165 +    }
  17.166 +    else
  17.167 +    {
  17.168 +        list_for_each_entry ( page, &d->page_list, list )
  17.169 +        {
  17.170 +            printk("    DomPage %p: mfn=%p, caf=%016lx, taf=%" PRtype_info "\n",
  17.171 +                   _p(page_to_maddr(page)), _p(page_to_mfn(page)),
  17.172 +                   page->count_info, page->u.inuse.type_info);
  17.173 +        }
  17.174 +    }
  17.175 +
  17.176 +    list_for_each_entry ( page, &d->xenpage_list, list )
  17.177 +    {
  17.178 +        printk("    XenPage %p: mfn=%p, caf=%016lx, taf=%" PRtype_info "\n",
  17.179 +               _p(page_to_maddr(page)), _p(page_to_mfn(page)),
  17.180 +               page->count_info, page->u.inuse.type_info);
  17.181 +    }
  17.182 +}
  17.183 +
  17.184 +
  17.185 +void context_switch(struct vcpu *prev, struct vcpu *next)
  17.186 +{
  17.187 +    struct cpu_user_regs *stack_regs = guest_cpu_user_regs();
  17.188 +    cpumask_t dirty_mask = next->vcpu_dirty_cpumask;
  17.189 +    unsigned int cpu = smp_processor_id();
  17.190 +
  17.191 +#if 0
  17.192 +    printf("%s: dom %x to dom %x\n", __func__, prev->domain->domain_id,
  17.193 +            next->domain->domain_id);
  17.194 +#endif
  17.195 +
  17.196 +    /* Allow at most one CPU at a time to be dirty. */
  17.197 +    ASSERT(cpus_weight(dirty_mask) <= 1);
  17.198 +    if (unlikely(!cpu_isset(cpu, dirty_mask) && !cpus_empty(dirty_mask)))
  17.199 +    {
  17.200 +        /* Other cpus call __sync_lazy_execstate from flush ipi handler. */
  17.201 +        if (!cpus_empty(next->vcpu_dirty_cpumask))
  17.202 +            flush_tlb_mask(next->vcpu_dirty_cpumask);
  17.203 +    }
  17.204 +
  17.205 +    /* copy prev guest state off the stack into its vcpu */
  17.206 +    memcpy(&prev->arch.ctxt, stack_regs, sizeof(struct cpu_user_regs));
  17.207 +
  17.208 +    set_current(next);
  17.209 +
  17.210 +    /* copy next guest state onto the stack */
  17.211 +    memcpy(stack_regs, &next->arch.ctxt, sizeof(struct cpu_user_regs));
  17.212 +
  17.213 +    /* save old domain state */
  17.214 +    save_sprs(prev);
  17.215 +    save_float(prev);
  17.216 +    save_segments(prev);
  17.217 +
  17.218 +    context_saved(prev);
  17.219 +
  17.220 +    /* load up new domain */
  17.221 +    load_sprs(next);
  17.222 +    load_float(next);
  17.223 +    load_segments(next);
  17.224 +
  17.225 +    mtsdr1(next->domain->arch.htab.sdr1);
  17.226 +    local_flush_tlb(); /* XXX maybe flush_tlb_mask? */
  17.227 +
  17.228 +    if (is_idle_vcpu(next)) {
  17.229 +        reset_stack_and_jump(idle_loop);
  17.230 +    }
  17.231 +
  17.232 +    reset_stack_and_jump(full_resume);
  17.233 +    /* not reached */
  17.234 +}
  17.235 +
  17.236 +void continue_running(struct vcpu *same)
  17.237 +{
  17.238 +    /* nothing to do */
  17.239 +}
  17.240 +
  17.241 +void sync_vcpu_execstate(struct vcpu *v)
  17.242 +{
  17.243 +    /* XXX for now, for domain destruction, make this non-fatal */
  17.244 +    printf("%s: called\n", __func__);
  17.245 +}
  17.246 +
  17.247 +void domain_relinquish_resources(struct domain *d)
  17.248 +{
  17.249 +    /* nothing to do? */
  17.250 +}
  17.251 +
  17.252 +void arch_dump_domain_info(struct domain *d)
  17.253 +{
  17.254 +}

    18.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    18.2 +++ b/xen/arch/powerpc/domain_build.c	Fri Jul 14 10:47:50 2006 +0100
    18.3 @@ -0,0 +1,285 @@
    18.4 +/*
    18.5 + * This program is free software; you can redistribute it and/or modify
    18.6 + * it under the terms of the GNU General Public License as published by
    18.7 + * the Free Software Foundation; either version 2 of the License, or
    18.8 + * (at your option) any later version.
    18.9 + *
   18.10 + * This program is distributed in the hope that it will be useful,
   18.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   18.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   18.13 + * GNU General Public License for more details.
   18.14 + *
   18.15 + * You should have received a copy of the GNU General Public License
   18.16 + * along with this program; if not, write to the Free Software
   18.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   18.18 + *
   18.19 + * Copyright (C) IBM Corp. 2005
   18.20 + *
   18.21 + * Authors: Jimi Xenidis <jimix@watson.ibm.com>
   18.22 + */
   18.23 +
   18.24 +#include <xen/config.h>
   18.25 +#include <xen/lib.h>
   18.26 +#include <xen/elf.h>
   18.27 +#include <xen/sched.h>
   18.28 +#include <xen/init.h>
   18.29 +#include <xen/ctype.h>
   18.30 +#include <xen/iocap.h>
   18.31 +#include <xen/compile.h>
   18.32 +#include <asm/processor.h>
   18.33 +#include <asm/papr.h>
   18.34 +#include "oftree.h"
   18.35 +
   18.36 +extern int parseelfimage_32(struct domain_setup_info *dsi);
   18.37 +extern int loadelfimage_32(struct domain_setup_info *dsi);
   18.38 +
   18.39 +/* opt_dom0_mem: memory allocated to domain 0. */
   18.40 +static unsigned int opt_dom0_mem;
   18.41 +static void parse_dom0_mem(char *s)
   18.42 +{
   18.43 +    unsigned long long bytes = parse_size_and_unit(s);
   18.44 +    /* If no unit is specified we default to kB units, not bytes. */
   18.45 +    if (isdigit(s[strlen(s)-1]))
   18.46 +        opt_dom0_mem = (unsigned int)bytes;
   18.47 +    else
   18.48 +        opt_dom0_mem = (unsigned int)(bytes >> 10);
   18.49 +}
   18.50 +custom_param("dom0_mem", parse_dom0_mem);
   18.51 +
   18.52 +int elf_sanity_check(Elf_Ehdr *ehdr)
   18.53 +{
   18.54 +    if (IS_ELF(*ehdr))
   18.55 +        /* we are happy with either */
   18.56 +        if ((ehdr->e_ident[EI_CLASS] == ELFCLASS32
   18.57 +             && ehdr->e_machine == EM_PPC)
   18.58 +            || (ehdr->e_ident[EI_CLASS] == ELFCLASS64
   18.59 +                && ehdr->e_machine == EM_PPC64)) {
   18.60 +            if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB
   18.61 +                && ehdr->e_type == ET_EXEC)
   18.62 +                return 1;
   18.63 +        }
   18.64 +    printk("DOM0 image is not a Xen-compatible Elf image.\n");
   18.65 +    return 0;
   18.66 +}
   18.67 +
   18.68 +/* adapted from common/elf.c */
   18.69 +#define RM_MASK(a,l) ((a) & ((1UL << (l)) - 1))
   18.70 +
   18.71 +static int rm_loadelfimage_64(struct domain_setup_info *dsi, ulong rma)
   18.72 +{
   18.73 +    char *elfbase = (char *)dsi->image_addr;
   18.74 +    Elf64_Ehdr *ehdr = (Elf64_Ehdr *)dsi->image_addr;
   18.75 +    Elf64_Phdr *phdr;
   18.76 +    int h;
   18.77 +  
   18.78 +    for (h = 0; h < ehdr->e_phnum; h++ ) 
   18.79 +    {
   18.80 +        phdr = (Elf64_Phdr *)(elfbase + ehdr->e_phoff + (h*ehdr->e_phentsize));
   18.81 +        if (!((phdr->p_type == PT_LOAD) &&
   18.82 +             ((phdr->p_flags & (PF_W|PF_X)) != 0)))
   18.83 +            continue;
   18.84 +
   18.85 +        if (phdr->p_filesz != 0)
   18.86 +            memcpy((char *)(rma + RM_MASK(phdr->p_paddr, 42)),
   18.87 +                   elfbase + phdr->p_offset, 
   18.88 +                   phdr->p_filesz);
   18.89 +        if (phdr->p_memsz > phdr->p_filesz)
   18.90 +            memset((char *)(rma + RM_MASK(phdr->p_paddr, 42) + phdr->p_filesz),
   18.91 +                   0, phdr->p_memsz - phdr->p_filesz);
   18.92 +    }
   18.93 +
   18.94 +#ifdef NOT_YET
   18.95 +    loadelfsymtab(dsi, 1);
   18.96 +#endif
   18.97 +
   18.98 +    return 0;
   18.99 +}
  18.100 +
  18.101 +int construct_dom0(struct domain *d,
  18.102 +                   unsigned long image_start, unsigned long image_len, 
  18.103 +                   unsigned long initrd_start, unsigned long initrd_len,
  18.104 +                   char *cmdline)
  18.105 +{
  18.106 +    int rc;
  18.107 +    struct vcpu *v = d->vcpu[0];
  18.108 +    struct domain_setup_info dsi;
  18.109 +    ulong dst;
  18.110 +    u64 *ofh_tree;
  18.111 +    ulong rma_sz = d->arch.rma_size;
  18.112 +    ulong rma = d->arch.rma_base;
  18.113 +    start_info_t *si;
  18.114 +    ulong eomem;
  18.115 +    int am64 = 1;
  18.116 +    ulong msr;
  18.117 +    ulong pc;
  18.118 +    ulong r2;
  18.119 +
  18.120 +    /* Sanity! */
  18.121 +    BUG_ON(d->domain_id != 0);
  18.122 +    BUG_ON(d->vcpu[0] == NULL);
  18.123 +
  18.124 +    cpu_init_vcpu(v);
  18.125 +
  18.126 +    memset(&dsi, 0, sizeof(struct domain_setup_info));
  18.127 +    dsi.image_addr = image_start;
  18.128 +    dsi.image_len  = image_len;
  18.129 +
  18.130 +    if ((rc = parseelfimage(&dsi)) != 0) {
  18.131 +        if ((rc = parseelfimage_32(&dsi)) != 0)
  18.132 +            return rc;
  18.133 +        am64 = 0;
  18.134 +    }
  18.135 +
  18.136 +    /* elf contains virtual addresses that can have the upper bits
  18.137 +     * masked while running in real mode, so we do the masking as well
  18.138 +     * as well */
  18.139 +    dsi.v_kernstart = RM_MASK(dsi.v_kernstart, 42);
  18.140 +    dsi.v_kernend = RM_MASK(dsi.v_kernend, 42);
  18.141 +    dsi.v_kernentry = RM_MASK(dsi.v_kernentry, 42);
  18.142 +
  18.143 +    if (dsi.xen_section_string == NULL) {
  18.144 +        printk("Not a Xen-ELF image: '__xen_guest' section not found.\n");
  18.145 +        return -EINVAL;
  18.146 +    }
  18.147 +    printk("*** LOADING DOMAIN 0 ***\n");
  18.148 +
  18.149 +    /* By default DOM0 is allocated all available memory. */
  18.150 +    d->max_pages = ~0U;
  18.151 +    d->tot_pages = (d->arch.rma_size >> PAGE_SHIFT);
  18.152 +
  18.153 +    ASSERT( image_len < rma_sz );
  18.154 +
  18.155 +    si = (start_info_t *)(rma_addr(&d->arch, RMA_START_INFO) + rma);
  18.156 +    printk("xen_start_info: %p\n", si);
  18.157 +
  18.158 +    sprintf(si->magic, "xen-%i.%i-powerpc%d%s",
  18.159 +            XEN_VERSION, XEN_SUBVERSION, BITS_PER_LONG, "HV");
  18.160 +    si->flags = SIF_PRIVILEGED | SIF_INITDOMAIN;
  18.161 +
  18.162 +    si->shared_info = ((ulong)d->shared_info) - rma;
  18.163 +    printk("shared_info: 0x%lx,%p\n", si->shared_info, d->shared_info);
  18.164 +
  18.165 +    eomem = si->shared_info;
  18.166 +
  18.167 +    /* allow dom0 to access all of system RAM */
  18.168 +    d->arch.logical_base_pfn = 128 << (20 - PAGE_SHIFT); /* 128 MB */
  18.169 +    d->arch.logical_end_pfn = max_page;
  18.170 +
  18.171 +    /* number of pages accessible */
  18.172 +    si->nr_pages = rma_sz >> PAGE_SHIFT;
  18.173 +
  18.174 +    si->pt_base = 0;
  18.175 +    si->nr_pt_frames = 0;
  18.176 +    si->mfn_list = 0;
  18.177 +
  18.178 +    /* OF usually sits here:
  18.179 +     *   - Linux needs it to be loaded before the vmlinux or initrd
  18.180 +     *   - AIX demands it to be @ 32M.
  18.181 +     */
  18.182 +    dst = (32 << 20);
  18.183 +
  18.184 +    /* put stack below everything */
  18.185 +    v->arch.ctxt.gprs[1] = dst - STACK_FRAME_OVERHEAD;
  18.186 +
  18.187 +    /* copy relative to Xen */
  18.188 +    dst += rma;
  18.189 +
  18.190 +    ASSERT((dst - rma) + (ulong)firmware_image_size < eomem);
  18.191 +    printk("loading OFH: 0x%lx, RMA: 0x%lx\n", dst, dst - rma);
  18.192 +    memcpy((void *)dst, firmware_image_start, (ulong)firmware_image_size);
  18.193 +
  18.194 +    v->arch.ctxt.gprs[5] = (dst - rma);
  18.195 +    ofh_tree = (u64 *)(dst + 0x10);
  18.196 +    ASSERT(*ofh_tree == 0xdeadbeef00000000);
  18.197 +
  18.198 +    /* accomodate for a modest bss section */
  18.199 +    dst = ALIGN_UP(dst + (ulong)firmware_image_size + PAGE_SIZE, PAGE_SIZE);
  18.200 +    ASSERT((dst - rma) + oftree_len < eomem);
  18.201 +
  18.202 +    *ofh_tree = dst - rma;
  18.203 +    printk("loading OFD: 0x%lx RMA: 0x%lx, 0x%lx\n", dst, dst - rma,
  18.204 +           oftree_len);
  18.205 +    memcpy((void *)dst, (void *)oftree, oftree_len);
  18.206 +
  18.207 +    dst = ALIGN_UP(dst + oftree_len, PAGE_SIZE);
  18.208 +
  18.209 +    if (am64) {
  18.210 +        ulong kbase;
  18.211 +        ulong *fdesc;
  18.212 +
  18.213 +        printk("loading 64-bit Dom0: 0x%lx, in RMA:0x%lx\n", dst, dst - rma);
  18.214 +        rm_loadelfimage_64(&dsi, dst);
  18.215 +
  18.216 +        kbase = dst;
  18.217 +        /* move dst to end of bss */
  18.218 +        dst = ALIGN_UP(dsi.v_kernend + dst, PAGE_SIZE);
  18.219 +
  18.220 +        if ( initrd_len > 0 ) {
  18.221 +            ASSERT( (dst - rma) + image_len < eomem );
  18.222 +
  18.223 +            printk("loading initrd: 0x%lx, 0x%lx\n", dst, initrd_len);
  18.224 +            memcpy((void *)dst, (void *)initrd_start, initrd_len);
  18.225 +
  18.226 +            si->mod_start = dst - rma;
  18.227 +            si->mod_len = image_len;
  18.228 +
  18.229 +            dst = ALIGN_UP(dst + initrd_len, PAGE_SIZE);
  18.230 +        } else {
  18.231 +            printk("no initrd\n");
  18.232 +            si->mod_start = 0;
  18.233 +            si->mod_len = 0;
  18.234 +        }
  18.235 +        /* it may be a function descriptor */
  18.236 +        fdesc = (ulong *)(dsi.v_kernstart + dsi.v_kernentry + kbase);
  18.237 +
  18.238 +        if (fdesc[2] == 0
  18.239 +            && ((fdesc[0] >= dsi.v_kernstart)
  18.240 +                && (fdesc[0] < dsi.v_kernend)) /* text entry is in range */
  18.241 +            && ((fdesc[1] >= dsi.v_kernstart)  /* toc can be > image */
  18.242 +                && (fdesc[1] < (dsi.v_kernend + (0x7fff * sizeof (ulong)))))) {
  18.243 +            /* it is almost certainly a function descriptor */
  18.244 +            pc = RM_MASK(fdesc[0], 42) + kbase - rma;
  18.245 +            r2 = RM_MASK(fdesc[1], 42) + kbase - rma;
  18.246 +        } else {
  18.247 +            pc = ((ulong)fdesc) - rma;
  18.248 +            r2 = 0;
  18.249 +        }
  18.250 +        msr = MSR_SF;
  18.251 +    } else {
  18.252 +        printk("loading 32-bit Dom0: 0x%lx, in RMA:0x%lx\n",
  18.253 +               dsi.v_kernstart + rma, dsi.v_kernstart);
  18.254 +        dsi.v_start = rma;
  18.255 +        loadelfimage_32(&dsi);
  18.256 +
  18.257 +        pc = dsi.v_kernentry;
  18.258 +        r2 = 0;
  18.259 +        msr = 0;
  18.260 +    }
  18.261 +
  18.262 +    v->arch.ctxt.gprs[3] = si->mod_start;
  18.263 +    v->arch.ctxt.gprs[4] = si->mod_len;
  18.264 +
  18.265 +    memset(si->cmd_line, 0, sizeof(si->cmd_line));
  18.266 +    if ( cmdline != NULL )
  18.267 +        strncpy((char *)si->cmd_line, cmdline, sizeof(si->cmd_line)-1);
  18.268 +
  18.269 +    v->arch.ctxt.msr = msr;
  18.270 +    v->arch.ctxt.pc = pc;
  18.271 +    v->arch.ctxt.gprs[2] = r2;
  18.272 +
  18.273 +    printk("DOM: pc = 0x%lx, r2 = 0x%lx\n", pc, r2);
  18.274 +
  18.275 +    ofd_dom0_fixup(d, *ofh_tree + rma, si, dst - rma);
  18.276 +
  18.277 +    set_bit(_VCPUF_initialised, &v->vcpu_flags);
  18.278 +
  18.279 +    rc = 0;
  18.280 +
  18.281 +    /* DOM0 is permitted full I/O capabilities. */
  18.282 +    rc |= iomem_permit_access(dom0, 0UL, ~0UL);
  18.283 +    rc |= irqs_permit_access(dom0, 0, NR_IRQS-1);
  18.284 +
  18.285 +    BUG_ON(rc != 0);
  18.286 +
  18.287 +    return 0;
  18.288 +}

    19.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    19.2 +++ b/xen/arch/powerpc/elf32.c	Fri Jul 14 10:47:50 2006 +0100
    19.3 @@ -0,0 +1,5 @@
    19.4 +#define parseelfimage parseelfimage_32
    19.5 +#define loadelfimage loadelfimage_32
    19.6 +#define ELFSIZE 32
    19.7 +#include "../../common/elf.c"
    19.8 +

    20.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    20.2 +++ b/xen/arch/powerpc/exceptions.c	Fri Jul 14 10:47:50 2006 +0100
    20.3 @@ -0,0 +1,87 @@
    20.4 +/*
    20.5 + * This program is free software; you can redistribute it and/or modify
    20.6 + * it under the terms of the GNU General Public License as published by
    20.7 + * the Free Software Foundation; either version 2 of the License, or
    20.8 + * (at your option) any later version.
    20.9 + *
   20.10 + * This program is distributed in the hope that it will be useful,
   20.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   20.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   20.13 + * GNU General Public License for more details.
   20.14 + *
   20.15 + * You should have received a copy of the GNU General Public License
   20.16 + * along with this program; if not, write to the Free Software
   20.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   20.18 + *
   20.19 + * Copyright (C) IBM Corp. 2005, 2006
   20.20 + *
   20.21 + * Authors: Hollis Blanchard <hollisb@us.ibm.com>
   20.22 + */
   20.23 +
   20.24 +#include <xen/config.h>
   20.25 +#include <xen/softirq.h>
   20.26 +#include <xen/sched.h>
   20.27 +#include <xen/serial.h>
   20.28 +#include <xen/gdbstub.h>
   20.29 +#include <public/xen.h>
   20.30 +#include <asm/time.h>
   20.31 +
   20.32 +#undef DEBUG
   20.33 +#define HDEC_PREEMPT
   20.34 +
   20.35 +extern ulong ppc_do_softirq(ulong orig_msr);
   20.36 +extern void do_timer(struct cpu_user_regs *regs);
   20.37 +extern void do_dec(struct cpu_user_regs *regs);
   20.38 +extern void program_exception(struct cpu_user_regs *regs, unsigned long cookie);
   20.39 +
   20.40 +int hdec_sample = 0;
   20.41 +
   20.42 +void do_timer(struct cpu_user_regs *regs)
   20.43 +{
   20.44 +    /* XXX this is just here to keep HDEC from firing until
   20.45 +     * reprogram_ac_timer() sets the proper next-tick time */
   20.46 +    mthdec(timebase_freq);
   20.47 +
   20.48 +#ifdef HDEC_PREEMPT
   20.49 +    raise_softirq(TIMER_SOFTIRQ);
   20.50 +#endif
   20.51 +#ifdef DEBUG
   20.52 +    {
   20.53 +        int d;
   20.54 +        if (regs->msr & MSR_HV) {
   20.55 +            d = -1;
   20.56 +        } else {
   20.57 +            d = get_current()->domain->domain_id;
   20.58 +        }
   20.59 +        extern char serial_getc_nb(int handle);
   20.60 +        if (0 && serial_getc_nb(0) > 0) {
   20.61 +            printk("H: pc: 0x%lx lr: 0x%lx \n", regs->pc, regs->lr);
   20.62 +        }
   20.63 +        if (hdec_sample)  {
   20.64 +            printk("H: pc: 0x%lx lr: 0x%lx \n", regs->pc, regs->lr);
   20.65 +            hdec_sample = 0;
   20.66 +        }
   20.67 +    }
   20.68 +#endif
   20.69 +}
   20.70 +
   20.71 +void do_dec(struct cpu_user_regs *regs)
   20.72 +{
   20.73 +    if (!(regs->msr & MSR_HV)) {
   20.74 +        panic("HV dec from domain\n");
   20.75 +    }
   20.76 +    printk("DEC_HV: pc: 0x%lx lr: 0x%lx \n", regs->pc, regs->lr);
   20.77 +    mtdec(INT_MAX);
   20.78 +}
   20.79 +
   20.80 +void program_exception(struct cpu_user_regs *regs, unsigned long cookie)
   20.81 +{
   20.82 +#ifdef CRASH_DEBUG
   20.83 +    __trap_to_gdb(regs, cookie);
   20.84 +#else /* CRASH_DEBUG */
   20.85 +    show_registers(regs);
   20.86 +    printk("dar 0x%016lx, dsisr 0x%08x\n", mfdar(), mfdsisr());
   20.87 +    printk("hid4 0x%016lx\n", regs->hid4);
   20.88 +    panic("%s: 0x%lx\n", __func__, cookie);
   20.89 +#endif /* CRASH_DEBUG */
   20.90 +}

    21.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    21.2 +++ b/xen/arch/powerpc/exceptions.h	Fri Jul 14 10:47:50 2006 +0100
    21.3 @@ -0,0 +1,57 @@
    21.4 +/*
    21.5 + * This program is free software; you can redistribute it and/or modify
    21.6 + * it under the terms of the GNU General Public License as published by
    21.7 + * the Free Software Foundation; either version 2 of the License, or
    21.8 + * (at your option) any later version.
    21.9 + *
   21.10 + * This program is distributed in the hope that it will be useful,
   21.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   21.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   21.13 + * GNU General Public License for more details.
   21.14 + *
   21.15 + * You should have received a copy of the GNU General Public License
   21.16 + * along with this program; if not, write to the Free Software
   21.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   21.18 + *
   21.19 + * Copyright (C) IBM Corp. 2005
   21.20 + *
   21.21 + * Authors: Hollis Blanchard <hollisb@us.ibm.com>
   21.22 + */
   21.23 +
   21.24 +#ifndef _ARCH_PPC_EXCEPTIONS_H_
   21.25 +#define _ARCH_PPC_EXCEPTIONS_H_
   21.26 +
   21.27 +#include <xen/types.h>
   21.28 +#include <public/xen.h>
   21.29 +#include <xen/multiboot.h>
   21.30 +
   21.31 +extern void do_hcall(struct cpu_user_regs *regs);
   21.32 +extern void do_IRQ(struct cpu_user_regs *regs);
   21.33 +extern void deliver_ee(struct cpu_user_regs *regs);
   21.34 +extern void do_external(struct cpu_user_regs *regs);
   21.35 +extern void init_IRQ(void);
   21.36 +extern void ack_APIC_irq(void);
   21.37 +extern int ioapic_guest_read(unsigned long physbase, unsigned int reg, u32 *pval);
   21.38 +extern int ioapic_guest_write(unsigned long physbase, unsigned int reg, u32 val);
   21.39 +extern void __start_xen_ppc(
   21.40 +    ulong r3, ulong r4, ulong r5, ulong r6, ulong r7, ulong orig_msr);
   21.41 +extern  multiboot_info_t *boot_of_init(ulong r3, ulong r4, ulong vec, ulong r6, ulong r7, ulong orig_msr);
   21.42 +
   21.43 +extern void do_timer(struct cpu_user_regs *regs);
   21.44 +extern void do_dec(struct cpu_user_regs *regs);
   21.45 +extern void program_exception(
   21.46 +    struct cpu_user_regs *regs, unsigned long cookie);
   21.47 +
   21.48 +extern long xen_hvcall_jump(struct cpu_user_regs *regs, ulong address);
   21.49 +extern void *mambo_memset(void *, int, ulong);
   21.50 +extern void *mambo_memcpy(void *, const void *, ulong);
   21.51 +
   21.52 +extern ulong *__hypercall_table[];
   21.53 +
   21.54 +extern char exception_vectors[];
   21.55 +extern char exception_vectors_end[];
   21.56 +extern int spin_start[];
   21.57 +extern int firmware_image_start[0];
   21.58 +extern int firmware_image_size[0];
   21.59 +
   21.60 +#endif

    22.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    22.2 +++ b/xen/arch/powerpc/external.c	Fri Jul 14 10:47:50 2006 +0100
    22.3 @@ -0,0 +1,247 @@
    22.4 +/*
    22.5 + * This program is free software; you can redistribute it and/or modify
    22.6 + * it under the terms of the GNU General Public License as published by
    22.7 + * the Free Software Foundation; either version 2 of the License, or
    22.8 + * (at your option) any later version.
    22.9 + *
   22.10 + * This program is distributed in the hope that it will be useful,
   22.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   22.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   22.13 + * GNU General Public License for more details.
   22.14 + *
   22.15 + * You should have received a copy of the GNU General Public License
   22.16 + * along with this program; if not, write to the Free Software
   22.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   22.18 + *
   22.19 + * Copyright (C) IBM Corp. 2005, 2006
   22.20 + *
   22.21 + * Authors: Jimi Xenidis <jimix@watson.ibm.com>
   22.22 + */
   22.23 +
   22.24 +#include <xen/config.h>
   22.25 +#include <xen/types.h>
   22.26 +#include <xen/sched.h>
   22.27 +#include <xen/lib.h>
   22.28 +#include <xen/event.h>
   22.29 +#include <xen/irq.h>
   22.30 +#include <public/xen.h>
   22.31 +#include <asm/current.h>
   22.32 +#include <asm/hardirq.h>
   22.33 +#include <asm/mpic.h>
   22.34 +#include "mpic_init.h"
   22.35 +#include "exceptions.h"
   22.36 +
   22.37 +#undef DEBUG
   22.38 +#ifdef DEBUG
   22.39 +#define DBG(fmt...) printk(fmt)
   22.40 +#else
   22.41 +#define DBG(fmt...)
   22.42 +#endif
   22.43 +
   22.44 +int vector_irq[NR_VECTORS] __read_mostly = { [0 ... NR_VECTORS - 1] = -1};
   22.45 +
   22.46 +unsigned long io_apic_irqs;
   22.47 +int ioapic_ack_new = 1;
   22.48 +
   22.49 +static struct hw_interrupt_type *hc_irq;
   22.50 +
   22.51 +/* deliver_ee: called with interrupts off when resuming every vcpu */
   22.52 +void deliver_ee(struct cpu_user_regs *regs)
   22.53 +{
   22.54 +    const ulong srr_mask = ~(MSR_IR | MSR_DR | MSR_FE0 | MSR_FE1 | MSR_EE |
   22.55 +                             MSR_RI |
   22.56 +                             MSR_BE | MSR_FP | MSR_PMM | MSR_PR | MSR_SE);
   22.57 +
   22.58 +    BUG_ON(mfmsr() & MSR_EE);
   22.59 +    BUG_ON(regs->msr & MSR_HV);
   22.60 +
   22.61 +    if (!local_events_need_delivery())
   22.62 +        return;
   22.63 +
   22.64 +    /* XXX OS error: EE was set but RI was not. We could trigger a machine
   22.65 +     * check, or kill the domain... for now just crash Xen so we notice. */
   22.66 +    BUG_ON(!(regs->msr & MSR_RI));
   22.67 +
   22.68 +    regs->srr0 = regs->pc;
   22.69 +    /* zero SRR1[33:36] and SRR1[42:47] */
   22.70 +    regs->srr1 = regs->msr & ~0x00000000783f0000;
   22.71 +    regs->pc = 0x500;
   22.72 +    regs->msr &= srr_mask;
   22.73 +    regs->msr |= MSR_SF | MSR_ME;
   22.74 +
   22.75 +    DBG("<HV: pc=0x%lx, msr=0x%lx\n", regs->pc, regs->msr);
   22.76 +}
   22.77 +
   22.78 +void do_external(struct cpu_user_regs *regs)
   22.79 +{
   22.80 +    int vec;
   22.81 +
   22.82 +    BUG_ON(!(regs->msr & MSR_EE));
   22.83 +    BUG_ON(mfmsr() & MSR_EE);
   22.84 +
   22.85 +    vec = xen_mpic_get_irq(regs);
   22.86 +
   22.87 +    if (vec != -1) {
   22.88 +        DBG("EE:0x%lx isrc: %d\n", regs->msr, vec);
   22.89 +        regs->entry_vector = vec;
   22.90 +        do_IRQ(regs);
   22.91 +
   22.92 +        BUG_ON(mfmsr() & MSR_EE);
   22.93 +    }
   22.94 +}
   22.95 +
   22.96 +static int xen_local_irq(unsigned int irq)
   22.97 +{
   22.98 +    irq_desc_t *desc;
   22.99 +    unsigned int vector;
  22.100 +
  22.101 +    vector = irq_to_vector(irq);
  22.102 +    desc = &irq_desc[vector];
  22.103 +
  22.104 +    return !(desc->status & IRQ_GUEST);
  22.105 +}
  22.106 +
  22.107 +static unsigned int xen_startup_irq(unsigned int irq)
  22.108 +{
  22.109 +    DBG("%s(%d)\n", __func__, irq);
  22.110 +    if (xen_local_irq(irq)) {
  22.111 +        return hc_irq->startup(irq);
  22.112 +    }
  22.113 +    return 0;
  22.114 +}
  22.115 +
  22.116 +static void xen_shutdown_irq(unsigned int irq)
  22.117 +{
  22.118 +    DBG("%s(%d)\n", __func__, irq);
  22.119 +    if (xen_local_irq(irq)) {
  22.120 +        hc_irq->shutdown(irq);
  22.121 +    }
  22.122 +}
  22.123 +
  22.124 +static void xen_enable_irq(unsigned int irq)
  22.125 +{
  22.126 +    DBG("%s(%d)\n", __func__, irq);
  22.127 +    if (xen_local_irq(irq)) {
  22.128 +        hc_irq->enable(irq);
  22.129 +    }
  22.130 +}
  22.131 +
  22.132 +static void xen_disable_irq(unsigned int irq)
  22.133 +{
  22.134 +    DBG("%s(%d)\n", __func__, irq);
  22.135 +    if (xen_local_irq(irq)) {
  22.136 +        hc_irq->disable(irq);
  22.137 +    }
  22.138 +}
  22.139 +    
  22.140 +static void xen_ack_irq(unsigned int irq)
  22.141 +{
  22.142 +    DBG("%s(%d)\n", __func__, irq);
  22.143 +    if (xen_local_irq(irq)) {
  22.144 +        if (hc_irq->ack) hc_irq->ack(irq);
  22.145 +    }
  22.146 +}
  22.147 +
  22.148 +static void xen_end_irq(unsigned int irq)
  22.149 +{
  22.150 +    DBG("%s(%d)\n", __func__, irq);
  22.151 +    if (xen_local_irq(irq)) {
  22.152 +        hc_irq->end(irq);
  22.153 +    }
  22.154 +}
  22.155 +
  22.156 +static void xen_set_affinity(unsigned int irq, cpumask_t mask)
  22.157 +{
  22.158 +    DBG("%s(%d)\n", __func__, irq);
  22.159 +    if (xen_local_irq(irq)) {
  22.160 +        if (hc_irq->set_affinity) hc_irq->set_affinity(irq, mask);
  22.161 +    }
  22.162 +}
  22.163 +
  22.164 +static struct hw_interrupt_type xen_irq = {
  22.165 +    .startup = xen_startup_irq,
  22.166 +    .enable = xen_enable_irq,
  22.167 +    .disable = xen_disable_irq,
  22.168 +    .shutdown = xen_shutdown_irq,
  22.169 +    .ack = xen_ack_irq,
  22.170 +    .end = xen_end_irq,
  22.171 +    .set_affinity = xen_set_affinity,
  22.172 +};
  22.173 +
  22.174 +void init_IRQ(void)
  22.175 +{
  22.176 +    hc_irq = xen_mpic_init(&xen_irq);
  22.177 +}
  22.178 +
  22.179 +void ack_APIC_irq(void)
  22.180 +{
  22.181 +    printk("%s: EOI the whole MPIC?\n", __func__);
  22.182 +    for (;;);
  22.183 +}
  22.184 +
  22.185 +void ack_bad_irq(unsigned int irq)
  22.186 +{
  22.187 +    printk("unexpected IRQ trap at vector %02x\n", irq);
  22.188 +    /*
  22.189 +     * Currently unexpected vectors happen only on SMP and APIC.
  22.190 +     * We _must_ ack these because every local APIC has only N
  22.191 +     * irq slots per priority level, and a 'hanging, unacked' IRQ
  22.192 +     * holds up an irq slot - in excessive cases (when multiple
  22.193 +     * unexpected vectors occur) that might lock up the APIC
  22.194 +     * completely.
  22.195 +     */
  22.196 +    ack_APIC_irq();
  22.197 +}
  22.198 +
  22.199 +extern void dump_ioapic_irq_info(void);
  22.200 +void dump_ioapic_irq_info(void)
  22.201 +{
  22.202 +    printk("%s: can't dump yet\n", __func__);
  22.203 +}
  22.204 +
  22.205 +/* irq_vectors is indexed by the sum of all RTEs in all I/O APICs. */
  22.206 +u8 irq_vector[NR_IRQ_VECTORS] __read_mostly = { FIRST_DEVICE_VECTOR , 0 };
  22.207 +int assign_irq_vector(int irq)
  22.208 +{
  22.209 +    static int current_vector = FIRST_DEVICE_VECTOR, offset = 0;
  22.210 +
  22.211 +    BUG_ON(irq >= NR_IRQ_VECTORS);
  22.212 +    if (irq != AUTO_ASSIGN && IO_APIC_VECTOR(irq) > 0)
  22.213 +        return IO_APIC_VECTOR(irq);
  22.214 +next:
  22.215 +    current_vector += 8;
  22.216 +
  22.217 +    /* Skip the hypercall vector. */
  22.218 +    if (current_vector == HYPERCALL_VECTOR)
  22.219 +        goto next;
  22.220 +
  22.221 +    /* Skip the Linux/BSD fast-trap vector. */
  22.222 +    if (current_vector == FAST_TRAP)
  22.223 +        goto next;
  22.224 +
  22.225 +    if (current_vector >= FIRST_SYSTEM_VECTOR) {
  22.226 +        offset++;
  22.227 +        if (!(offset%8))
  22.228 +            return -ENOSPC;
  22.229 +        current_vector = FIRST_DEVICE_VECTOR + offset;
  22.230 +    }
  22.231 +
  22.232 +    vector_irq[current_vector] = irq;
  22.233 +    if (irq != AUTO_ASSIGN)
  22.234 +        IO_APIC_VECTOR(irq) = current_vector;
  22.235 +
  22.236 +    return current_vector;
  22.237 +}
  22.238 +
  22.239 +int ioapic_guest_read(unsigned long physbase, unsigned int reg, u32 *pval)
  22.240 +{
  22.241 +    BUG_ON(pval != pval);
  22.242 +
  22.243 +    return 0;
  22.244 +}
  22.245 +
  22.246 +int ioapic_guest_write(unsigned long physbase, unsigned int reg, u32 val)
  22.247 +{
  22.248 +    BUG_ON(val != val);
  22.249 +    return 0;
  22.250 +}

    23.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    23.2 +++ b/xen/arch/powerpc/float.S	Fri Jul 14 10:47:50 2006 +0100
    23.3 @@ -0,0 +1,243 @@
    23.4 +/*
    23.5 + * Copyright (C) 2005 Jimi Xenidis <jimix@watson.ibm.com>, IBM Corporation
    23.6 + *
    23.7 + * This program is free software; you can redistribute it and/or modify
    23.8 + * it under the terms of the GNU General Public License as published by
    23.9 + * the Free Software Foundation; either version 2 of the License, or
   23.10 + * (at your option) any later version.
   23.11 + * 
   23.12 + * This program is distributed in the hope that it will be useful,
   23.13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   23.14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   23.15 + * GNU General Public License for more details.
   23.16 + * 
   23.17 + * You should have received a copy of the GNU General Public License
   23.18 + * along with this program; if not, write to the Free Software
   23.19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
   23.20 + */
   23.21 +
   23.22 +#include <asm/config.h>
   23.23 +#include <asm/asm-offsets.h>
   23.24 +#include <asm/reg_defs.h>
   23.25 +#include <asm/msr.h>
   23.26 +#include <asm/processor.h>
   23.27 +
   23.28 +#ifdef HAS_FLOAT
   23.29 +save_fp:
   23.30 +	addi	r4, r3, VCPU_fprs - FPR_WIDTH
   23.31 +	stfdu	fr0,FPR_WIDTH(r4)
   23.32 +	stfdu	fr1,FPR_WIDTH(r4)
   23.33 +	stfdu	fr2,FPR_WIDTH(r4)
   23.34 +	stfdu	fr3,FPR_WIDTH(r4)
   23.35 +	stfdu	fr4,FPR_WIDTH(r4)
   23.36 +	stfdu	fr5,FPR_WIDTH(r4)
   23.37 +	stfdu	fr6,FPR_WIDTH(r4)
   23.38 +	stfdu	fr7,FPR_WIDTH(r4)
   23.39 +	stfdu	fr8,FPR_WIDTH(r4)
   23.40 +	stfdu	fr9,FPR_WIDTH(r4)
   23.41 +	stfdu	fr10,FPR_WIDTH(r4)
   23.42 +	stfdu	fr11,FPR_WIDTH(r4)
   23.43 +	stfdu	fr12,FPR_WIDTH(r4)
   23.44 +	stfdu	fr13,FPR_WIDTH(r4)
   23.45 +	stfdu	fr14,FPR_WIDTH(r4)
   23.46 +	stfdu	fr15,FPR_WIDTH(r4)
   23.47 +	stfdu	fr16,FPR_WIDTH(r4)
   23.48 +	stfdu	fr17,FPR_WIDTH(r4)
   23.49 +	stfdu	fr18,FPR_WIDTH(r4)
   23.50 +	stfdu	fr19,FPR_WIDTH(r4)
   23.51 +	stfdu	fr20,FPR_WIDTH(r4)
   23.52 +	stfdu	fr21,FPR_WIDTH(r4)
   23.53 +	stfdu	fr22,FPR_WIDTH(r4)
   23.54 +	stfdu	fr23,FPR_WIDTH(r4)
   23.55 +	stfdu	fr24,FPR_WIDTH(r4)
   23.56 +	stfdu	fr25,FPR_WIDTH(r4)
   23.57 +	stfdu	fr26,FPR_WIDTH(r4)
   23.58 +	stfdu	fr27,FPR_WIDTH(r4)
   23.59 +	stfdu	fr28,FPR_WIDTH(r4)
   23.60 +	stfdu	fr29,FPR_WIDTH(r4)
   23.61 +	stfdu	fr30,FPR_WIDTH(r4)
   23.62 +	stfdu	fr31,FPR_WIDTH(r4)
   23.63 +	mffs	fr0
   23.64 +	stfd	fr0,VCPU_fpscr(r3)
   23.65 +	blr
   23.66 +
   23.67 +load_fp:
   23.68 +	lfd	fr0,VCPU_fpscr(r3)
   23.69 +	mtfsf	0xff,fr0
   23.70 +
   23.71 +	addi	r4, r3, VCPU_fprs - FPR_WIDTH
   23.72 +	lfdu	fr0,FPR_WIDTH(r4)
   23.73 +	lfdu	fr1,FPR_WIDTH(r4)
   23.74 +	lfdu	fr2,FPR_WIDTH(r4)
   23.75 +	lfdu	fr3,FPR_WIDTH(r4)
   23.76 +	lfdu	fr4,FPR_WIDTH(r4)
   23.77 +	lfdu	fr5,FPR_WIDTH(r4)
   23.78 +	lfdu	fr6,FPR_WIDTH(r4)
   23.79 +	lfdu	fr7,FPR_WIDTH(r4)
   23.80 +	lfdu	fr8,FPR_WIDTH(r4)
   23.81 +	lfdu	fr9,FPR_WIDTH(r4)
   23.82 +	lfdu	fr10,FPR_WIDTH(r4)
   23.83 +	lfdu	fr11,FPR_WIDTH(r4)
   23.84 +	lfdu	fr12,FPR_WIDTH(r4)
   23.85 +	lfdu	fr13,FPR_WIDTH(r4)
   23.86 +	lfdu	fr14,FPR_WIDTH(r4)
   23.87 +	lfdu	fr15,FPR_WIDTH(r4)
   23.88 +	lfdu	fr16,FPR_WIDTH(r4)
   23.89 +	lfdu	fr17,FPR_WIDTH(r4)
   23.90 +	lfdu	fr18,FPR_WIDTH(r4)
   23.91 +	lfdu	fr19,FPR_WIDTH(r4)
   23.92 +	lfdu	fr20,FPR_WIDTH(r4)
   23.93 +	lfdu	fr21,FPR_WIDTH(r4)
   23.94 +	lfdu	fr22,FPR_WIDTH(r4)
   23.95 +	lfdu	fr23,FPR_WIDTH(r4)
   23.96 +	lfdu	fr24,FPR_WIDTH(r4)
   23.97 +	lfdu	fr25,FPR_WIDTH(r4)
   23.98 +	lfdu	fr26,FPR_WIDTH(r4)
   23.99 +	lfdu	fr27,FPR_WIDTH(r4)
  23.100 +	lfdu	fr28,FPR_WIDTH(r4)
  23.101 +	lfdu	fr29,FPR_WIDTH(r4)
  23.102 +	lfdu	fr30,FPR_WIDTH(r4)
  23.103 +	lfdu	fr31,FPR_WIDTH(r4)
  23.104 +	blr
  23.105 +#endif /* HAS_FLOAT */
  23.106 +
  23.107 +#ifdef HAS_VMX
  23.108 +
  23.109 +#define VCPU_vr(n) (VCPU_vrs + ((n) * 16))
  23.110 +
  23.111 +/*
  23.112 + * We cannot rely on the domain to correctly use VRSAVE
  23.113 + * so it is required that all VMX registers are saved and restored.
  23.114 + */
  23.115 +save_vmx:
  23.116 +	mfspr	r0,SPRN_VRSAVE
  23.117 +	stw	r0,VCPU_vrsave(r3)
  23.118 +
  23.119 +	addi r0,r3,VCPU_vr(0);	stvxl	vr0,0,r0
  23.120 +	addi r0,r3,VCPU_vr(1);	stvxl	vr1,0,r0
  23.121 +	addi r0,r3,VCPU_vr(2);	stvxl	vr2,0,r0
  23.122 +	addi r0,r3,VCPU_vr(3);	stvxl	vr3,0,r0
  23.123 +	addi r0,r3,VCPU_vr(4);	stvxl	vr4,0,r0
  23.124 +	addi r0,r3,VCPU_vr(5);	stvxl	vr5,0,r0
  23.125 +	addi r0,r3,VCPU_vr(6);	stvxl	vr6,0,r0
  23.126 +	addi r0,r3,VCPU_vr(7);	stvxl	vr7,0,r0
  23.127 +	addi r0,r3,VCPU_vr(8);	stvxl	vr8,0,r0
  23.128 +
  23.129 +	/*
  23.130 +	 * By now vr0 should be pushed out so now is a good time to
  23.131 +	 * get the VRSCR which can take a long time and has no dependcies
  23.132 +	 * on the following operations.
  23.133 +	 */
  23.134 +	mfvscr	vr0
  23.135 +	addi r0,r3,VCPU_vscr ;	stvxl	vr0,0,r0
  23.136 +
  23.137 +	addi r0,r3,VCPU_vr(9);	stvxl	vr9,0,r0
  23.138 +	addi r0,r3,VCPU_vr(10);	stvxl	vr10,0,r0
  23.139 +	addi r0,r3,VCPU_vr(11);	stvxl	vr11,0,r0
  23.140 +	addi r0,r3,VCPU_vr(12);	stvxl	vr12,0,r0
  23.141 +	addi r0,r3,VCPU_vr(13);	stvxl	vr13,0,r0
  23.142 +	addi r0,r3,VCPU_vr(14);	stvxl	vr14,0,r0
  23.143 +	addi r0,r3,VCPU_vr(15);	stvxl	vr15,0,r0
  23.144 +	addi r0,r3,VCPU_vr(16);	stvxl	vr16,0,r0
  23.145 +	addi r0,r3,VCPU_vr(17);	stvxl	vr17,0,r0
  23.146 +	addi r0,r3,VCPU_vr(18);	stvxl	vr18,0,r0
  23.147 +	addi r0,r3,VCPU_vr(19);	stvxl	vr19,0,r0
  23.148 +	addi r0,r3,VCPU_vr(20);	stvxl	vr20,0,r0
  23.149 +	addi r0,r3,VCPU_vr(21);	stvxl	vr21,0,r0
  23.150 +	addi r0,r3,VCPU_vr(22);	stvxl	vr22,0,r0
  23.151 +	addi r0,r3,VCPU_vr(23);	stvxl	vr23,0,r0
  23.152 +	addi r0,r3,VCPU_vr(24);	stvxl	vr24,0,r0
  23.153 +	addi r0,r3,VCPU_vr(25);	stvxl	vr25,0,r0
  23.154 +	addi r0,r3,VCPU_vr(26);	stvxl	vr26,0,r0
  23.155 +	addi r0,r3,VCPU_vr(27);	stvxl	vr27,0,r0
  23.156 +	addi r0,r3,VCPU_vr(28);	stvxl	vr28,0,r0
  23.157 +	addi r0,r3,VCPU_vr(29);	stvxl	vr29,0,r0
  23.158 +	addi r0,r3,VCPU_vr(30);	stvxl	vr30,0,r0
  23.159 +	addi r0,r3,VCPU_vr(31);	stvxl	vr31,0,r0
  23.160 +	blr
  23.161 +
  23.162 +load_vmx:
  23.163 +	lwz	r0,VCPU_vrsave(r3)
  23.164 +	mtspr	SPRN_VRSAVE,r0
  23.165 +
  23.166 +	/*
  23.167 +	 * This operation can take a long time so we use vr31 to
  23.168 +	 * eliminate the depency on r0 for the next load
  23.169 +	 */
  23.170 +	addi r0,r3,VCPU_vscr ;	lvxl	vr31,0,r0
  23.171 +	mtvscr	vr31
  23.172 +
  23.173 +	addi r0,r3,VCPU_vr(0);	lvxl	vr0,0,r0
  23.174 +	addi r0,r3,VCPU_vr(1);	lvxl	vr1,0,r0
  23.175 +	addi r0,r3,VCPU_vr(2);	lvxl	vr2,0,r0
  23.176 +	addi r0,r3,VCPU_vr(3);	lvxl	vr3,0,r0
  23.177 +	addi r0,r3,VCPU_vr(4);	lvxl	vr4,0,r0
  23.178 +	addi r0,r3,VCPU_vr(5);	lvxl	vr5,0,r0
  23.179 +	addi r0,r3,VCPU_vr(6);	lvxl	vr6,0,r0
  23.180 +	addi r0,r3,VCPU_vr(7);	lvxl	vr7,0,r0
  23.181 +	addi r0,r3,VCPU_vr(8);	lvxl	vr8,0,r0
  23.182 +	addi r0,r3,VCPU_vr(9);	lvxl	vr9,0,r0
  23.183 +	addi r0,r3,VCPU_vr(10);	lvxl	vr10,0,r0
  23.184 +	addi r0,r3,VCPU_vr(11);	lvxl	vr11,0,r0
  23.185 +	addi r0,r3,VCPU_vr(12);	lvxl	vr12,0,r0
  23.186 +	addi r0,r3,VCPU_vr(13);	lvxl	vr13,0,r0
  23.187 +	addi r0,r3,VCPU_vr(14);	lvxl	vr14,0,r0
  23.188 +	addi r0,r3,VCPU_vr(15);	lvxl	vr15,0,r0
  23.189 +	addi r0,r3,VCPU_vr(16);	lvxl	vr16,0,r0
  23.190 +	addi r0,r3,VCPU_vr(17);	lvxl	vr17,0,r0
  23.191 +	addi r0,r3,VCPU_vr(18);	lvxl	vr18,0,r0
  23.192 +	addi r0,r3,VCPU_vr(19);	lvxl	vr19,0,r0
  23.193 +	addi r0,r3,VCPU_vr(20);	lvxl	vr20,0,r0
  23.194 +	addi r0,r3,VCPU_vr(21);	lvxl	vr21,0,r0
  23.195 +	addi r0,r3,VCPU_vr(22);	lvxl	vr22,0,r0
  23.196 +	addi r0,r3,VCPU_vr(23);	lvxl	vr23,0,r0
  23.197 +	addi r0,r3,VCPU_vr(24);	lvxl	vr24,0,r0
  23.198 +	addi r0,r3,VCPU_vr(25);	lvxl	vr25,0,r0
  23.199 +	addi r0,r3,VCPU_vr(26);	lvxl	vr26,0,r0
  23.200 +	addi r0,r3,VCPU_vr(27);	lvxl	vr27,0,r0
  23.201 +	addi r0,r3,VCPU_vr(28);	lvxl	vr28,0,r0
  23.202 +	addi r0,r3,VCPU_vr(29);	lvxl	vr29,0,r0
  23.203 +	addi r0,r3,VCPU_vr(30);	lvxl	vr30,0,r0
  23.204 +	addi r0,r3,VCPU_vr(31);	lvxl	vr31,0,r0
  23.205 +	blr
  23.206 +#endif /* HAS_VMX */
  23.207 +
  23.208 +/* void save_float(struct exec_domain *ed) */
  23.209 +_GLOBAL(save_float)
  23.210 +	mflr	r8
  23.211 +#ifdef HAS_FLOAT
  23.212 +	mfmsr	r9		# save msr
  23.213 +	ori	r0,r9,MSR_FP	# turn on FPU
  23.214 +	mtmsr	r0
  23.215 +	bl	save_fp		# uses r3, r4
  23.216 +	mtmsr	r9		# restore msr
  23.217 +#endif /* HAS_FLOAT */
  23.218 +#ifdef HAS_VMX
  23.219 +	mfmsr	r9		# save msr
  23.220 +	oris	r0,r9,MSR_VMX@h	# turn on VMX
  23.221 +	mtmsr	r0
  23.222 +	bl	save_vmx	# uses r3
  23.223 +	mtmsr	r9		# restore msr
  23.224 +#endif /* HAS_VMX */
  23.225 +	mtlr	r8
  23.226 +	blr
  23.227 +
  23.228 +/* void load_float(struct exec_domain *ed) */
  23.229 +_GLOBAL(load_float)
  23.230 +	mflr	r8
  23.231 +#ifdef HAS_FLOAT
  23.232 +	mfmsr	r9		# save msr
  23.233 +	ori	r0,r9,MSR_FP	# turn on FPU
  23.234 +	mtmsr	r0
  23.235 +	bl	load_fp	# uses r3, r4
  23.236 +	mtmsr	r9		# restore msr
  23.237 +#endif /* HAS_FLOAT */
  23.238 +#ifdef HAS_VMX
  23.239 +	mfmsr	r9		# save msr
  23.240 +	oris	r0,r9,MSR_VMX@h	# turn on VMX
  23.241 +	mtmsr	r0
  23.242 +	bl	load_vmx	# uses r3
  23.243 +	mtmsr	r9		# restore msr
  23.244 +#endif /* HAS_VMX */
  23.245 +	mtlr	r8
  23.246 +	blr

    24.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    24.2 +++ b/xen/arch/powerpc/gdbstub.c	Fri Jul 14 10:47:50 2006 +0100
    24.3 @@ -0,0 +1,207 @@
    24.4 +/*
    24.5 + * This program is free software; you can redistribute it and/or modify
    24.6 + * it under the terms of the GNU General Public License as published by
    24.7 + * the Free Software Foundation; either version 2 of the License, or
    24.8 + * (at your option) any later version.
    24.9 + *
   24.10 + * This program is distributed in the hope that it will be useful,
   24.11 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
   24.12 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   24.13 + * GNU General Public License for more details.
   24.14 + *
   24.15 + * You should have received a copy of the GNU General Public License
   24.16 + * along with this program; if not, write to the Free Software
   24.17 + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   24.18 + *
   24.19 + * Copyright (C) IBM Corp. 2005
   24.20 + *
   24.21 + * Authors: Hollis Blanchard <hollisb@us.ibm.com>
   24.22 + */
   24.23 +
   24.24 +#include <xen/types.h>
   24.25 +#include <xen/lib.h>
   24.26 +#include <xen/gdbstub.h>
   24.27 +#include <public/xen.h>
   24.28 +#include <asm/msr.h>
   24.29 +#include <asm/bitops.h>
   24.30 +#include <asm/cache.h>
   24.31 +#include <asm/processor.h>
   24.32 +
   24.33 +asm(".globl trap_instruction\n"
   24.34 +        "trap_instruction:\n"
   24.35 +        "trap\n");
   24.36 +extern u32 trap_instruction[];
   24.37 +
   24.38 +static unsigned int dec_entry;
   24.39 +static unsigned int hdec_entry;
   24.40 +
   24.41 +static inline ulong
   24.42 +gdb_ppc_0x700(struct cpu_user_regs *state)
   24.43 +{
   24.44 +    ulong instr;
   24.45 +
   24.46 +    switch (state->msr & MSR_TRAP_BITS) {
   24.47 +        case MSR_TRAP_FE:
   24.48 +            return SIGFPE;
   24.49 +        case MSR_TRAP_IOP:
   24.50 +        case MSR_TRAP_PRIV:
   24.51 +            return SIGILL;
   24.52 +        case MSR_TRAP:
   24.53 +            instr = *((u32 *)state->pc);
   24.54 +
   24.55 +            /* if this was a hardcoded trap in the source, step past it */
   24.56 +            if (instr == *trap_instruction) {
   24.57 +                state->pc += sizeof (u32);
   24.58 +            }
   24.59 +            return SIGTRAP;
   24.60 +    }
   24.61 +    return SIGBUS;
   24.62 +}
   24.63 +
   24.64 +u16 gdb_arch_signal_num(struct cpu_user_regs *regs, unsigned long cookie)
   24.65 +{
   24.66 +    /* exception type identifies, trap or bad address */
   24.67 +    switch (cookie) {
   24.68 +        case 0x200: /* Machine Check */
   24.69 +            return SIGTERM;
   24.70 +        case 0x300: /* DSI */
   24.71 +        case 0x380: /* Data SLB */
   24.72 +        case 0x400: /* ISI */
   24.73 +        case 0x480: /* Instruction SLB */
   24.74 +            return SIGSEGV;
   24.75 +        case 0x600: /* Alignment SLB */
   24.76 +            return SIGBUS;
   24.77 +        case 0x700: /* Program */
   24.78 +            return gdb_ppc_0x700(regs);
   24.79 +        case 0x800: /* Float */
   24.80 +            return SIGFPE;
   24.81 +        case 0x900: /* Decrementer */
   24.82 +            return SIGALRM; /* is this right? */
   24.83 +        case 0xd00: /* TRAP */
   24.84 +            return SIGTRAP;
   24.85 +        case 0xe00: /* FP */
   24.86 +            return SIGFPE;
   24.87 +    }
   24.88 +    return SIGBUS;
   24.89 +}
   24.90 +
   24.91 +void
   24.92 +gdb_arch_resume(struct cpu_user_regs *regs,
   24.93 +                unsigned long addr, unsigned long type,
   24.94 +                struct gdb_context *ctx)
   24.95 +{
   24.96 +    if (addr != ~((ulong)0)) {
   24.97 +        regs->pc = addr;
   24.98 +    }
   24.99 +
  24.100 +    if (type == GDB_CONTINUE) {
  24.101 +        regs->msr &= ~MSR_SE;
  24.102 +    } else {
  24.103 +        regs->msr |= MSR_SE;
  24.104 +    }
  24.105 +}
  24.106 +
  24.107 +void 
  24.108 +gdb_arch_read_reg(unsigned long regnum, struct cpu_user_regs *regs,
  24.109 +                  struct gdb_context *ctx)
  24.110 +{
  24.111 +    unimplemented();
  24.112 +    gdb_send_reply("", ctx);
  24.113 +}
  24.114 +
  24.115 +void
  24.116 +gdb_arch_read_reg_array(struct cpu_user_regs *state, struct gdb_context *ctx)
  24.117 +{
  24.118 +    ulong i = 0;
  24.119 +
  24.120 +    for (i = 0; i < 32; ++i) {
  24.121 +        gdb_write_to_packet_hex(state->gprs[i], sizeof(state->gprs[i]), ctx);
  24.122 +    }
  24.123 +    /* Avoid floating point for now */
  24.124 +    for (i = 0; i < 32; ++i) {
  24.125 +        gdb_write_to_packet_hex(0, sizeof(u64), ctx);
  24.126 +    }
  24.127 +    gdb_write_to_packet_hex(state->pc, sizeof (state->pc), ctx);
  24.128 +    gdb_write_to_packet_hex(state->msr, sizeof (state->msr), ctx);
  24.129 +    gdb_write_to_packet_hex(state->cr, sizeof (state->cr), ctx);
  24.130 +    gdb_write_to_packet_hex(state->lr, sizeof (state->lr), ctx);
  24.131 +    gdb_write_to_packet_hex(state->ctr, sizeof (state->ctr), ctx);
  24.132 +    gdb_write_to_packet_hex(state->xer, sizeof (u32), ctx);
  24.133 +    gdb_write_to_packet_hex(0, sizeof(u32), ctx); /* fpscr */
  24.134 +    gdb_send_packet(ctx);
  24.135 +}
  24.136 +
  24.137 +void
  24.138 +gdb_arch_write_reg_array(struct cpu_user_regs *regs, const char *buf,
  24.139 +                         struct gdb_context *ctx)
  24.140 +{
  24.141 +    ulong i;
  24.142 +
  24.143 +    for (i = 0; i < 32; ++i) {
  24.144 +        regs->gprs[i] = str2ulong(buf, sizeof (ulong));
  24.145 +        buf += sizeof (regs->gprs[0]) * 2;
  24.146 +    }
  24.147 +    /* Avoid floating point for now */
  24.148 +    for (i = 0; i < 32; ++i) {
  24.149 +        buf += sizeof (u64) * 2;
  24.150 +    }
  24.151 +
  24.152 +    regs->pc = str2ulong(buf, sizeof (regs->pc));
  24.153 +    buf += sizeof (regs->pc) * 2;
  24.154 +    regs->msr = str2ulong(buf, sizeof (regs->msr));
  24.155 +    buf += sizeof (regs->msr) * 2;
  24.156 +    regs->cr = str2ulong(buf, sizeof (regs->cr));
  24.157 +    buf += sizeof (regs->cr) * 2;
  24.158 +    regs->lr = str2ulong(buf, sizeof (regs->lr));
  24.159 +    buf += sizeof (regs->lr) * 2;
  24.160 +    regs->ctr = str2ulong(buf, sizeof (regs->ctr));
  24.161 +    buf += sizeof (regs->ctr) * 2;
  24.162 +    regs->xer = str2ulong(buf, sizeof (u32));
  24.163 +    buf += sizeof (u32) * 2;
  24.164 +}
  24.165 +
  24.166 +unsigned int
  24.167 +gdb_arch_copy_from_user(void *dest, const void *src, unsigned len)
  24.168 +{
  24.169 +    memcpy(dest, src, len);
  24.170 +    return 0;
  24.171 +}
  24.172 +
  24.173 +unsigned int
  24.174 +gdb_arch_copy_to_user(void *dest, const void *src, unsigned len)
  24.175 +{
  24.176 +    memcpy(dest, src, len);
  24.177 +    synchronize_caches((ulong)dest, len);
  24.178 +    return 0;
  24.179 +}
  24.180 +
  24.181 +void
  24.182 +gdb_arch_print_state(struct cpu_user_regs *state)
  24.183 +{
  24.184 +    int i = 0;
  24.185 +    printk("PC: 0x%016lx MSR: 0x%016lx\n", state->pc, state->msr);
  24.186 +    printk("LR: 0x%016lx CTR: 0x%016lx\n", state->lr, state->ctr);
  24.187 +    /* XXX
  24.188 +       printk("DAR: 0x%016lx DSISR: 0x%016lx\n", state->dar, state->dsisr);
  24.189 +       */
  24.190 +    printk("CR: 0x%08x XER: 0x%016lx\n", state->cr, state->xer);
  24.191 +    for (; i < 32; i+=4) {
  24.192 +        printk("%02d: 0x%016lx 0x%016lx 0x%016lx 0x%016lx\n",
  24.193 +                i, state->gprs[i], state->gprs[i+1],
  24.194 +                state->gprs[i+2], state->gprs[i+3]);
  24.195 +    }
  24.196 +}
  24.197 +
  24.198 +void
  24.199 +gdb_arch_enter(struct cpu_user_regs *state)
  24.200 +{
  24.201 +    dec_entry = mfdec();
  24.202 +    hdec_entry = mfhdec();
  24.203 +}
  24.204 +
  24.205 +void
  24.206 +gdb_arch_exit(struct cpu_user_regs *state)
  24.207 +{
  24.208 +    mtdec(dec_entry);
  24.209 +    mthdec(hdec_entry);
  24.210 +}