source: mainline/kernel/arch/mips32/src/mm/frame.c@ 3061bc1

/*
 * Copyright (c) 2005 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - 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.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 */

/** @addtogroup mips32mm
 * @{
 */
/** @file
 */

#include <macros.h>
#include <arch/mm/frame.h>
#include <arch/mm/tlb.h>
#include <interrupt.h>
#include <mm/frame.h>
#include <mm/asid.h>
#include <config.h>
#ifdef MACHINE_msim
#include <arch/drivers/msim.h>
#endif
#include <arch/arch.h>
#include <print.h>

#define ZERO_PAGE_MASK    TLB_PAGE_MASK_256K
#define ZERO_FRAMES       2048
#define ZERO_PAGE_WIDTH   18  /* 256K */
#define ZERO_PAGE_SIZE    (1 << ZERO_PAGE_WIDTH)
#define ZERO_PAGE_ASID    ASID_INVALID
#define ZERO_PAGE_TLBI    0
#define ZERO_PAGE_ADDR    0
#define ZERO_PAGE_OFFSET  (ZERO_PAGE_SIZE / sizeof(uint32_t) - 1)
#define ZERO_PAGE_VALUE   (((volatile uint32_t *) ZERO_PAGE_ADDR)[ZERO_PAGE_OFFSET])

#define ZERO_PAGE_VALUE_KSEG1(frame) \
        (((volatile uint32_t *) (0xa0000000 + (frame << ZERO_PAGE_WIDTH)))[ZERO_PAGE_OFFSET])

#define MAX_REGIONS  32

typedef struct {
        pfn_t start;
        pfn_t count;
} phys_region_t;

static size_t phys_regions_count = 0;
static phys_region_t phys_regions[MAX_REGIONS];

/** Check whether frame is available
 *
 * Returns true if given frame is generally available for use.
 * Returns false if given frame is used for physical memory
 * mapped devices and cannot be used.
 *
 */
static bool frame_available(pfn_t frame)
{
#ifdef MACHINE_msim
        /* MSIM device (dprinter) */
        if (frame == (KA2PA(MSIM_VIDEORAM) >> ZERO_PAGE_WIDTH))
                return false;
        
        /* MSIM device (dkeyboard) */
        if (frame == (KA2PA(MSIM_KBD_ADDRESS) >> ZERO_PAGE_WIDTH))
                return false;
#endif

#if defined(MACHINE_lmalta) || defined(MACHINE_bmalta)
        if (frame >= (sdram_size >> ZERO_PAGE_WIDTH))
                return false;
#endif
        
        return true;
}


/** Check whether frame is safe to write
 *
 * Returns true if given frame is safe for read/write test.
 * Returns false if given frame should not be touched.
 *
 */
static bool frame_safe(pfn_t frame)
{
        /* Kernel structures */
        if ((frame << ZERO_PAGE_WIDTH) < KA2PA(config.base))
                return false;
        
        /* Kernel */
        if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
            KA2PA(config.base), config.kernel_size))
                return false;
        
        /* Kernel stack */
        if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
            KA2PA(config.stack_base), config.stack_size))
                return false;
        
        /* Init tasks */
        bool safe = true;
        size_t i;
        for (i = 0; i < init.cnt; i++)
                if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
                    init.tasks[i].paddr, init.tasks[i].size)) {
                        safe = false;
                        break;
                }
        
        return safe;
}

static void frame_add_region(pfn_t start_frame, pfn_t end_frame, bool low)
{
        if (end_frame <= start_frame)
                return;

        uintptr_t base = start_frame << ZERO_PAGE_WIDTH;
        size_t size = (end_frame - start_frame) << ZERO_PAGE_WIDTH;

        if (!frame_adjust_zone_bounds(low, &base, &size))
                return;

        pfn_t first = ADDR2PFN(base);
        size_t count = SIZE2FRAMES(size);
        pfn_t conf_frame;

        if (low) {
                /* Interrupt vector frame is blacklisted */
                if (first == 0)
                        conf_frame = 1;
                else
                        conf_frame = first;
                zone_create(first, count, conf_frame,
                    ZONE_AVAILABLE | ZONE_LOWMEM);
        } else {
                conf_frame = zone_external_conf_alloc(count);
                if (conf_frame != 0)
                        zone_create(first, count, conf_frame,
                            ZONE_AVAILABLE | ZONE_HIGHMEM);
        }
        
        if (phys_regions_count < MAX_REGIONS) {
                phys_regions[phys_regions_count].start = first;
                phys_regions[phys_regions_count].count = count;
                phys_regions_count++;
        }
}


