x86/efi: Split the boot stub into 32/64 code paths

Make the decision which code path to take at runtime based on
efi_early->is64.

Signed-off-by: Matt Fleming <matt.fleming@intel.com>

1 files changed, 637 insertions, 177 deletions

diff --git a/arch/x86/boot/compressed/eboot.c b/arch/x86/boot/compressed/eboot.c
index 42548168bdc3..ab1f3a2f1e1e 100644
--- a/arch/x86/boot/compressed/eboot.c
+++ b/arch/x86/boot/compressed/eboot.c
@@ -49,10 +49,63 @@ static void efi_printk(efi_system_table_t *, char *);
 static void efi_char16_printk(efi_system_table_t *, efi_char16_t *);
 
 static efi_status_t
-efi_file_size(efi_system_table_t *sys_table, void *__fh,
-              efi_char16_t *filename_16, void **handle, u64 *file_sz)
+__file_size32(void *__fh, efi_char16_t *filename_16,
+              void **handle, u64 *file_sz)
+{
+        efi_file_handle_32_t *h, *fh = __fh;
+        efi_file_info_t *info;
+        efi_status_t status;
+        efi_guid_t info_guid = EFI_FILE_INFO_ID;
+        u32 info_sz;
+
+        status = efi_early->call((unsigned long)fh->open, fh, &h, filename_16,
+                                 EFI_FILE_MODE_READ, (u64)0);
+        if (status != EFI_SUCCESS) {
+                efi_printk(sys_table, "Failed to open file: ");
+                efi_char16_printk(sys_table, filename_16);
+                efi_printk(sys_table, "\n");
+                return status;
+        }
+
+        *handle = h;
+
+        info_sz = 0;
+        status = efi_early->call((unsigned long)h->get_info, h, &info_guid,
+                                 &info_sz, NULL);
+        if (status != EFI_BUFFER_TOO_SMALL) {
+                efi_printk(sys_table, "Failed to get file info size\n");
+                return status;
+        }
+
+grow:
+        status = efi_early->call(efi_early->allocate_pool, EFI_LOADER_DATA,
+                                 info_sz, (void **)&info);
+        if (status != EFI_SUCCESS) {
+                efi_printk(sys_table, "Failed to alloc mem for file info\n");
+                return status;
+        }
+
+        status = efi_early->call((unsigned long)h->get_info, h, &info_guid,
+                                 &info_sz, info);
+        if (status == EFI_BUFFER_TOO_SMALL) {
+                efi_early->call(efi_early->free_pool, info);
+                goto grow;
+        }
+
+        *file_sz = info->file_size;
+        efi_early->call(efi_early->free_pool, info);
+
+        if (status != EFI_SUCCESS)
+                efi_printk(sys_table, "Failed to get initrd info\n");
+
+        return status;
+}
+
+static efi_status_t
+__file_size64(void *__fh, efi_char16_t *filename_16,
+              void **handle, u64 *file_sz)
 {
-        efi_file_handle_t *h, *fh = __fh;
+        efi_file_handle_64_t *h, *fh = __fh;
         efi_file_info_t *info;
         efi_status_t status;
         efi_guid_t info_guid = EFI_FILE_INFO_ID;
@@ -100,31 +153,82 @@ grow:
 
         return status;
 }
+static efi_status_t
+efi_file_size(efi_system_table_t *sys_table, void *__fh,
+              efi_char16_t *filename_16, void **handle, u64 *file_sz)
+{
+        if (efi_early->is64)
+                return __file_size64(__fh, filename_16, handle, file_sz);
+
+        return __file_size32(__fh, filename_16, handle, file_sz);
+}
 
 static inline efi_status_t
 efi_file_read(void *__fh, void *handle, unsigned long *size, void *addr)
 {
-        efi_file_handle_t *fh = __fh;
-        return efi_early->call((unsigned long)fh->read, handle, size, addr);
+        unsigned long func;
+
+        if (efi_early->is64) {
+                efi_file_handle_64_t *fh = __fh;
+
+                func = (unsigned long)fh->read;
+                return efi_early->call(func, handle, size, addr);
+        } else {
+                efi_file_handle_32_t *fh = __fh;
+
+                func = (unsigned long)fh->read;
+                return efi_early->call(func, handle, size, addr);
+        }
 }
 
 static inline efi_status_t efi_file_close(void *__fh, void *handle)
 {
-        efi_file_handle_t *fh = __fh;
+        if (efi_early->is64) {
+                efi_file_handle_64_t *fh = __fh;
 
-        return efi_early->call((unsigned long)fh->close, handle);
+                return efi_early->call((unsigned long)fh->close, handle);
+        } else {
+                efi_file_handle_32_t *fh = __fh;
+
+                return efi_early->call((unsigned long)fh->close, handle);
+        }
 }
 
