// SPDX-License-Identifier: GPL-2.0
/* -----------------------------------------------------------------------
 *
 *   Copyright 2011 Intel Corporation; author Matt Fleming
 *
 * ----------------------------------------------------------------------- */

#include <linux/bitops.h>
#include <linux/ctype.h>
#include <linux/efi.h>
#include <linux/screen_info.h>
#include <linux/string.h>
#include <asm/efi.h>
#include <asm/setup.h>
#include <video/edid.h>

#include "efistub.h"

enum efi_cmdline_option {
        EFI_CMDLINE_NONE,
        EFI_CMDLINE_MODE_NUM,
        EFI_CMDLINE_RES,
        EFI_CMDLINE_AUTO,
        EFI_CMDLINE_LIST
};

static struct {
        enum efi_cmdline_option option;
        union {
                u32 mode;
                struct {
                        u32 width, height;
                        int format;
                        u8 depth;
                } res;
        };
} cmdline = { .option = EFI_CMDLINE_NONE };

static bool parse_modenum(char *option, char **next)
{
        u32 m;

        if (!strstarts(option, "mode="))
                return false;
        option += strlen("mode=");
        m = simple_strtoull(option, &option, 0);
        if (*option && *option++ != ',')
                return false;
        cmdline.option = EFI_CMDLINE_MODE_NUM;
        cmdline.mode   = m;

        *next = option;
        return true;
}

static bool parse_res(char *option, char **next)
{
        u32 w, h, d = 0;
        int pf = -1;

        if (!isdigit(*option))
                return false;
        w = simple_strtoull(option, &option, 10);
        if (*option++ != 'x' || !isdigit(*option))
                return false;
        h = simple_strtoull(option, &option, 10);
        if (*option == '-') {
                option++;
                if (strstarts(option, "rgb")) {
                        option += strlen("rgb");
                        pf = PIXEL_RGB_RESERVED_8BIT_PER_COLOR;
                } else if (strstarts(option, "bgr")) {
                        option += strlen("bgr");
                        pf = PIXEL_BGR_RESERVED_8BIT_PER_COLOR;
                } else if (isdigit(*option))
                        d = simple_strtoull(option, &option, 10);
                else
                        return false;
        }
        if (*option && *option++ != ',')
                return false;
        cmdline.option     = EFI_CMDLINE_RES;
        cmdline.res.width  = w;
        cmdline.res.height = h;
        cmdline.res.format = pf;
        cmdline.res.depth  = d;

        *next = option;
        return true;
}

static bool parse_auto(char *option, char **next)
{
        if (!strstarts(option, "auto"))
                return false;
        option += strlen("auto");
        if (*option && *option++ != ',')
                return false;
        cmdline.option = EFI_CMDLINE_AUTO;

        *next = option;
        return true;
}

static bool parse_list(char *option, char **next)
{
        if (!strstarts(option, "list"))
                return false;
        option += strlen("list");
        if (*option && *option++ != ',')
                return false;
        cmdline.option = EFI_CMDLINE_LIST;

        *next = option;
        return true;
}

void efi_parse_option_graphics(char *option)
{
        while (*option) {
                if (parse_modenum(option, &option))
                        continue;
                if (parse_res(option, &option))
                        continue;
                if (parse_auto(option, &option))
                        continue;
                if (parse_list(option, &option))
                        continue;

                while (*option && *option++ != ',')
                        ;
        }
}

static u32 choose_mode_modenum(efi_graphics_output_protocol_t *gop)
{
        efi_graphics_output_mode_info_t *info __free(efi_pool) = NULL;
        efi_graphics_output_protocol_mode_t *mode;
        unsigned long info_size;
        u32 max_mode, cur_mode;
        efi_status_t status;
        int pf;

        mode = efi_table_attr(gop, mode);

        cur_mode = efi_table_attr(mode, mode);
        if (cmdline.mode == cur_mode)
                return cur_mode;

        max_mode = efi_table_attr(mode, max_mode);
        if (cmdline.mode >= max_mode) {
                efi_err("Requested mode is invalid\n");
                return cur_mode;
        }

        status = efi_call_proto(gop, query_mode, cmdline.mode, &info_size, &info);
        if (status != EFI_SUCCESS) {
                efi_err("Couldn't get mode information\n");
                return cur_mode;
        }

        pf = info->pixel_format;
        if (pf == PIXEL_BLT_ONLY || pf >= PIXEL_FORMAT_MAX) {
                efi_err("Invalid PixelFormat\n");
                return cur_mode;
        }

        return cmdline.mode;
}