/** Create memory zones
 *
 * Walk through available 256 KB chunks of physical
 * memory and create zones.
 *
 * Note: It is assumed that the TLB is not yet being
 * used in any way, thus there is no interference.
 *
 */
void frame_low_arch_init(void)
{
        ipl_t ipl = interrupts_disable();
        
        /* Clear and initialize TLB */
        cp0_pagemask_write(ZERO_PAGE_MASK);
        cp0_entry_lo0_write(0);
        cp0_entry_lo1_write(0);
        cp0_entry_hi_write(0);

        size_t i;
        for (i = 0; i < TLB_ENTRY_COUNT; i++) {
                cp0_index_write(i);
                tlbwi();
        }
                
        pfn_t start_frame = 0;
        pfn_t frame;
        bool avail = true;
        
        /* Walk through all 1 MB frames */
        for (frame = 0; frame < ZERO_FRAMES; frame++) {
                if (!frame_available(frame))
                        avail = false;
                else {
                        if (frame_safe(frame)) {
                                entry_lo_t lo0;
                                entry_lo_t lo1;
                                entry_hi_t hi;
                                tlb_prepare_entry_lo(&lo0, false, true, true, false, frame << (ZERO_PAGE_WIDTH - 12));
                                tlb_prepare_entry_lo(&lo1, false, false, false, false, 0);
                                tlb_prepare_entry_hi(&hi, ZERO_PAGE_ASID, ZERO_PAGE_ADDR);
                                
                                cp0_pagemask_write(ZERO_PAGE_MASK);
                                cp0_entry_lo0_write(lo0.value);
                                cp0_entry_lo1_write(lo1.value);
                                cp0_entry_hi_write(hi.value);
                                cp0_index_write(ZERO_PAGE_TLBI);
                                tlbwi();
                                
                                ZERO_PAGE_VALUE = 0;
                                if (ZERO_PAGE_VALUE != 0)
                                        avail = false;
                                else {
                                        ZERO_PAGE_VALUE = 0xdeadbeef;
                                        if (ZERO_PAGE_VALUE != 0xdeadbeef)
                                                avail = false;
                                }
                        }
                }
                
                if (!avail) {
                        frame_add_region(start_frame, frame, true);
                        start_frame = frame + 1;
                        avail = true;
                }
        }
        
        frame_add_region(start_frame, frame, true);
        
        /* Blacklist interrupt vector frame */
        frame_mark_unavailable(0, 1);

#if defined(MACHINE_lmalta) || defined(MACHINE_bmalta)
        /* Blacklist memory regions used by YAMON.
         *
         * The YAMON User's Manual vaguely says the following physical addresses
         * are taken by YAMON:
         *
         * 0x1000       YAMON functions
         * 0x5000       YAMON code
         *
         * These addresses overlap with the beginning of the SDRAM so we need to
         * make sure they cannot be allocated.
         *
         * The User's Manual unfortunately does not say where does the SDRAM
         * portion used by YAMON end.
         *
         * Looking into the YAMON 02.21 sources, it looks like the first free
         * address is computed dynamically and depends on the size of the YAMON
         * image. From the YAMON binary, it appears to be 0xc0d50 or roughly
         * 772 KiB for that particular version.
         *
         * Linux is linked to 1MiB which seems to be a safe bet and a reasonable
         * upper bound for memory taken by YAMON. We will use it too.
         */
        frame_mark_unavailable(0, 1024 * 1024 / FRAME_SIZE);
#endif
        
        /* Cleanup */
        cp0_pagemask_write(ZERO_PAGE_MASK);
        cp0_entry_lo0_write(0);
        cp0_entry_lo1_write(0);
        cp0_entry_hi_write(0);
        cp0_index_write(ZERO_PAGE_TLBI);
        tlbwi();
        
        interrupts_restore(ipl);
}

void frame_high_arch_init(void)
{
}

void physmem_print(void)
{
        printf("[base    ] [size    ]\n");
        
        size_t i;
        for (i = 0; i < phys_regions_count; i++) {
                printf("%#010x %10u\n",
                        PFN2ADDR(phys_regions[i].start), PFN2ADDR(phys_regions[i].count));
        }
}

/** @}
 */