-static inline efi_status_t
-efi_open_volume(efi_system_table_t *sys_table, void *__image, void **__fh)
+static inline efi_status_t __open_volume32(void *__image, void **__fh)
+{
+        efi_file_io_interface_t *io;
+        efi_loaded_image_32_t *image = __image;
+        efi_file_handle_32_t *fh;
+        efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;
+        efi_status_t status;
+        void *handle = (void *)(unsigned long)image->device_handle;
+        unsigned long func;
+
+        status = efi_early->call(efi_early->handle_protocol, handle,
+                                 &fs_proto, (void **)&io);
+        if (status != EFI_SUCCESS) {
+                efi_printk(sys_table, "Failed to handle fs_proto\n");
+                return status;
+        }
+
+        func = (unsigned long)io->open_volume;
+        status = efi_early->call(func, io, &fh);
+        if (status != EFI_SUCCESS)
+                efi_printk(sys_table, "Failed to open volume\n");
+
+        *__fh = fh;
+        return status;
+}
+
+static inline efi_status_t __open_volume64(void *__image, void **__fh)
 {
         efi_file_io_interface_t *io;
-        efi_loaded_image_t *image = __image;
-        efi_file_handle_t *fh;
+        efi_loaded_image_64_t *image = __image;
+        efi_file_handle_64_t *fh;
         efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;
         efi_status_t status;
         void *handle = (void *)(unsigned long)image->device_handle;
-        u32 func;
+        unsigned long func;
 
         status = efi_early->call(efi_early->handle_protocol, handle,
                                  &fs_proto, (void **)&io);
@@ -142,19 +246,39 @@ efi_open_volume(efi_system_table_t *sys_table, void *__image, void **__fh)
         return status;
 }
 
-static inline void
-efi_char16_printk(efi_system_table_t *table, efi_char16_t *str)
+static inline efi_status_t
+efi_open_volume(efi_system_table_t *sys_table, void *__image, void **__fh)
+{
+        if (efi_early->is64)
+                return __open_volume64(__image, __fh);
+
+        return __open_volume32(__image, __fh);
+}
+
+static void efi_char16_printk(efi_system_table_t *table, efi_char16_t *str)
 {
-        struct efi_simple_text_output_protocol *out;
         unsigned long output_string;
         size_t offset;
-        unsigned long *func;
 
-        offset = offsetof(typeof(*out), output_string);
-        output_string = efi_early->text_output + offset;
-        func = (unsigned long *)output_string;
+        if (efi_early->is64) {
+                struct efi_simple_text_output_protocol_64 *out;
+                u64 *func;
+
+                offset = offsetof(typeof(*out), output_string);
+                output_string = efi_early->text_output + offset;
+                func = (u64 *)output_string;
+
+                efi_early->call(*func, efi_early->text_output, str);
+        } else {
+                struct efi_simple_text_output_protocol_32 *out;
+                u32 *func;
+
+                offset = offsetof(typeof(*out), output_string);
+                output_string = efi_early->text_output + offset;
+                func = (u32 *)output_string;
 
-        efi_early->call(*func, efi_early->text_output, str);
+                efi_early->call(*func, efi_early->text_output, str);
+        }
 }
 
 #include "../../../../drivers/firmware/efi/efi-stub-helper.c"
@@ -182,46 +306,86 @@ static void find_bits(unsigned long mask, u8 *pos, u8 *size)
         *size = len;
 }
 
