/*
 * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
 * All rights reserved.
 *
 * 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 AUTHOR 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 AUTHOR 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 <sys/cdefs.h>

/*
 * Obtain memory configuration information from the BIOS
 */
#include <stand.h>
#include <machine/pc/bios.h>
#include "bootstrap.h"
#include "libi386.h"
#include "btxv86.h"
#include "smbios.h"

vm_offset_t     memtop, memtop_copyin, high_heap_base;
uint32_t        bios_basemem, bios_extmem, high_heap_size;

static struct bios_smap_xattr smap;

/*
 * Used to track which method was used to set BIOS memory
 * regions.
 */
static uint8_t b_bios_probed;
#define B_BASEMEM_E820  0x1
#define B_BASEMEM_12    0x2
#define B_EXTMEM_E820   0x4
#define B_EXTMEM_E801   0x8
#define B_EXTMEM_8800   0x10

/*
 * The minimum amount of memory to reserve in bios_extmem for the heap.
 */
#define HEAP_MIN        (64 * 1024 * 1024)

/*
 * Products in this list need quirks to detect
 * memory correctly. You need both maker and product as
 * reported by smbios.
 */
/* e820 might not return useful extended memory */
#define BQ_DISTRUST_E820_EXTMEM 0x1
struct bios_getmem_quirks {
        const char *bios_vendor;
        const char *maker;
        const char *product;
        int quirk;
};

static struct bios_getmem_quirks quirks[] = {
        {"coreboot", "Acer", "Peppy", BQ_DISTRUST_E820_EXTMEM},
        {NULL, NULL, NULL, 0}
};

static int
bios_getquirks(void)
{
        int i;

        for (i = 0; quirks[i].quirk != 0; ++i) {
                if (smbios_match(quirks[i].bios_vendor, quirks[i].maker,
                    quirks[i].product))
                        return (quirks[i].quirk);
        }

        return (0);
}

