/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2016 Toomas Soome <tsoome@me.com>
 */

/*
 * dboot module utility functions for multiboot 2 tags processing.
 */

#include <sys/inttypes.h>
#include <sys/param.h>
#include <sys/machparam.h>
#include <sys/systm.h>
#include <sys/sysmacros.h>
#include <sys/multiboot2.h>
#include <sys/multiboot2_impl.h>
#include <sys/efi.h>

struct dboot_multiboot2_iterate_ctx;

typedef boolean_t (*dboot_multiboot2_iterate_cb_t)
        (int, multiboot_tag_t *, struct dboot_multiboot2_iterate_ctx *);

struct dboot_multiboot2_iterate_ctx {
        dboot_multiboot2_iterate_cb_t dboot_iter_callback;
        int dboot_iter_index;                   /* item from set */
        uint32_t dboot_iter_tag;                /* tag to search */
        multiboot_tag_t *dboot_iter_tagp;       /* search result */
};

/*
 * Multiboot2 tag list elements are aligned to MULTIBOOT_TAG_ALIGN.
 * To get the next item from the list, we first add the tag's size
 * to the start of the current tag. Next, we round up that address to the
 * nearest MULTIBOOT_TAG_ALIGN address.
 */

static multiboot_tag_t *
dboot_multiboot2_first_tag(multiboot2_info_header_t *mbi)
{
        return (&mbi->mbi_tags[0]);
}

static multiboot_tag_t *
dboot_multiboot2_next_tag(multiboot_tag_t *tag)
{
        if (tag == NULL || tag->mb_type == MULTIBOOT_TAG_TYPE_END)
                return (NULL);

        return ((multiboot_tag_t *)P2ROUNDUP((uintptr_t)tag +
            tag->mb_size, MULTIBOOT_TAG_ALIGN));
}

/*
 * Walk the tag list until we hit the first instance of a given tag or
 * the end of the list.
 * MB2_NEXT_TAG() will return NULL on end of list.
 */
static void *
dboot_multiboot2_find_tag_impl(multiboot_tag_t *tagp, uint32_t tag)
{
        while (tagp != NULL && tagp->mb_type != tag) {
                tagp = dboot_multiboot2_next_tag(tagp);
        }
        return (tagp);
}

/*
 * Walk the entire list to find the first instance of the given tag.
 */
void *
dboot_multiboot2_find_tag(multiboot2_info_header_t *mbi, uint32_t tag)
{
        multiboot_tag_t *tagp = dboot_multiboot2_first_tag(mbi);

        return (dboot_multiboot2_find_tag_impl(tagp, tag));
}

/*
 * dboot_multiboot2_iterate()
 *
 * While most tags in tag list are unique, the modules are specified
 * one module per tag and therefore we need an mechanism to process
 * tags in set.
 *
 * Arguments:
 *      mbi: multiboot info header
 *      data: callback context.
 *
 * Return value:
 *      Processed item count.
 * Callback returning B_TRUE will terminate the iteration.
 */
static int
dboot_multiboot2_iterate(multiboot2_info_header_t *mbi,
    struct dboot_multiboot2_iterate_ctx *ctx)
{
        dboot_multiboot2_iterate_cb_t callback = ctx->dboot_iter_callback;
        multiboot_tag_t *tagp;
        uint32_t tag = ctx->dboot_iter_tag;
        int index = 0;

        tagp = dboot_multiboot2_find_tag(mbi, tag);
        while (tagp != NULL) {
                if (callback != NULL) {
                        if (callback(index, tagp, ctx) == B_TRUE) {
                                return (index + 1);
                        }
                }
                tagp = dboot_multiboot2_next_tag(tagp);
                tagp = dboot_multiboot2_find_tag_impl(tagp, tag);
                index++;
        }
        return (index);
}