-static efi_status_t setup_efi_pci(struct boot_params *params)
+static efi_status_t
+__setup_efi_pci32(efi_pci_io_protocol_32 *pci, struct pci_setup_rom **__rom)
 {
-        efi_pci_io_protocol *pci;
+        struct pci_setup_rom *rom = NULL;
         efi_status_t status;
-        void **pci_handle = NULL;
-        efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;
-        unsigned long nr_pci, size = 0;
-        int i;
-        struct setup_data *data;
+        unsigned long size;
+        uint64_t attributes;
 
-        data = (struct setup_data *)(unsigned long)params->hdr.setup_data;
+        status = efi_early->call(pci->attributes, pci,
+                                 EfiPciIoAttributeOperationGet, 0, 0,
+                                 &attributes);
+        if (status != EFI_SUCCESS)
+                return status;
 
-        while (data && data->next)
-                data = (struct setup_data *)(unsigned long)data->next;
+        if (!pci->romimage || !pci->romsize)
+                return EFI_INVALID_PARAMETER;
 
-        status = efi_early->call(efi_early->locate_handle,
-                                 EFI_LOCATE_BY_PROTOCOL,
-                                 &pci_proto, NULL, &size, pci_handle);
+        size = pci->romsize + sizeof(*rom);
 
-        if (status == EFI_BUFFER_TOO_SMALL) {
-                status = efi_early->call(efi_early->allocate_pool,
-                                         EFI_LOADER_DATA,
-                                         size, (void **)&pci_handle);
+        status = efi_early->call(efi_early->allocate_pool,
+                                 EFI_LOADER_DATA, size, &rom);
 
-                if (status != EFI_SUCCESS)
-                        return status;
+        if (status != EFI_SUCCESS)
+                return status;
 
-                status = efi_early->call(efi_early->locate_handle,
-                                         EFI_LOCATE_BY_PROTOCOL, &pci_proto,
-                                         NULL, &size, pci_handle);
-        }
+        memset(rom, 0, sizeof(*rom));
+
+        rom->data.type = SETUP_PCI;
+        rom->data.len = size - sizeof(struct setup_data);
+        rom->data.next = 0;
+        rom->pcilen = pci->romsize;
+        *__rom = rom;
+
+        status = efi_early->call(pci->pci.read, pci, EfiPciIoWidthUint16,
+                                 PCI_VENDOR_ID, 1, &(rom->vendor));
 
         if (status != EFI_SUCCESS)
-                goto free_handle;
+                goto free_struct;
+
+        status = efi_early->call(pci->pci.read, pci, EfiPciIoWidthUint16,
+                                 PCI_DEVICE_ID, 1, &(rom->devid));
+
+        if (status != EFI_SUCCESS)
+                goto free_struct;
 
-        nr_pci = size / sizeof(void *);
+        status = efi_early->call(pci->get_location, pci, &(rom->segment),
+                                 &(rom->bus), &(rom->device), &(rom->function));
+
+        if (status != EFI_SUCCESS)
+                goto free_struct;
+
+        memcpy(rom->romdata, pci->romimage, pci->romsize);
+        return status;
+
+free_struct:
+        efi_early->call(efi_early->free_pool, rom);
+        return status;
+}
+
+static efi_status_t
+setup_efi_pci32(struct boot_params *params, void **pci_handle,
+                unsigned long size)
+{
+        efi_pci_io_protocol_32 *pci = NULL;
+        efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;
+        u32 *handles = (u32 *)(unsigned long)pci_handle;
+        efi_status_t status;
+        unsigned long nr_pci;
+        struct setup_data *data;
+        int i;
+
+        data = (struct setup_data *)(unsigned long)params->hdr.setup_data;
+
+        while (data && data->next)
+                data = (struct setup_data *)(unsigned long)data->next;
+
+        nr_pci = size / sizeof(u32);
         for (i = 0; i < nr_pci; i++) {
-                void *h = pci_handle[i];
-                uint64_t attributes;
-                struct pci_setup_rom *rom;
+                struct pci_setup_rom *rom = NULL;
+                u32 h = handles[i];
 
                 status = efi_early->call(efi_early->handle_protocol, h,
                                          &pci_proto, (void **)&pci);
@@ -232,56 +396,114 @@ static efi_status_t setup_efi_pci(struct boot_params *params)
                 if (!pci)
                         continue;
 
-#ifdef CONFIG_X86_64
-                status = efi_early->call((unsigned long)pci->attributes, pci,
-                                         EfiPciIoAttributeOperationGet, 0,
-                                         &attributes);
-#else
-                status = efi_early->call((unsigned long)pci->attributes, pci,
-                                         EfiPciIoAttributeOperationGet, 0, 0,
-                                         &attributes);
-#endif
+                status = __setup_efi_pci32(pci, &rom);
                 if (status != EFI_SUCCESS)
                         continue;
 
-                if (!pci->romimage || !pci->romsize)
-                        continue;
+                if (data)
+                        data->next = (unsigned long)rom;
+                else
+                        params->hdr.setup_data = (unsigned long)rom;
 
-                size = pci->romsize + sizeof(*rom);
+                data = (struct setup_data *)rom;
 
-                status = efi_early->call(efi_early->allocate_pool,
-                                         EFI_LOADER_DATA, size, &rom);
+        }
 
-                if (status != EFI_SUCCESS)
-                        continue;
+        return status;
+}
 
