Skip to content
Navigation Menu
Toggle navigation
Sign in
In this repository
All GitHub Enterprise
↵
Jump to
↵
No suggested jump to results
In this repository
All GitHub Enterprise
↵
Jump to
↵
In this organization
All GitHub Enterprise
↵
Jump to
↵
In this repository
All GitHub Enterprise
↵
Jump to
↵
Sign in
Reseting focus
You signed in with another tab or window.
Reload
to refresh your session.
You signed out in another tab or window.
Reload
to refresh your session.
You switched accounts on another tab or window.
Reload
to refresh your session.
Dismiss alert
{{ message }}
mariux64
/
linux
Public
Notifications
You must be signed in to change notification settings
Fork
0
Star
0
Code
Issues
2
Pull requests
0
Actions
Projects
0
Wiki
Security
Insights
Additional navigation options
Code
Issues
Pull requests
Actions
Projects
Wiki
Security
Insights
Files
14fb420
Documentation
LICENSES
arch
block
certs
crypto
drivers
accessibility
acpi
amba
android
ata
atm
auxdisplay
base
bcma
block
bluetooth
bus
cdrom
char
clk
clocksource
connector
counter
cpufreq
cpuidle
crypto
dax
dca
devfreq
dio
dma-buf
dma
edac
eisa
extcon
firewire
firmware
arm_scmi
broadcom
efi
libstub
test
Kconfig
Makefile
apple-properties.c
arm-init.c
arm-runtime.c
capsule-loader.c
capsule.c
cper-arm.c
cper-x86.c
cper.c
dev-path-parser.c
earlycon.c
efi-bgrt.c
efi-pstore.c
efi.c
efibc.c
efivars.c
esrt.c
fake_mem.c
fake_mem.h
memattr.c
memmap.c
rci2-table.c
reboot.c
runtime-map.c
runtime-wrappers.c
tpm.c
vars.c
x86_fake_mem.c
google
imx
meson
psci
tegra
xilinx
Kconfig
Makefile
arm_scpi.c
arm_sdei.c
dmi-id.c
dmi-sysfs.c
dmi_scan.c
edd.c
iscsi_ibft.c
iscsi_ibft_find.c
memmap.c
pcdp.c
pcdp.h
qcom_scm-legacy.c
qcom_scm-smc.c
qcom_scm.c
qcom_scm.h
qemu_fw_cfg.c
raspberrypi.c
scpi_pm_domain.c
stratix10-rsu.c
stratix10-svc.c
ti_sci.c
ti_sci.h
trusted_foundations.c
turris-mox-rwtm.c
fpga
fsi
gnss
gpio
gpu
greybus
hid
hsi
hv
hwmon
hwspinlock
hwtracing
i2c
i3c
ide
idle
iio
infiniband
input
interconnect
iommu
ipack
irqchip
isdn
leds
lightnvm
macintosh
mailbox
mcb
md
media
memory
memstick
message
mfd
misc
mmc
mtd
mux
net
nfc
ntb
nubus
nvdimm
nvme
nvmem
of
opp
oprofile
parisc
parport
pci
pcmcia
perf
phy
pinctrl
platform
pnp
power
powercap
pps
ps3
ptp
pwm
rapidio
ras
regulator
remoteproc
reset
rpmsg
rtc
s390
sbus
scsi
sfi
sh
siox
slimbus
soc
soundwire
spi
spmi
ssb
staging
target
tc
tee
thermal
thunderbolt
tty
uio
usb
vfio
vhost
video
virt
virtio
visorbus
vlynq
vme
w1
watchdog
xen
zorro
Kconfig
Makefile
fs
include
init
ipc
kernel
lib
mm
net
samples
scripts
security
sound
tools
usr
virt
.clang-format
.cocciconfig
.get_maintainer.ignore
.gitattributes
.gitignore
.mailmap
COPYING
CREDITS
Kbuild
Kconfig
MAINTAINERS
Makefile
README
Breadcrumbs
linux
/
drivers
/
firmware
/
efi
/
arm-init.c
Blame
Blame
Latest commit
History
History
367 lines (299 loc) · 8.9 KB
Breadcrumbs
linux
/
drivers
/
firmware
/
efi
/
arm-init.c
Top
File metadata and controls
Code
Blame
367 lines (299 loc) · 8.9 KB
Raw
// SPDX-License-Identifier: GPL-2.0 /* * Extensible Firmware Interface * * Based on Extensible Firmware Interface Specification version 2.4 * * Copyright (C) 2013 - 2015 Linaro Ltd. */ #define pr_fmt(fmt) "efi: " fmt #include <linux/efi.h> #include <linux/fwnode.h> #include <linux/init.h> #include <linux/memblock.h> #include <linux/mm_types.h> #include <linux/of.h> #include <linux/of_address.h> #include <linux/of_fdt.h> #include <linux/platform_device.h> #include <linux/screen_info.h> #include <asm/efi.h> u64 efi_system_table; static int __init is_memory(efi_memory_desc_t *md) { if (md->attribute & (EFI_MEMORY_WB|EFI_MEMORY_WT|EFI_MEMORY_WC)) return 1; return 0; } /* * Translate a EFI virtual address into a physical address: this is necessary, * as some data members of the EFI system table are virtually remapped after * SetVirtualAddressMap() has been called. */ static phys_addr_t efi_to_phys(unsigned long addr) { efi_memory_desc_t *md; for_each_efi_memory_desc(md) { if (!(md->attribute & EFI_MEMORY_RUNTIME)) continue; if (md->virt_addr == 0) /* no virtual mapping has been installed by the stub */ break; if (md->virt_addr <= addr && (addr - md->virt_addr) < (md->num_pages << EFI_PAGE_SHIFT)) return md->phys_addr + addr - md->virt_addr; } return addr; } static __initdata unsigned long screen_info_table = EFI_INVALID_TABLE_ADDR; static __initdata efi_config_table_type_t arch_tables[] = { {LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID, NULL, &screen_info_table}, {NULL_GUID, NULL, NULL} }; static void __init init_screen_info(void) { struct screen_info *si; if (screen_info_table != EFI_INVALID_TABLE_ADDR) { si = early_memremap_ro(screen_info_table, sizeof(*si)); if (!si) { pr_err("Could not map screen_info config table\n"); return; } screen_info = *si; early_memunmap(si, sizeof(*si)); /* dummycon on ARM needs non-zero values for columns/lines */ screen_info.orig_video_cols = 80; screen_info.orig_video_lines = 25; } if (screen_info.orig_video_isVGA == VIDEO_TYPE_EFI && memblock_is_map_memory(screen_info.lfb_base)) memblock_mark_nomap(screen_info.lfb_base, screen_info.lfb_size); } static int __init uefi_init(void) { void *config_tables; size_t table_size; int retval; efi.systab = early_memremap_ro(efi_system_table, sizeof(efi_system_table_t)); if (efi.systab == NULL) { pr_warn("Unable to map EFI system table.\n"); return -ENOMEM; } set_bit(EFI_BOOT, &efi.flags); if (IS_ENABLED(CONFIG_64BIT)) set_bit(EFI_64BIT, &efi.flags); retval = efi_systab_check_header(&efi.systab->hdr, 2); if (retval) goto out; efi.runtime_version = efi.systab->hdr.revision; efi_systab_report_header(&efi.systab->hdr, efi_to_phys(efi.systab->fw_vendor)); table_size = sizeof(efi_config_table_64_t) * efi.systab->nr_tables; config_tables = early_memremap_ro(efi_to_phys(efi.systab->tables), table_size); if (config_tables == NULL) { pr_warn("Unable to map EFI config table array.\n"); retval = -ENOMEM; goto out; } retval = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sizeof(efi_config_table_t), arch_tables); if (!retval) efi.config_table = (unsigned long)efi.systab->tables; early_memunmap(config_tables, table_size); out: early_memunmap(efi.systab, sizeof(efi_system_table_t)); return retval; } /* * Return true for regions that can be used as System RAM. */ static __init int is_usable_memory(efi_memory_desc_t *md) { switch (md->type) { case EFI_LOADER_CODE: case EFI_LOADER_DATA: case EFI_ACPI_RECLAIM_MEMORY: case EFI_BOOT_SERVICES_CODE: case EFI_BOOT_SERVICES_DATA: case EFI_CONVENTIONAL_MEMORY: case EFI_PERSISTENT_MEMORY: /* * Special purpose memory is 'soft reserved', which means it * is set aside initially, but can be hotplugged back in or * be assigned to the dax driver after boot. */ if (efi_soft_reserve_enabled() && (md->attribute & EFI_MEMORY_SP)) return false; /* * According to the spec, these regions are no longer reserved * after calling ExitBootServices(). However, we can only use * them as System RAM if they can be mapped writeback cacheable. */ return (md->attribute & EFI_MEMORY_WB); default: break; } return false; } static __init void reserve_regions(void) { efi_memory_desc_t *md; u64 paddr, npages, size; if (efi_enabled(EFI_DBG)) pr_info("Processing EFI memory map:\n"); /* * Discard memblocks discovered so far: if there are any at this * point, they originate from memory nodes in the DT, and UEFI * uses its own memory map instead. */ memblock_dump_all(); memblock_remove(0, PHYS_ADDR_MAX); for_each_efi_memory_desc(md) { paddr = md->phys_addr; npages = md->num_pages; if (efi_enabled(EFI_DBG)) { char buf[64]; pr_info(" 0x%012llx-0x%012llx %s\n", paddr, paddr + (npages << EFI_PAGE_SHIFT) - 1, efi_md_typeattr_format(buf, sizeof(buf), md)); } memrange_efi_to_native(&paddr, &npages); size = npages << PAGE_SHIFT; if (is_memory(md)) { early_init_dt_add_memory_arch(paddr, size); if (!is_usable_memory(md)) memblock_mark_nomap(paddr, size); /* keep ACPI reclaim memory intact for kexec etc. */ if (md->type == EFI_ACPI_RECLAIM_MEMORY) memblock_reserve(paddr, size); } } } void __init efi_init(void) { struct efi_memory_map_data data; struct efi_fdt_params params; /* Grab UEFI information placed in FDT by stub */ if (!efi_get_fdt_params(¶ms)) return; efi_system_table = params.system_table; data.desc_version = params.desc_ver; data.desc_size = params.desc_size; data.size = params.mmap_size; data.phys_map = params.mmap; if (efi_memmap_init_early(&data) < 0) { /* * If we are booting via UEFI, the UEFI memory map is the only * description of memory we have, so there is little point in * proceeding if we cannot access it. */ panic("Unable to map EFI memory map.\n"); } WARN(efi.memmap.desc_version != 1, "Unexpected EFI_MEMORY_DESCRIPTOR version %ld", efi.memmap.desc_version); if (uefi_init() < 0) { efi_memmap_unmap(); return; } reserve_regions(); efi_esrt_init(); memblock_reserve(params.mmap & PAGE_MASK, PAGE_ALIGN(params.mmap_size + (params.mmap & ~PAGE_MASK))); init_screen_info(); /* ARM does not permit early mappings to persist across paging_init() */ if (IS_ENABLED(CONFIG_ARM)) efi_memmap_unmap(); } static bool efifb_overlaps_pci_range(const struct of_pci_range *range) { u64 fb_base = screen_info.lfb_base; if (screen_info.capabilities & VIDEO_CAPABILITY_64BIT_BASE) fb_base |= (u64)(unsigned long)screen_info.ext_lfb_base << 32; return fb_base >= range->cpu_addr && fb_base < (range->cpu_addr + range->size); } static struct device_node *find_pci_overlap_node(void) { struct device_node *np; for_each_node_by_type(np, "pci") { struct of_pci_range_parser parser; struct of_pci_range range; int err; err = of_pci_range_parser_init(&parser, np); if (err) { pr_warn("of_pci_range_parser_init() failed: %d\n", err); continue; } for_each_of_pci_range(&parser, &range) if (efifb_overlaps_pci_range(&range)) return np; } return NULL; } /* * If the efifb framebuffer is backed by a PCI graphics controller, we have * to ensure that this relation is expressed using a device link when * running in DT mode, or the probe order may be reversed, resulting in a * resource reservation conflict on the memory window that the efifb * framebuffer steals from the PCIe host bridge. */ static int efifb_add_links(const struct fwnode_handle *fwnode, struct device *dev) { struct device_node *sup_np; struct device *sup_dev; sup_np = find_pci_overlap_node(); /* * If there's no PCI graphics controller backing the efifb, we are * done here. */ if (!sup_np) return 0; sup_dev = get_dev_from_fwnode(&sup_np->fwnode); of_node_put(sup_np); /* * Return -ENODEV if the PCI graphics controller device hasn't been * registered yet. This ensures that efifb isn't allowed to probe * and this function is retried again when new devices are * registered. */ if (!sup_dev) return -ENODEV; /* * If this fails, retrying this function at a later point won't * change anything. So, don't return an error after this. */ if (!device_link_add(dev, sup_dev, 0)) dev_warn(dev, "device_link_add() failed\n"); put_device(sup_dev); return 0; } static const struct fwnode_operations efifb_fwnode_ops = { .add_links = efifb_add_links, }; static struct fwnode_handle efifb_fwnode = { .ops = &efifb_fwnode_ops, }; static int __init register_gop_device(void) { struct platform_device *pd; int err; if (screen_info.orig_video_isVGA != VIDEO_TYPE_EFI) return 0; pd = platform_device_alloc("efi-framebuffer", 0); if (!pd) return -ENOMEM; if (IS_ENABLED(CONFIG_PCI)) pd->dev.fwnode = &efifb_fwnode; err = platform_device_add_data(pd, &screen_info, sizeof(screen_info)); if (err) return err; return platform_device_add(pd); } subsys_initcall(register_gop_device);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
You can’t perform that action at this time.