char *
dboot_multiboot2_cmdline(multiboot2_info_header_t *mbi)
{
        multiboot_tag_string_t *tag;

        tag = dboot_multiboot2_find_tag(mbi, MULTIBOOT_TAG_TYPE_CMDLINE);

        if (tag != NULL)
                return (&tag->mb_string[0]);
        else
                return (NULL);
}

/*
 * Simple callback to index item in set.
 * Terminates iteration if the indexed item is found.
 */
static boolean_t
dboot_multiboot2_iterate_callback(int index, multiboot_tag_t *tagp,
    struct dboot_multiboot2_iterate_ctx *ctx)
{
        if (index == ctx->dboot_iter_index) {
                ctx->dboot_iter_tagp = tagp;
                return (B_TRUE);
        }
        return (B_FALSE);
}

int
dboot_multiboot2_modcount(multiboot2_info_header_t *mbi)
{
        struct dboot_multiboot2_iterate_ctx ctx = {
                .dboot_iter_callback = NULL,
                .dboot_iter_index = 0,
                .dboot_iter_tag = MULTIBOOT_TAG_TYPE_MODULE,
                .dboot_iter_tagp = NULL
        };

        return (dboot_multiboot2_iterate(mbi, &ctx));
}

uint32_t
dboot_multiboot2_modstart(multiboot2_info_header_t *mbi, int index)
{
        multiboot_tag_module_t *tagp;
        struct dboot_multiboot2_iterate_ctx ctx = {
                .dboot_iter_callback = dboot_multiboot2_iterate_callback,
                .dboot_iter_index = index,
                .dboot_iter_tag = MULTIBOOT_TAG_TYPE_MODULE,
                .dboot_iter_tagp = NULL
        };

        if (dboot_multiboot2_iterate(mbi, &ctx) != 0) {
                tagp = (multiboot_tag_module_t *)ctx.dboot_iter_tagp;

                if (tagp != NULL)
                        return (tagp->mb_mod_start);
        }
        return (0);
}

uint32_t
dboot_multiboot2_modend(multiboot2_info_header_t *mbi, int index)
{
        multiboot_tag_module_t *tagp;
        struct dboot_multiboot2_iterate_ctx ctx = {
                .dboot_iter_callback = dboot_multiboot2_iterate_callback,
                .dboot_iter_index = index,
                .dboot_iter_tag = MULTIBOOT_TAG_TYPE_MODULE,
                .dboot_iter_tagp = NULL
        };

        if (dboot_multiboot2_iterate(mbi, &ctx) != 0) {
                tagp = (multiboot_tag_module_t *)ctx.dboot_iter_tagp;

                if (tagp != NULL)
                        return (tagp->mb_mod_end);
        }
        return (0);
}

char *
dboot_multiboot2_modcmdline(multiboot2_info_header_t *mbi, int index)
{
        multiboot_tag_module_t *tagp;
        struct dboot_multiboot2_iterate_ctx ctx = {
                .dboot_iter_callback = dboot_multiboot2_iterate_callback,
                .dboot_iter_index = index,
                .dboot_iter_tag = MULTIBOOT_TAG_TYPE_MODULE,
                .dboot_iter_tagp = NULL
        };

        if (dboot_multiboot2_iterate(mbi, &ctx) != 0) {
                tagp = (multiboot_tag_module_t *)ctx.dboot_iter_tagp;

                if (tagp != NULL)
                        return (&tagp->mb_cmdline[0]);
        }
        return (NULL);
}

multiboot_tag_mmap_t *
dboot_multiboot2_get_mmap_tagp(multiboot2_info_header_t *mbi)
{
        return (dboot_multiboot2_find_tag(mbi, MULTIBOOT_TAG_TYPE_MMAP));
}

multiboot_tag_efi_mmap_t *
dboot_multiboot2_get_efi_mmap_tagp(multiboot2_info_header_t *mbi)
{
        multiboot_tag_efi_mmap_t *tagp;

        /* Find tag and check the descriptor version. */
        tagp = dboot_multiboot2_find_tag(mbi, MULTIBOOT_TAG_TYPE_EFI_MMAP);
        if (tagp != NULL &&
            tagp->mb_descr_vers != EFI_MEMORY_DESCRIPTOR_VERSION)
                tagp = NULL;

        return (tagp);
}

