/*      $NetBSD: loadfile_machdep.c,v 1.2 2022/07/10 14:18:27 thorpej Exp $     */

/*-
* Copyright (c) 2021 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Jason R. Thorpe.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include "boot.h"

#include <sys/param.h>
#include <sys/boot_flag.h>
#include <sys/disklabel.h>

#include <lib/libsa/stand.h>
#include <lib/libsa/loadfile.h>
#include <lib/libkern/libkern.h>

#include "openfirm.h"

#ifdef KMAPPING_DEBUG
#define DPRINTF         printf
#else
#define DPRINTF         while (0) printf
#endif

static int
ofw_claimphys(paddr_t pa, vsize_t size)
{
       /* (2) phys, (2) size, (1) align -> 2 (phys) */
       uint32_t cells[2+2+1+2];
       uint32_t *p = cells;
       paddr_t result;

       if (ofw_address_cells == 2) {
               *p++ = ((uint64_t)pa) >> 32;
               *p++ = (uint32_t)pa;
       } else {
               *p++ = (uint32_t)pa;
       }

#if 0   /* No known Mac systems with 2. */
       if (ofw_size_cells == 2) {
               *p++ = ((uint64_t)size) >> 32;
               *p++ = (uint32_t)size;
       } else
#endif
               *p++ = (uint32_t)size;

       *p++ = 0;       /* align */

       if (OF_call_method("claim", ofw_memory_ihandle,
                          ofw_address_cells + ofw_size_cells + 1,
                          ofw_address_cells, (int *)cells) == -1) {
               return -1;
       }

       if (ofw_address_cells == 2) {
               uint64_t v;
               v = (uint64_t)(*p++) << 32;
               v |= *p++;
               result = (paddr_t)v;
       } else {
               result = *p++;
       }

       if (result != pa) {
               printf("!!! CLAIM PHYS 0x%lx RETURNED 0x%lx\n",
                   pa, result);
               return -1;
       }

       return 0;
}

static int
ofw_releasephys(paddr_t pa, vsize_t size)
{
       /* (2) phys, (2) size, -> nil */
       uint32_t cells[2+2];
       uint32_t *p = cells;

       if (ofw_address_cells == 2) {
               *p++ = ((uint64_t)pa) >> 32;
               *p++ = (uint32_t)pa;
       } else {
               *p++ = (uint32_t)pa;
       }

#if 0   /* No known Mac systems with 2. */
       if (ofw_size_cells == 2) {
               *p++ = ((uint64_t)size) >> 32;
               *p++ = (uint32_t)size;
       } else
#endif
               *p++ = (uint32_t)size;

       if (OF_call_method("release", ofw_memory_ihandle,
                          ofw_address_cells + ofw_size_cells,
                          0, (int *)cells) == -1) {
               return -1;
       }

       return 0;
}

static int
ofw_claimvirt(vaddr_t va, vsize_t size)
{
       /* (1) virt, (1) size, (1) align -> (1) virt */
       uint32_t cells[1+1+1+1];
       uint32_t *p = cells;
       vaddr_t result;

       *p++ = va;
       *p++ = size;
       *p++ = 0;               /* align */

       if (OF_call_method("claim", ofw_mmu_ihandle,
                          3, 1, (int *)cells) == -1) {
               return -1;
       }

       result = *p++;

       if (result != va) {
               printf("!!! CLAIM VIRT 0x%lx RETURNED 0x%lx\n",
                   va, result);
               return -1;
       }

       return 0;
}

static int
ofw_releasevirt(vaddr_t va, vsize_t size)
{
       /* (1) virt, (1) size -> nil */
       uint32_t cells[1+1];
       uint32_t *p = cells;

       *p++ = va;
       *p++ = size;

       if (OF_call_method("release", ofw_mmu_ihandle,
                          2, 0, (int *)cells) == -1) {
               return -1;
       }

       return 0;
}