-                rom->data.type = SETUP_PCI;
-                rom->data.len = size - sizeof(struct setup_data);
-                rom->data.next = 0;
-                rom->pcilen = pci->romsize;
+static efi_status_t
+__setup_efi_pci64(efi_pci_io_protocol_64 *pci, struct pci_setup_rom **__rom)
+{
+        struct pci_setup_rom *rom;
+        efi_status_t status;
+        unsigned long size;
+        uint64_t attributes;
 
-                status = efi_early->call((unsigned long)pci->pci.read, pci,
-                                         EfiPciIoWidthUint16, PCI_VENDOR_ID,
-                                         1, &(rom->vendor));
+        status = efi_early->call(pci->attributes, pci,
+                                 EfiPciIoAttributeOperationGet, 0,
+                                 &attributes);
+        if (status != EFI_SUCCESS)
+                return status;
 
-                if (status != EFI_SUCCESS)
-                        goto free_struct;
+        if (!pci->romimage || !pci->romsize)
+                return EFI_INVALID_PARAMETER;
 
-                status = efi_early->call((unsigned long)pci->pci.read, pci,
-                                         EfiPciIoWidthUint16, PCI_DEVICE_ID,
-                                         1, &(rom->devid));
+        size = pci->romsize + sizeof(*rom);
 
-                if (status != EFI_SUCCESS)
-                        goto free_struct;
+        status = efi_early->call(efi_early->allocate_pool,
+                                 EFI_LOADER_DATA, size, &rom);
+
+        if (status != EFI_SUCCESS)
+                return status;
+
+        rom->data.type = SETUP_PCI;
+        rom->data.len = size - sizeof(struct setup_data);
+        rom->data.next = 0;
+        rom->pcilen = pci->romsize;
+        *__rom = rom;
+
+        status = efi_early->call(pci->pci.read, pci, EfiPciIoWidthUint16,
+                                 PCI_VENDOR_ID, 1, &(rom->vendor));
+
+        if (status != EFI_SUCCESS)
+                goto free_struct;
+
+        status = efi_early->call(pci->pci.read, pci, EfiPciIoWidthUint16,
+                                 PCI_DEVICE_ID, 1, &(rom->devid));
+
+        if (status != EFI_SUCCESS)
+                goto free_struct;
+
+        status = efi_early->call(pci->get_location, pci, &(rom->segment),
+                                 &(rom->bus), &(rom->device), &(rom->function));
 
-                status = efi_early->call((unsigned long)pci->get_location, pci,
-                                         &(rom->segment), &(rom->bus),
-                                         &(rom->device), &(rom->function));
+        if (status != EFI_SUCCESS)
+                goto free_struct;
+
+        memcpy(rom->romdata, pci->romimage, pci->romsize);
+        return status;
+
+free_struct:
+        efi_early->call(efi_early->free_pool, rom);
+        return status;
+
+}
+
+static efi_status_t
+setup_efi_pci64(struct boot_params *params, void **pci_handle,
+                unsigned long size)
+{
+        efi_pci_io_protocol_64 *pci = NULL;
+        efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;
+        u64 *handles = (u64 *)(unsigned long)pci_handle;
+        efi_status_t status;
+        unsigned long nr_pci;
+        struct setup_data *data;
+        int i;
+
+        data = (struct setup_data *)(unsigned long)params->hdr.setup_data;
+
+        while (data && data->next)
+                data = (struct setup_data *)(unsigned long)data->next;
+
+        nr_pci = size / sizeof(u64);
+        for (i = 0; i < nr_pci; i++) {
+                struct pci_setup_rom *rom = NULL;
+                u64 h = handles[i];
+
+                status = efi_early->call(efi_early->handle_protocol, h,
+                                         &pci_proto, (void **)&pci);
 
                 if (status != EFI_SUCCESS)
-                        goto free_struct;
+                        continue;
+
+                if (!pci)
+                        continue;
 
-                memcpy(rom->romdata, pci->romimage, pci->romsize);
+                status = __setup_efi_pci64(pci, &rom);
+                if (status != EFI_SUCCESS)
+                        continue;
 
                 if (data)
                         data->next = (unsigned long)rom;
@@ -290,56 +512,250 @@ static efi_status_t setup_efi_pci(struct boot_params *params)
 
                 data = (struct setup_data *)rom;
 
-                continue;
-        free_struct:
-                efi_early->call(efi_early->free_pool, rom);
         }
 
+        return status;
+}
+
+static efi_status_t setup_efi_pci(struct boot_params *params)
+{
+        efi_status_t status;
+        void **pci_handle = NULL;
+        efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;
+        unsigned long size = 0;
+
+        status = efi_early->call(efi_early->locate_handle,
+                                 EFI_LOCATE_BY_PROTOCOL,
+                                 &pci_proto, NULL, &size, pci_handle);
+
+        if (status == EFI_BUFFER_TOO_SMALL) {
+                status = efi_early->call(efi_early->allocate_pool,
+                                         EFI_LOADER_DATA,
+                                         size, (void **)&pci_handle);
+
+                if (status != EFI_SUCCESS)
+                        return status;
+
+                status = efi_early->call(efi_early->locate_handle,
+                                         EFI_LOCATE_BY_PROTOCOL, &pci_proto,
+                                         NULL, &size, pci_handle);
+        }
+
+        if (status != EFI_SUCCESS)
+                goto free_handle;
+
+        if (efi_early->is64)
+                status = setup_efi_pci64(params, pci_handle, size);
+        else
+                status = setup_efi_pci32(params, pci_handle, size);
+
 free_handle:
         efi_early->call(efi_early->free_pool, pci_handle);
         return status;
 }
 