boolean_t
dboot_multiboot2_basicmeminfo(multiboot2_info_header_t *mbi,
    uint32_t *lower, uint32_t *upper)
{
        multiboot_tag_basic_meminfo_t *mip;

        mip = dboot_multiboot2_find_tag(mbi, MULTIBOOT_TAG_TYPE_BASIC_MEMINFO);
        if (mip != NULL) {
                *lower = mip->mb_mem_lower;
                *upper = mip->mb_mem_upper;
                return (B_TRUE);
        }
        return (B_FALSE);
}

/*
 * Return the type of mmap entry referenced by index.
 */
boolean_t
dboot_multiboot2_mmap_get_type(multiboot2_info_header_t *mbi, int index,
    uint32_t *typep)
{
        multiboot_tag_mmap_t *mb2_mmap_tagp;
        multiboot_mmap_entry_t *mapentp;

        if (dboot_multiboot2_mmap_nentries(mbi) < index)
                return (B_FALSE);

        mb2_mmap_tagp = dboot_multiboot2_get_mmap_tagp(mbi);
        if (mb2_mmap_tagp == NULL)
                return (B_FALSE);

        if (dboot_multiboot2_mmap_nentries(mbi) < index)
                return (B_FALSE);

        mapentp = (multiboot_mmap_entry_t *)(mb2_mmap_tagp->mb_entries +
            index * mb2_mmap_tagp->mb_entry_size);
        *typep = mapentp->mmap_type;
        return (B_TRUE);
}

/*
 * Return the length of mmap entry referenced by index.
 */
boolean_t
dboot_multiboot2_mmap_get_length(multiboot2_info_header_t *mbi, int index,
    uint64_t *lengthp)
{
        multiboot_tag_mmap_t *mb2_mmap_tagp;
        multiboot_mmap_entry_t *mapentp;

        if (dboot_multiboot2_mmap_nentries(mbi) < index)
                return (B_FALSE);

        mb2_mmap_tagp = dboot_multiboot2_get_mmap_tagp(mbi);
        if (mb2_mmap_tagp == NULL)
                return (B_FALSE);

        mapentp = (multiboot_mmap_entry_t *)(mb2_mmap_tagp->mb_entries +
            index * mb2_mmap_tagp->mb_entry_size);
        *lengthp = mapentp->mmap_len;
        return (B_TRUE);
}

/*
 * Return the address from mmap entry referenced by index.
 */
boolean_t
dboot_multiboot2_mmap_get_base(multiboot2_info_header_t *mbi, int index,
    uint64_t *basep)
{
        multiboot_tag_mmap_t *mb2_mmap_tagp;
        multiboot_mmap_entry_t *mapentp;

        if (dboot_multiboot2_mmap_nentries(mbi) < index)
                return (B_FALSE);

        mb2_mmap_tagp = dboot_multiboot2_get_mmap_tagp(mbi);
        if (mb2_mmap_tagp == NULL)
                return (B_FALSE);

        mapentp = (multiboot_mmap_entry_t *)(mb2_mmap_tagp->mb_entries +
            index * mb2_mmap_tagp->mb_entry_size);
        *basep = mapentp->mmap_addr;
        return (B_TRUE);
}

/*
 * Count and return the number of mmap entries provided by the tag.
 */
int
dboot_multiboot2_mmap_nentries(multiboot2_info_header_t *mbi)
{
        multiboot_tag_mmap_t *mb2_mmap_tagp;

        mb2_mmap_tagp = dboot_multiboot2_get_mmap_tagp(mbi);
        if (mb2_mmap_tagp != NULL) {
                return ((mb2_mmap_tagp->mb_size -
                    offsetof(multiboot_tag_mmap_t, mb_entries)) /
                    mb2_mmap_tagp->mb_entry_size);
        }
        return (0);
}