void
bios_getmem(void)
{
        uint64_t size;

        /* Parse system memory map */
        v86.ebx = 0;
        do {
                v86.ctl = V86_FLAGS;
                v86.addr = 0x15;                /* int 0x15 function 0xe820 */
                v86.eax = 0xe820;
                v86.ecx = sizeof (struct bios_smap_xattr);
                v86.edx = SMAP_SIG;
                v86.es = VTOPSEG(&smap);
                v86.edi = VTOPOFF(&smap);
                v86int();
                if ((V86_CY(v86.efl)) || (v86.eax != SMAP_SIG))
                        break;
                /* look for a low-memory segment that's large enough */
                if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base == 0) &&
                    (smap.length >= (512 * 1024))) {
                        bios_basemem = smap.length;
                        b_bios_probed |= B_BASEMEM_E820;
                }

                /* look for the first segment in 'extended' memory */
                if ((smap.type == SMAP_TYPE_MEMORY) &&
                    (smap.base == 0x100000) &&
                    !(bios_getquirks() & BQ_DISTRUST_E820_EXTMEM)) {
                        bios_extmem = smap.length;
                        b_bios_probed |= B_EXTMEM_E820;
                }

                /*
                 * Look for the highest segment in 'extended' memory beyond
                 * 1MB but below 4GB.
                 */
                if ((smap.type == SMAP_TYPE_MEMORY) &&
                    (smap.base > 0x100000) &&
                    (smap.base < 0x100000000ull)) {
                        size = smap.length;

                        /*
                         * If this segment crosses the 4GB boundary,
                         * truncate it.
                         */
                        if (smap.base + size > 0x100000000ull)
                                size = 0x100000000ull - smap.base;

                        /*
                         * To make maximum space for the kernel and the modules,
                         * set heap to use highest HEAP_MIN bytes below 4GB.
                         */
                        if (high_heap_base < smap.base && size >= HEAP_MIN) {
                                high_heap_base = smap.base + size - HEAP_MIN;
                                high_heap_size = HEAP_MIN;
                        }
                }
        } while (v86.ebx != 0);

        /* Fall back to the old compatibility function for base memory */
        if (bios_basemem == 0) {
                v86.ctl = 0;
                v86.addr = 0x12;                /* int 0x12 */
                v86int();

                bios_basemem = (v86.eax & 0xffff) * 1024;
                b_bios_probed |= B_BASEMEM_12;
        }

        /*
         * Fall back through several compatibility functions for extended
         * memory.
         */
        if (bios_extmem == 0) {
                v86.ctl = V86_FLAGS;
                v86.addr = 0x15;                /* int 0x15 function 0xe801 */
                v86.eax = 0xe801;
                v86int();
                if (!(V86_CY(v86.efl))) {
                        /*
                         * Clear high_heap; it may end up overlapping
                         * with the segment we're determining here.
                         * Let the default "steal stuff from top of
                         * bios_extmem" code below pick up on it.
                         */
                        high_heap_size = 0;
                        high_heap_base = 0;

                        /*
                         * %cx is the number of 1KiB blocks between 1..16MiB.
                         * It can only be up to 0x3c00; if it's smaller then
                         * there's a PC AT memory hole so we can't treat
                         * it as contiguous.
                         */
                        bios_extmem = (v86.ecx & 0xffff) * 1024;
                        if (bios_extmem == (1024 * 0x3c00))
                                bios_extmem += (v86.edx & 0xffff) * 64 * 1024;

                        /* truncate bios_extmem */
                        if (bios_extmem > 0x3ff00000)
                                bios_extmem = 0x3ff00000;

                        b_bios_probed |= B_EXTMEM_E801;
                }
        }
        if (bios_extmem == 0) {
                v86.ctl = 0;
                v86.addr = 0x15;                /* int 0x15 function 0x88 */
                v86.eax = 0x8800;
                v86int();
                bios_extmem = (v86.eax & 0xffff) * 1024;
                b_bios_probed |= B_EXTMEM_8800;
        }

        /* Set memtop to actual top of memory */
        if (high_heap_size != 0) {
                memtop = memtop_copyin = high_heap_base;
        } else {
                memtop = memtop_copyin = 0x100000 + bios_extmem;
        }

        /*
         * If we have extended memory and did not find a suitable heap
         * region in the SMAP, use the last HEAP_MIN of 'extended' memory as a
         * high heap candidate.
         */
        if (bios_extmem >= HEAP_MIN && high_heap_size < HEAP_MIN) {
                high_heap_size = HEAP_MIN;
                high_heap_base = memtop - HEAP_MIN;
                memtop = memtop_copyin = high_heap_base;
        }
}

static int
command_biosmem(int argc __unused, char *argv[] __unused)
{
        int bq = bios_getquirks();

        printf("bios_basemem: 0x%llx\n", (unsigned long long)bios_basemem);
        printf("bios_extmem: 0x%llx\n", (unsigned long long)bios_extmem);
        printf("memtop: 0x%llx\n", (unsigned long long)memtop);
        printf("high_heap_base: 0x%llx\n", (unsigned long long)high_heap_base);
        printf("high_heap_size: 0x%llx\n", (unsigned long long)high_heap_size);
        printf("bios_quirks: 0x%02x", bq);
        if (bq & BQ_DISTRUST_E820_EXTMEM)
                printf(" BQ_DISTRUST_E820_EXTMEM");
        printf("\n");
        printf("b_bios_probed: 0x%02x", (int)b_bios_probed);
        if (b_bios_probed & B_BASEMEM_E820)
                printf(" B_BASEMEM_E820");
        if (b_bios_probed & B_BASEMEM_12)
                printf(" B_BASEMEM_12");
        if (b_bios_probed & B_EXTMEM_E820)
                printf(" B_EXTMEM_E820");
        if (b_bios_probed & B_EXTMEM_E801)
                printf(" B_EXTMEM_E801");
        if (b_bios_probed & B_EXTMEM_8800)
                printf(" B_EXTMEM_8800");
        printf("\n");

        return (CMD_OK);
}

COMMAND_SET(biosmem, "biosmem", "show BIOS memory setup", command_biosmem);