-/*
- * See if we have Graphics Output Protocol
- */
-static efi_status_t setup_gop(struct screen_info *si, efi_guid_t *proto,
-                              unsigned long size)
+static void
+setup_pixel_info(struct screen_info *si, u32 pixels_per_scan_line,
+                 struct efi_pixel_bitmask pixel_info, int pixel_format)
 {
-        struct efi_graphics_output_protocol *gop, *first_gop;
-        struct efi_pixel_bitmask pixel_info;
-        unsigned long nr_gops;
+        if (pixel_format == PIXEL_RGB_RESERVED_8BIT_PER_COLOR) {
+                si->lfb_depth = 32;
+                si->lfb_linelength = pixels_per_scan_line * 4;
+                si->red_size = 8;
+                si->red_pos = 0;
+                si->green_size = 8;
+                si->green_pos = 8;
+                si->blue_size = 8;
+                si->blue_pos = 16;
+                si->rsvd_size = 8;
+                si->rsvd_pos = 24;
+        } else if (pixel_format == PIXEL_BGR_RESERVED_8BIT_PER_COLOR) {
+                si->lfb_depth = 32;
+                si->lfb_linelength = pixels_per_scan_line * 4;
+                si->red_size = 8;
+                si->red_pos = 16;
+                si->green_size = 8;
+                si->green_pos = 8;
+                si->blue_size = 8;
+                si->blue_pos = 0;
+                si->rsvd_size = 8;
+                si->rsvd_pos = 24;
+        } else if (pixel_format == PIXEL_BIT_MASK) {
+                find_bits(pixel_info.red_mask, &si->red_pos, &si->red_size);
+                find_bits(pixel_info.green_mask, &si->green_pos,
+                          &si->green_size);
+                find_bits(pixel_info.blue_mask, &si->blue_pos, &si->blue_size);
+                find_bits(pixel_info.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 = (pixels_per_scan_line * si->lfb_depth) / 8;
+        } else {
+                si->lfb_depth = 4;
+                si->lfb_linelength = si->lfb_width / 2;
+                si->red_size = 0;
+                si->red_pos = 0;
+                si->green_size = 0;
+                si->green_pos = 0;
+                si->blue_size = 0;
+                si->blue_pos = 0;
+                si->rsvd_size = 0;
+                si->rsvd_pos = 0;
+        }
+}
+
+static efi_status_t
+__gop_query32(struct efi_graphics_output_protocol_32 *gop32,
+              struct efi_graphics_output_mode_info **info,
+              unsigned long *size, u32 *fb_base)
+{
+        struct efi_graphics_output_protocol_mode_32 *mode;
         efi_status_t status;
-        void **gop_handle = NULL;
+        unsigned long m;
+
+        m = gop32->mode;
+        mode = (struct efi_graphics_output_protocol_mode_32 *)m;
+
+        status = efi_early->call(gop32->query_mode, gop32,
+                                 mode->mode, size, info);
+        if (status != EFI_SUCCESS)
+                return status;
+
+        *fb_base = mode->frame_buffer_base;
+        return status;
+}
+
+static efi_status_t
+setup_gop32(struct screen_info *si, efi_guid_t *proto,
+            unsigned long size, void **gop_handle)
+{
+        struct efi_graphics_output_protocol_32 *gop32, *first_gop;
+        unsigned long nr_gops;
         u16 width, height;
-        u32 fb_base, fb_size;
         u32 pixels_per_scan_line;
+        u32 fb_base;
+        struct efi_pixel_bitmask pixel_info;
         int pixel_format;
+        efi_status_t status;
+        u32 *handles = (u32 *)(unsigned long)gop_handle;
         int i;
 
-        status = efi_early->call(efi_early->allocate_pool, EFI_LOADER_DATA,
-                                 size, (void **)&gop_handle);
+        first_gop = NULL;
+        gop32 = NULL;
+
+        nr_gops = size / sizeof(u32);
+        for (i = 0; i < nr_gops; i++) {
+                struct efi_graphics_output_mode_info *info = NULL;
+                efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
+                bool conout_found = false;
+                void *dummy = NULL;
+                u32 h = handles[i];
+
+                status = efi_early->call(efi_early->handle_protocol, h,
+                                         proto, (void **)&gop32);
+                if (status != EFI_SUCCESS)
+                        continue;
+
+                status = efi_early->call(efi_early->handle_protocol, h,
+                                         &conout_proto, &dummy);
+                if (status == EFI_SUCCESS)
+                        conout_found = true;
+
+                status = __gop_query32(gop32, &info, &size, &fb_base);
+                if (status == EFI_SUCCESS && (!first_gop || conout_found)) {
+                        /*
+                         * 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.
+                         */
+                        width = info->horizontal_resolution;
+                        height = info->vertical_resolution;
+                        pixel_format = info->pixel_format;
+                        pixel_info = info->pixel_information;
+                        pixels_per_scan_line = info->pixels_per_scan_line;
+
+                        /*
+                         * Once we've found a GOP supporting ConOut,
+                         * don't bother looking any further.
+                         */
+                        first_gop = gop32;
+                        if (conout_found)
+                                break;
+                }
+        }
+
+        /* Did we find any GOPs? */
+        if (!first_gop)
+                goto out;
+
+        /* EFI framebuffer */
+        si->orig_video_isVGA = VIDEO_TYPE_EFI;
+
+        si->lfb_width = width;
+        si->lfb_height = height;
+        si->lfb_base = fb_base;
+        si->pages = 1;
+
+        setup_pixel_info(si, pixels_per_scan_line, pixel_info, pixel_format);
+
+        si->lfb_size = si->lfb_linelength * si->lfb_height;
+
+        si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS;
+out:
+        return status;
+}
+
+static efi_status_t
+__gop_query64(struct efi_graphics_output_protocol_64 *gop64,
+              struct efi_graphics_output_mode_info **info,
+              unsigned long *size, u32 *fb_base)
+{
+        struct efi_graphics_output_protocol_mode_64 *mode;
+        efi_status_t status;
+        unsigned long m;
+
+        m = gop64->mode;
+        mode = (struct efi_graphics_output_protocol_mode_64 *)m;
+
+        status = efi_early->call(gop64->query_mode, gop64,
+                                 mode->mode, size, info);
         if (status != EFI_SUCCESS)
                 return status;
 
-        status = efi_early->call(efi_early->locate_handle,
-                                 EFI_LOCATE_BY_PROTOCOL,
-                                 proto, NULL, &size, gop_handle);
-        if (status != EFI_SUCCESS)
-                goto free_handle;
+        *fb_base = mode->frame_buffer_base;
+        return status;
+}
+
+static efi_status_t
+setup_gop64(struct screen_info *si, efi_guid_t *proto,
+            unsigned long size, void **gop_handle)
+{
+        struct efi_graphics_output_protocol_64 *gop64, *first_gop;
+        unsigned long nr_gops;
+        u16 width, height;
+        u32 pixels_per_scan_line;
+        u32 fb_base;
+        struct efi_pixel_bitmask pixel_info;
+        int pixel_format;
+        efi_status_t status;
+        u64 *handles = (u64 *)(unsigned long)gop_handle;
+        int i;
 
         first_gop = NULL;
+        gop64 = NULL;
 
-        nr_gops = size / sizeof(void *);
+        nr_gops = size / sizeof(u64);
         for (i = 0; i < nr_gops; i++) {
-                struct efi_graphics_output_mode_info *info;
+                struct efi_graphics_output_mode_info *info = NULL;
                 efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
                 bool conout_found = false;
-                void *dummy;
-                void *h = gop_handle[i];
+                void *dummy = NULL;
+                u64 h = handles[i];
 
                 status = efi_early->call(efi_early->handle_protocol, h,
-                                         proto, (void **)&gop);
+                                         proto, (void **)&gop64);
                 if (status != EFI_SUCCESS)
                         continue;
 
@@ -348,8 +764,7 @@ static efi_status_t setup_gop(struct screen_info *si, efi_guid_t *proto,
                 if (status == EFI_SUCCESS)
                         conout_found = true;
 
-                status = efi_early->call((unsigned long)gop->query_mode, gop,
-                                         gop->mode->mode, &size, &info);
+                status = __gop_query64(gop64, &info, &size, &fb_base);
                 if (status == EFI_SUCCESS && (!first_gop || conout_found)) {
                         /*
                          * Systems that use the UEFI Console Splitter may
@@ -360,8 +775,6 @@ static efi_status_t setup_gop(struct screen_info *si, efi_guid_t *proto,
                          */
                         width = info->horizontal_resolution;
                         height = info->vertical_resolution;
-                        fb_base = gop->mode->frame_buffer_base;
-                        fb_size = gop->mode->frame_buffer_size;
                         pixel_format = info->pixel_format;
                         pixel_info = info->pixel_information;
                         pixels_per_scan_line = info->pixels_per_scan_line;
@@ -370,7 +783,7 @@ static efi_status_t setup_gop(struct screen_info *si, efi_guid_t *proto,
                          * Once we've found a GOP supporting ConOut,
                          * don't bother looking any further.
                          */
-                        first_gop = gop;
+                        first_gop = gop64;
                         if (conout_found)
                                 break;
                 }
@@ -378,7 +791,7 @@ static efi_status_t setup_gop(struct screen_info *si, efi_guid_t *proto,
 
         /* Did we find any GOPs? */
         if (!first_gop)
-                goto free_handle;
+                goto out;
 
         /* EFI framebuffer */
         si->orig_video_isVGA = VIDEO_TYPE_EFI;
@@ -388,95 +801,111 @@ static efi_status_t setup_gop(struct screen_info *si, efi_guid_t *proto,
         si->lfb_base = fb_base;
         si->pages = 1;
 
-        if (pixel_format == PIXEL_RGB_RESERVED_8BIT_PER_COLOR) {
-                si->lfb_depth = 32;
-                si->lfb_linelength = pixels_per_scan_line * 4;
-                si->red_size = 8;
-                si->red_pos = 0;
-                si->green_size = 8;
-                si->green_pos = 8;
-                si->blue_size = 8;
-                si->blue_pos = 16;
-                si->rsvd_size = 8;
-                si->rsvd_pos = 24;
-        } else if (pixel_format == PIXEL_BGR_RESERVED_8BIT_PER_COLOR) {
-                si->lfb_depth = 32;
-                si->lfb_linelength = pixels_per_scan_line * 4;
-                si->red_size = 8;
-                si->red_pos = 16;
-                si->green_size = 8;
-                si->green_pos = 8;
-                si->blue_size = 8;
-                si->blue_pos = 0;
-                si->rsvd_size = 8;
-                si->rsvd_pos = 24;
-        } else if (pixel_format == PIXEL_BIT_MASK) {
-                find_bits(pixel_info.red_mask, &si->red_pos, &si->red_size);
-                find_bits(pixel_info.green_mask, &si->green_pos,
-                          &si->green_size);
-                find_bits(pixel_info.blue_mask, &si->blue_pos, &si->blue_size);
-                find_bits(pixel_info.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 = (pixels_per_scan_line * si->lfb_depth) / 8;
-        } else {
-                si->lfb_depth = 4;
-                si->lfb_linelength = si->lfb_width / 2;
-                si->red_size = 0;
-                si->red_pos = 0;
-                si->green_size = 0;
-                si->green_pos = 0;
-                si->blue_size = 0;
-                si->blue_pos = 0;
-                si->rsvd_size = 0;
-                si->rsvd_pos = 0;
-        }
+        setup_pixel_info(si, pixels_per_scan_line, pixel_info, pixel_format);
 
         si->lfb_size = si->lfb_linelength * si->lfb_height;
 
         si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS;
-
-free_handle:
-        efi_early->call(efi_early->free_pool, gop_handle);
+out:
         return status;
 }
 
 /*
- * See if we have Universal Graphics Adapter (UGA) protocol
+ * See if we have Graphics Output Protocol
  */
-static efi_status_t setup_uga(struct screen_info *si, efi_guid_t *uga_proto,
+static efi_status_t setup_gop(struct screen_info *si, efi_guid_t *proto,
                               unsigned long size)
 {
-        struct efi_uga_draw_protocol *uga, *first_uga;
-        unsigned long nr_ugas;
         efi_status_t status;
-        u32 width, height;
-        void **uga_handle = NULL;
-        int i;
+        void **gop_handle = NULL;
 
         status = efi_early->call(efi_early->allocate_pool, EFI_LOADER_DATA,
-                                 size, (void **)&uga_handle);
+                                 size, (void **)&gop_handle);
         if (status != EFI_SUCCESS)
                 return status;
 
         status = efi_early->call(efi_early->locate_handle,
                                  EFI_LOCATE_BY_PROTOCOL,
-                                 uga_proto, NULL, &size, uga_handle);
+                                 proto, NULL, &size, gop_handle);
         if (status != EFI_SUCCESS)
                 goto free_handle;
 
+        if (efi_early->is64)
+                status = setup_gop64(si, proto, size, gop_handle);
+        else
+                status = setup_gop32(si, proto, size, gop_handle);
+
+free_handle:
+        efi_early->call(efi_early->free_pool, gop_handle);
+        return status;
+}
+
+static efi_status_t
+setup_uga32(void **uga_handle, unsigned long size, u32 *width, u32 *height)
+{
+        struct efi_uga_draw_protocol *uga = NULL, *first_uga;
+        efi_guid_t uga_proto = EFI_UGA_PROTOCOL_GUID;
+        unsigned long nr_ugas;
+        u32 *handles = (u32 *)uga_handle;;
+        efi_status_t status;
+        int i;
+
         first_uga = NULL;
+        nr_ugas = size / sizeof(u32);
+        for (i = 0; i < nr_ugas; i++) {
+                efi_guid_t pciio_proto = EFI_PCI_IO_PROTOCOL_GUID;
+                u32 w, h, depth, refresh;
+                void *pciio;
+                u32 handle = handles[i];
+
+                status = efi_early->call(efi_early->handle_protocol, handle,
+                                         &uga_proto, (void **)&uga);
+                if (status != EFI_SUCCESS)
+                        continue;
+
+                efi_early->call(efi_early->handle_protocol, handle,
+                                &pciio_proto, &pciio);
+
+                status = efi_early->call((unsigned long)uga->get_mode, uga,
+                                         &w, &h, &depth, &refresh);
+                if (status == EFI_SUCCESS && (!first_uga || pciio)) {
+                        *width = w;
+                        *height = h;
+
+                        /*
+                         * Once we've found a UGA supporting PCIIO,
+                         * don't bother looking any further.
+                         */
+                        if (pciio)
+                                break;
 
-        nr_ugas = size / sizeof(void *);
+                        first_uga = uga;
+                }
+        }
+
+        return status;
+}
+
+static efi_status_t
+setup_uga64(void **uga_handle, unsigned long size, u32 *width, u32 *height)
+{
+        struct efi_uga_draw_protocol *uga = NULL, *first_uga;
+        efi_guid_t uga_proto = EFI_UGA_PROTOCOL_GUID;
+        unsigned long nr_ugas;
+        u64 *handles = (u64 *)uga_handle;;
+        efi_status_t status;
+        int i;
+
+        first_uga = NULL;
+        nr_ugas = size / sizeof(u64);
         for (i = 0; i < nr_ugas; i++) {
                 efi_guid_t pciio_proto = EFI_PCI_IO_PROTOCOL_GUID;
-                void *handle = uga_handle[i];
                 u32 w, h, depth, refresh;
                 void *pciio;
+                u64 handle = handles[i];
 
                 status = efi_early->call(efi_early->handle_protocol, handle,
-                                         uga_proto, (void **)&uga);
+                                         &uga_proto, (void **)&uga);
                 if (status != EFI_SUCCESS)
                         continue;
 
@@ -486,8 +915,8 @@ static efi_status_t setup_uga(struct screen_info *si, efi_guid_t *uga_proto,
                 status = efi_early->call((unsigned long)uga->get_mode, uga,
                                          &w, &h, &depth, &refresh);
                 if (status == EFI_SUCCESS && (!first_uga || pciio)) {
-                        width = w;
-                        height = h;
+                        *width = w;
+                        *height = h;
 
                         /*
                          * Once we've found a UGA supporting PCIIO,
@@ -500,7 +929,39 @@ static efi_status_t setup_uga(struct screen_info *si, efi_guid_t *uga_proto,
                 }
         }
 
-        if (!first_uga)
+        return status;
+}
+
+/*
+ * See if we have Universal Graphics Adapter (UGA) protocol
+ */
+static efi_status_t setup_uga(struct screen_info *si, efi_guid_t *uga_proto,
+                              unsigned long size)
+{
+        efi_status_t status;
+        u32 width, height;
+        void **uga_handle = NULL;
+
+        status = efi_early->call(efi_early->allocate_pool, EFI_LOADER_DATA,
+                                 size, (void **)&uga_handle);
+        if (status != EFI_SUCCESS)
+                return status;
+
+        status = efi_early->call(efi_early->locate_handle,
+                                 EFI_LOCATE_BY_PROTOCOL,
+                                 uga_proto, NULL, &size, uga_handle);
+        if (status != EFI_SUCCESS)
+                goto free_handle;
+
+        height = 0;
+        width = 0;
+
+        if (efi_early->is64)
+                status = setup_uga64(uga_handle, size, &width, &height);
+        else
+                status = setup_uga32(uga_handle, size, &width, &height);
+
+        if (!width && !height)
                 goto free_handle;
 
         /* EFI framebuffer */
@@ -519,7 +980,6 @@ static efi_status_t setup_uga(struct screen_info *si, efi_guid_t *uga_proto,
         si->rsvd_size = 8;
         si->rsvd_pos = 24;
 
-
 free_handle:
         efi_early->call(efi_early->free_pool, uga_handle);
         return status;