/*
 * Return the type of efi mmap entry referenced by index.
 */
boolean_t
dboot_multiboot2_efi_mmap_get_type(multiboot2_info_header_t *mbi, int index,
    uint32_t *typep)
{
        multiboot_tag_efi_mmap_t *mb2_efi_mmap_tagp;
        EFI_MEMORY_DESCRIPTOR *mapentp;

        if (dboot_multiboot2_efi_mmap_nentries(mbi) < index)
                return (B_FALSE);

        mb2_efi_mmap_tagp = dboot_multiboot2_get_efi_mmap_tagp(mbi);
        if (mb2_efi_mmap_tagp == NULL)
                return (B_FALSE);

        mapentp = (EFI_MEMORY_DESCRIPTOR *)(mb2_efi_mmap_tagp->mb_efi_mmap +
            index * mb2_efi_mmap_tagp->mb_descr_size);

        *typep = mapentp->Type;
        return (B_TRUE);
}

/*
 * Return the length of efi mmap entry referenced by index.
 */
boolean_t
dboot_multiboot2_efi_mmap_get_length(multiboot2_info_header_t *mbi, int index,
    uint64_t *lengthp)
{
        multiboot_tag_efi_mmap_t *mb2_efi_mmap_tagp;
        EFI_MEMORY_DESCRIPTOR *mapentp;

        if (dboot_multiboot2_efi_mmap_nentries(mbi) < index)
                return (B_FALSE);

        mb2_efi_mmap_tagp = dboot_multiboot2_get_efi_mmap_tagp(mbi);
        if (mb2_efi_mmap_tagp == NULL)
                return (B_FALSE);

        mapentp = (EFI_MEMORY_DESCRIPTOR *)(mb2_efi_mmap_tagp->mb_efi_mmap +
            index * mb2_efi_mmap_tagp->mb_descr_size);
        *lengthp = mapentp->NumberOfPages << PAGESHIFT;
        return (B_TRUE);
}

/*
 * Return the address from efi mmap entry referenced by index.
 */
boolean_t
dboot_multiboot2_efi_mmap_get_base(multiboot2_info_header_t *mbi, int index,
    uint64_t *basep)
{
        multiboot_tag_efi_mmap_t *mb2_efi_mmap_tagp;
        EFI_MEMORY_DESCRIPTOR *mapentp;

        if (dboot_multiboot2_efi_mmap_nentries(mbi) < index)
                return (B_FALSE);

        mb2_efi_mmap_tagp = dboot_multiboot2_get_efi_mmap_tagp(mbi);
        if (mb2_efi_mmap_tagp == NULL)
                return (B_FALSE);

        mapentp = (EFI_MEMORY_DESCRIPTOR *)(mb2_efi_mmap_tagp->mb_efi_mmap +
            index * mb2_efi_mmap_tagp->mb_descr_size);
        *basep = mapentp->PhysicalStart;
        return (B_TRUE);
}

/*
 * Count and return the number of efi mmap entries provided by the tag.
 */
int
dboot_multiboot2_efi_mmap_nentries(multiboot2_info_header_t *mbi)
{
        multiboot_tag_efi_mmap_t *mb2_efi_mmap_tagp;

        mb2_efi_mmap_tagp = dboot_multiboot2_get_efi_mmap_tagp(mbi);
        if (mb2_efi_mmap_tagp != NULL) {
                return ((mb2_efi_mmap_tagp->mb_size -
                    offsetof(multiboot_tag_efi_mmap_t, mb_efi_mmap)) /
                    mb2_efi_mmap_tagp->mb_descr_size);
        }
        return (0);
}

/*
 * Return the highest address used by info header.
 */
paddr_t
dboot_multiboot2_highest_addr(multiboot2_info_header_t *mbi)
{
        return ((paddr_t)(uintptr_t)mbi + mbi->mbi_total_size);
}