// SPDX-License-Identifier: GPL-2.0-only
/* -*- linux-c -*- ------------------------------------------------------- *
 *
 *   Copyright (C) 1991, 1992 Linus Torvalds
 *   Copyright 2007 rPath, Inc. - All Rights Reserved
 *   Copyright 2009 Intel Corporation; author H. Peter Anvin
 *
 * ----------------------------------------------------------------------- */

/*
 * Memory detection code
 */

#include "boot.h"

#define SMAP    0x534d4150      /* ASCII "SMAP" */

static void detect_memory_e820(void)
{
        int count = 0;
        struct biosregs ireg, oreg;
        struct boot_e820_entry *desc = boot_params.e820_table;
        static struct boot_e820_entry buf; /* static so it is zeroed */

        initregs(&ireg);
        ireg.ax  = 0xe820;
        ireg.cx  = sizeof(buf);
        ireg.edx = SMAP;
        ireg.di  = (size_t)&buf;

        /*
         * Note: at least one BIOS is known which assumes that the
         * buffer pointed to by one e820 call is the same one as
         * the previous call, and only changes modified fields.  Therefore,
         * we use a temporary buffer and copy the results entry by entry.
         *
         * This routine deliberately does not try to account for
         * ACPI 3+ extended attributes.  This is because there are
         * BIOSes in the field which report zero for the valid bit for
         * all ranges, and we don't currently make any use of the
         * other attribute bits.  Revisit this if we see the extended
         * attribute bits deployed in a meaningful way in the future.
         */

        do {
                intcall(0x15, &ireg, &oreg);
                ireg.ebx = oreg.ebx; /* for next iteration... */

                /* BIOSes which terminate the chain with CF = 1 as opposed
                   to %ebx = 0 don't always report the SMAP signature on
                   the final, failing, probe. */
                if (oreg.eflags & X86_EFLAGS_CF)
                        break;

                /* Some BIOSes stop returning SMAP in the middle of
                   the search loop.  We don't know exactly how the BIOS
                   screwed up the map at that point, we might have a
                   partial map, the full map, or complete garbage, so
                   just return failure. */
                if (oreg.eax != SMAP) {
                        count = 0;
                        break;
                }

                *desc++ = buf;
                count++;
        } while (ireg.ebx && count < ARRAY_SIZE(boot_params.e820_table));

        boot_params.e820_entries = count;
}

static void detect_memory_e801(void)
{
        struct biosregs ireg, oreg;

        initregs(&ireg);
        ireg.ax = 0xe801;
        intcall(0x15, &ireg, &oreg);

        if (oreg.eflags & X86_EFLAGS_CF)
                return;

        /* Do we really need to do this? */
        if (oreg.cx || oreg.dx) {
                oreg.ax = oreg.cx;
                oreg.bx = oreg.dx;
        }

        if (oreg.ax > 15*1024) {
                return; /* Bogus! */
        } else if (oreg.ax == 15*1024) {
                boot_params.alt_mem_k = (oreg.bx << 6) + oreg.ax;
        } else {
                /*
                 * This ignores memory above 16MB if we have a memory
                 * hole there.  If someone actually finds a machine
                 * with a memory hole at 16MB and no support for
                 * 0E820h they should probably generate a fake e820
                 * map.
                 */
                boot_params.alt_mem_k = oreg.ax;
        }
}

static void detect_memory_88(void)
{
        struct biosregs ireg, oreg;

        initregs(&ireg);
        ireg.ah = 0x88;
        intcall(0x15, &ireg, &oreg);

        boot_params.screen_info.ext_mem_k = oreg.ax;
}

void detect_memory(void)
{
        detect_memory_e820();

        detect_memory_e801();

        detect_memory_88();
}