static int
ofw_map(vaddr_t va, paddr_t pa, vsize_t size)
{
       /* (2) phys, (1) virt, (1) size, (1) mode -> nil */
       uint32_t cells[2+1+1+1];
       uint32_t *p = cells;

       if (ofw_address_cells == 2) {
               *p++ = ((uint64_t)pa) >> 32;
               *p++ = (uint32_t)pa;
       } else {
               *p++ = (uint32_t)pa;
       }

       *p++ = va;
       *p++ = size;
       *p++ = 0x00000010 /* PTE_SO | PTE_M */; /* XXX magic numbers */

       if (OF_call_method("map", ofw_mmu_ihandle,
                          ofw_address_cells + 3, 0, (int *)cells) == -1) {
               return -1;
       }

       return 0;
}

static int
ofw_create_mapping(vaddr_t va, paddr_t pa, vsize_t size)
{
       if (ofw_claimphys(pa, size) == -1) {
               printf("!!! FAILED TO CLAIM PHYS 0x%lx size 0x%lx\n",
                   pa, size);
               return -1;
       }

       /*
        * If we're running in real-mode, the claimphys is enough.
        */
       if (ofw_real_mode) {
               return 0;
       }

       if (ofw_claimvirt(va, size) == -1) {
               printf("!!! FAILED TO CLAIM VIRT 0x%lx size 0x%lx\n",
                   va, size);
               ofw_releasephys(pa, size);
               return -1;
       }
       if (ofw_map(va, pa, size) == -1) {
               printf("!!! FAILED TO MAP PHYS 0x%lx @ 0x%lx size 0x%lx\n",
                   pa, va, size);
               ofw_releasevirt(va, size);
               ofw_releasephys(pa, size);
               return -1;
       }

       return 0;
}

/*
* This structure describes a physically contiguous mapping
* for the loaded kernel.  We assume VA==PA, which would be
* equivalent to running in real-mode.
*/
#define MAX_KMAPPINGS   64
struct kmapping {
       vaddr_t         vstart;
       vaddr_t         vend;
} kmappings[MAX_KMAPPINGS];

#define TRUNC_PAGE(x)   ((x) & ~((unsigned long)NBPG - 1))
#define ROUND_PAGE(x)   TRUNC_PAGE((x) + (NBPG - 1))