static u32 choose_mode(efi_graphics_output_protocol_t *gop,
                       bool (*match)(const efi_graphics_output_mode_info_t *, u32, void *),
                       void *ctx)
{
        efi_graphics_output_protocol_mode_t *mode = efi_table_attr(gop, mode);
        u32 max_mode = efi_table_attr(mode, max_mode);

        for (u32 m = 0; m < max_mode; m++) {
                efi_graphics_output_mode_info_t *info __free(efi_pool) = NULL;
                unsigned long info_size;
                efi_status_t status;

                status = efi_call_proto(gop, query_mode, m, &info_size, &info);
                if (status != EFI_SUCCESS)
                        continue;

                if (match(info, m, ctx))
                        return m;
        }
        return (unsigned long)ctx;
}

static u8 pixel_bpp(int pixel_format, efi_pixel_bitmask_t pixel_info)
{
        if (pixel_format == PIXEL_BIT_MASK) {
                u32 mask = pixel_info.red_mask | pixel_info.green_mask |
                           pixel_info.blue_mask | pixel_info.reserved_mask;
                if (!mask)
                        return 0;
                return __fls(mask) - __ffs(mask) + 1;
        } else
                return 32;
}

static bool match_res(const efi_graphics_output_mode_info_t *info, u32 mode, void *ctx)
{
        efi_pixel_bitmask_t pi = info->pixel_information;
        int pf = info->pixel_format;

        if (pf == PIXEL_BLT_ONLY || pf >= PIXEL_FORMAT_MAX)
                return false;

        return cmdline.res.width == info->horizontal_resolution &&
               cmdline.res.height == info->vertical_resolution &&
               (cmdline.res.format < 0 || cmdline.res.format == pf) &&
               (!cmdline.res.depth || cmdline.res.depth == pixel_bpp(pf, pi));
}

static u32 choose_mode_res(efi_graphics_output_protocol_t *gop)
{
        efi_graphics_output_protocol_mode_t *mode = efi_table_attr(gop, mode);
        unsigned long cur_mode = efi_table_attr(mode, mode);

        if (match_res(efi_table_attr(mode, info), cur_mode, NULL))
                return cur_mode;

        return choose_mode(gop, match_res, (void *)cur_mode);
}

struct match {
        u32     mode;
        u32     area;
        u8      depth;
};

static bool match_auto(const efi_graphics_output_mode_info_t *info, u32 mode, void *ctx)
{
        u32 area = info->horizontal_resolution * info->vertical_resolution;
        efi_pixel_bitmask_t pi = info->pixel_information;
        int pf = info->pixel_format;
        u8 depth = pixel_bpp(pf, pi);
        struct match *m = ctx;

        if (pf == PIXEL_BLT_ONLY || pf >= PIXEL_FORMAT_MAX)
                return false;

        if (area > m->area || (area == m->area && depth > m->depth))
                *m = (struct match){ mode, area, depth };

        return false;
}

static u32 choose_mode_auto(efi_graphics_output_protocol_t *gop)
{
        struct match match = {};

        choose_mode(gop, match_auto, &match);

        return match.mode;
}

static bool match_list(const efi_graphics_output_mode_info_t *info, u32 mode, void *ctx)
{
        efi_pixel_bitmask_t pi = info->pixel_information;
        u32 cur_mode = (unsigned long)ctx;
        int pf = info->pixel_format;
        const char *dstr;
        u8 depth = 0;
        bool valid;

        valid = !(pf == PIXEL_BLT_ONLY || pf >= PIXEL_FORMAT_MAX);

        switch (pf) {
        case PIXEL_RGB_RESERVED_8BIT_PER_COLOR:
                dstr = "rgb";
                break;
        case PIXEL_BGR_RESERVED_8BIT_PER_COLOR:
                dstr = "bgr";
                break;
        case PIXEL_BIT_MASK:
                dstr = "";
                depth = pixel_bpp(pf, pi);
                break;
        case PIXEL_BLT_ONLY:
                dstr = "blt";
                break;
        default:
                dstr = "xxx";
                break;
        }

        efi_printk("Mode %3u %c%c: Resolution %ux%u-%s%.0hhu\n",
                    mode,
                    (mode == cur_mode) ? '*' : ' ',
                    !valid ? '-' : ' ',
                    info->horizontal_resolution,
                    info->vertical_resolution,
                    dstr, depth);

        return false;
}

static u32 choose_mode_list(efi_graphics_output_protocol_t *gop)
{
        efi_graphics_output_protocol_mode_t *mode = efi_table_attr(gop, mode);
        unsigned long cur_mode = efi_table_attr(mode, mode);
        u32 max_mode = efi_table_attr(mode, max_mode);
        efi_input_key_t key;
        efi_status_t status;

        efi_printk("Available graphics modes are 0-%u\n", max_mode-1);
        efi_puts("  * = current mode\n"
                 "  - = unusable mode\n");

        choose_mode(gop, match_list, (void *)cur_mode);

        efi_puts("\nPress any key to continue (or wait 10 seconds)\n");
        status = efi_wait_for_key(10 * EFI_USEC_PER_SEC, &key);
        if (status != EFI_SUCCESS && status != EFI_TIMEOUT) {
                efi_err("Unable to read key, continuing in 10 seconds\n");
                efi_bs_call(stall, 10 * EFI_USEC_PER_SEC);
        }

        return cur_mode;
}

static void set_mode(efi_graphics_output_protocol_t *gop)
{
        efi_graphics_output_protocol_mode_t *mode;
        u32 cur_mode, new_mode;

        switch (cmdline.option) {
        case EFI_CMDLINE_MODE_NUM:
                new_mode = choose_mode_modenum(gop);
                break;
        case EFI_CMDLINE_RES:
                new_mode = choose_mode_res(gop);
                break;
        case EFI_CMDLINE_AUTO:
                new_mode = choose_mode_auto(gop);
                break;
        case EFI_CMDLINE_LIST:
                new_mode = choose_mode_list(gop);
                break;
        default:
                return;
        }

        mode = efi_table_attr(gop, mode);
        cur_mode = efi_table_attr(mode, mode);

        if (new_mode == cur_mode)
                return;

        if (efi_call_proto(gop, set_mode, new_mode) != EFI_SUCCESS)
                efi_err("Failed to set requested mode\n");
}

static void find_bits(u32 mask, u8 *pos, u8 *size)
{
        if (!mask) {
                *pos = *size = 0;
                return;
        }

        /* UEFI spec guarantees that the set bits are contiguous */
        *pos  = __ffs(mask);
        *size = __fls(mask) - *pos + 1;
}

static void setup_screen_info(struct screen_info *si, const efi_graphics_output_protocol_t *gop)
{
        const efi_graphics_output_protocol_mode_t *mode = efi_table_attr(gop, mode);
        const efi_graphics_output_mode_info_t *info = efi_table_attr(mode, info);

        si->orig_video_isVGA = VIDEO_TYPE_EFI;

        si->lfb_width  = info->horizontal_resolution;
        si->lfb_height = info->vertical_resolution;

        efi_set_u64_split(efi_table_attr(mode, frame_buffer_base),
                          &si->lfb_base, &si->ext_lfb_base);
        if (si->ext_lfb_base)
                si->capabilities |= VIDEO_CAPABILITY_64BIT_BASE;
        si->pages = 1;

        if (info->pixel_format == PIXEL_BIT_MASK) {
                find_bits(info->pixel_information.red_mask, &si->red_pos, &si->red_size);
                find_bits(info->pixel_information.green_mask, &si->green_pos, &si->green_size);
                find_bits(info->pixel_information.blue_mask, &si->blue_pos, &si->blue_size);
                find_bits(info->pixel_information.reserved_mask, &si->rsvd_pos, &si->rsvd_size);
                si->lfb_depth = si->red_size + si->green_size + si->blue_size + si->rsvd_size;
                si->lfb_linelength = (info->pixels_per_scan_line * si->lfb_depth) / 8;
        } else {
                if (info->pixel_format == PIXEL_RGB_RESERVED_8BIT_PER_COLOR) {
                        si->red_pos   = 0;
                        si->blue_pos  = 16;
                } else /* PIXEL_BGR_RESERVED_8BIT_PER_COLOR */ {
                        si->blue_pos  = 0;
                        si->red_pos   = 16;
                }

                si->green_pos = 8;
                si->rsvd_pos  = 24;
                si->red_size = 8;
                si->green_size = 8;
                si->blue_size = 8;
                si->rsvd_size = 8;
                si->lfb_depth = 32;
                si->lfb_linelength = info->pixels_per_scan_line * 4;
        }

        si->lfb_size = si->lfb_linelength * si->lfb_height;
        si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS;
}