/*
* Enter a mapping for the loaded kernel.  If the start is within an
* already mapped region, or if it starts immediately following a
* previous region, we extend it.
*/
static int
kmapping_enter(vaddr_t va, vsize_t size)
{
       struct kmapping *km, *km_prev, *km_next, *km_last;
       vaddr_t va_end;
       int i;

       km_last = &kmappings[MAX_KMAPPINGS - 1];

       /* Round the region to a page. */
       va_end = ROUND_PAGE(va + size);

       /* Truncate the region to the nearest page boundary. */
       va = TRUNC_PAGE(va);

       /* Get the rounded size. */
       size = va_end - va;

       DPRINTF("kmapping_enter: va=0x%lx size=0x%lx\n",
           va, size);

       /* Check to see if there's an overlapping entry in the table. */
       for (i = 0, km_prev = NULL; i < MAX_KMAPPINGS; i++, km_prev = km) {
               km = &kmappings[i];
               km_next = (km == km_last) ? NULL : (km + 1);

               if (km->vstart == km->vend) {
                       /*
                        * Found an empty slot.  We are guaranteed there
                        * is not slot after this to merge with.
                        */
                       DPRINTF("!!! entering into empty slot (%d)\n", i);
                       goto enter_new;
               }

               if (va >= km->vstart) {
                       if (va_end <= km->vend) {
                               /* This region is already fully mapped. */
                               DPRINTF("!!! matches existing region "
                                      "va=0x%lx-0x%lx\n",
                                      km->vstart, km->vend);
                               return 0;
                       }
                       if (va > km->vend) {
                               /* Requested region falls after this one. */
                               continue;
                       }

                       /*
                        * We will extend this region.  Adjust the
                        * start and size.
                        */
                       va = km->vend;
                       size = va_end - va;

                       /*
                        * If there is a slot after this one and it's
                        * not empty, see if these two can be merged.
                        */
                       if (km_next != NULL &&
                           km_next->vstart != km_next->vend &&
                           va_end >= km_next->vstart) {
                               if (va_end > km_next->vend) {
                                       /* Crazy! */
                                       printf("!!! GOBBLED UP KM_NEXT!\n");
                                       return 1;
                               }
                               va_end = km_next->vstart;
                               size = va_end - va;

                               DPRINTF("!!! merging va=0x%lx-0x%lx and "
                                      "va=0x%lx-0x%lx\n",
                                      km->vstart, km->vend,
                                      km_next->vstart, km_next->vend);
                               goto merge_two;
                       }

                       DPRINTF("!!! extending existing region "
                              "va=0x%lx-0x%lx to "
                              "va=0x%lx-0x%lx\n",
                              km->vstart, km->vend,
                              km->vstart, va_end);
                       goto extend_existing;
               }

               /*
                * We know that the new region starts before the current
                * one.  Check to see of the end overlaps.
                */
               if (va_end >= km->vstart) {
                       va_end = km->vstart;
                       size = va_end - va;

                       /*
                        * No need to check for a merge here; we would
                        * have caught it above.
                        */
                       goto prepend_existing;
               }

               /*
                * Need to the new region in front of the current one.
                * Make sure there's room.
                */
               if (km_next == NULL || km_last->vstart != km_last->vend) {
                       printf("!!! NO ROOM TO INSERT MAPPING\n");
                       return 1;
               }

               if (km_prev == NULL) {
                       DPRINTF("!!! entering before 0x%lx-0x%lx\n",
                           km->vstart, km->vend);
               } else {
                       DPRINTF("!!! entering between 0x%lx-0x%lx and "
                              "0x%lx-0x%lx\n",
                              km_prev->vstart, km_prev->vend,
                              km->vstart, km->vend);
               }

               if (ofw_create_mapping(va, va, size) == -1) {
                       return 1;
               }
               size = (uintptr_t)(&kmappings[MAX_KMAPPINGS]) -
                   (uintptr_t)(km_next + 1);
               memmove(km_next, km, size);
               km->vstart = va;
               km->vend = va_end;
               return 0;
       }

extend_existing:
       if (ofw_create_mapping(va, va, size) == -1) {
               return 1;
       }
       km->vend = va_end;
       return 0;

prepend_existing:
       if (ofw_create_mapping(va, va, size) == -1) {
               return 1;
       }
       km->vstart = va;
       return 0;

enter_new:
       if (ofw_create_mapping(va, va, size) == -1) {
               return 1;
       }
       km->vstart = va;
       km->vend = va_end;
       return 0;

merge_two:
       if (ofw_create_mapping(va, va, size) == -1) {
               return 1;
       }
       km->vend = km_next->vend;
       size =
           (uintptr_t)(&kmappings[MAX_KMAPPINGS]) - (uintptr_t)(km_next + 1);
       if (size != 0) {
               memmove(km_next, km_next + 1, size);
       }
       km_last->vstart = km_last->vend = 0;
       return 0;
}

/*
* loadfile() hooks.
*/
ssize_t
macppc_read(int f, void *addr, size_t size)
{
       if (kmapping_enter((vaddr_t)addr, size)) {
               return -1;
       }
       return read(f, addr, size);
}

void *
macppc_memcpy(void *dst, const void *src, size_t size)
{
       if (kmapping_enter((vaddr_t)dst, size)) {
               panic("macppc_memcpy: kmapping_enter failed");
       }
       return memcpy(dst, src, size);
}

void *
macppc_memset(void *dst, int c, size_t size)
{
       if (kmapping_enter((vaddr_t)dst, size)) {
               panic("macppc_memset: kmapping_enter failed");
       }
       return memset(dst, c, size);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.