static void setup_edid_info(struct edid_info *edid, u32 gop_size_of_edid, u8 *gop_edid)
{
        if (!gop_edid || gop_size_of_edid < 128)
                memset(edid->dummy, 0, sizeof(edid->dummy));
        else
                memcpy(edid->dummy, gop_edid, min(gop_size_of_edid, sizeof(edid->dummy)));
}

static efi_handle_t find_handle_with_primary_gop(unsigned long num, const efi_handle_t handles[],
                                                 efi_graphics_output_protocol_t **found_gop)
{
        efi_graphics_output_protocol_t *first_gop;
        efi_handle_t h, first_gop_handle;

        first_gop_handle = NULL;
        first_gop = NULL;

        for_each_efi_handle(h, handles, num) {
                efi_status_t status;

                efi_graphics_output_protocol_t *gop;
                efi_graphics_output_protocol_mode_t *mode;
                efi_graphics_output_mode_info_t *info;
                void *dummy = NULL;

                status = efi_bs_call(handle_protocol, h,
                                     &EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID,
                                     (void **)&gop);
                if (status != EFI_SUCCESS)
                        continue;

                mode = efi_table_attr(gop, mode);
                info = efi_table_attr(mode, info);
                if (info->pixel_format == PIXEL_BLT_ONLY ||
                    info->pixel_format >= PIXEL_FORMAT_MAX)
                        continue;

                /*
                 * Systems that use the UEFI Console Splitter may
                 * provide multiple GOP devices, not all of which are
                 * backed by real hardware. The workaround is to search
                 * for a GOP implementing the ConOut protocol, and if
                 * one isn't found, to just fall back to the first GOP.
                 *
                 * Once we've found a GOP supporting ConOut,
                 * don't bother looking any further.
                 */
                status = efi_bs_call(handle_protocol, h,
                                     &EFI_CONSOLE_OUT_DEVICE_GUID, &dummy);
                if (status == EFI_SUCCESS) {
                        if (found_gop)
                                *found_gop = gop;
                        return h;
                } else if (!first_gop_handle) {
                        first_gop_handle = h;
                        first_gop = gop;
                }
        }

        if (found_gop)
                *found_gop = first_gop;
        return first_gop_handle;
}

efi_status_t efi_setup_graphics(struct screen_info *si, struct edid_info *edid)
{
        efi_handle_t *handles __free(efi_pool) = NULL;
        efi_handle_t handle;
        efi_graphics_output_protocol_t *gop;
        efi_status_t status;
        unsigned long num;

        status = efi_bs_call(locate_handle_buffer, EFI_LOCATE_BY_PROTOCOL,
                              &EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID, NULL, &num,
                              &handles);
        if (status != EFI_SUCCESS)
                return status;

        handle = find_handle_with_primary_gop(num, handles, &gop);
        if (!handle)
                return EFI_NOT_FOUND;

        /* Change mode if requested */
        set_mode(gop);

        /* EFI framebuffer */
        if (si)
                setup_screen_info(si, gop);

        /* Display EDID for primary GOP */
        if (edid) {
                efi_edid_discovered_protocol_t *discovered_edid;
                efi_edid_active_protocol_t *active_edid;
                u32 gop_size_of_edid = 0;
                u8 *gop_edid = NULL;

                status = efi_bs_call(handle_protocol, handle, &EFI_EDID_ACTIVE_PROTOCOL_GUID,
                                     (void **)&active_edid);
                if (status == EFI_SUCCESS) {
                        gop_size_of_edid = efi_table_attr(active_edid, size_of_edid);
                        gop_edid = efi_table_attr(active_edid, edid);
                } else {
                        status = efi_bs_call(handle_protocol, handle,
                                             &EFI_EDID_DISCOVERED_PROTOCOL_GUID,
                                             (void **)&discovered_edid);
                        if (status == EFI_SUCCESS) {
                                gop_size_of_edid = efi_table_attr(discovered_edid, size_of_edid);
                                gop_edid = efi_table_attr(discovered_edid, edid);
                        }
                }

                setup_edid_info(edid, gop_size_of_edid, gop_edid);
        }

        return EFI_SUCCESS;
}