Add basic boot, setup and reset routines for LoongArch. Now, LoongArch machines use UEFI-based firmware. The firmware passes configuration information to the kernel via ACPI and DMI/SMBIOS. Currently an existing interface between the kernel and the bootloader is implemented. Kernel gets 2 values from the bootloader, passed in registers a0 and a1; a0 is an "EFI boot flag" distinguishing UEFI and non-UEFI firmware, while a1 is a pointer to an FDT with systable, memmap, cmdline and initrd information. The standard UEFI boot protocol (EFISTUB) will be added later.
Unified · Split
| @@ -0,0 +1,18 @@ | ||
| 1 | +/* SPDX-License-Identifier: GPL-2.0 */ | |
| 2 | +/* | |
| 3 | + * LoongArch specific ACPICA environments and implementation | |
| 4 | + * | |
| 5 | + * Author: Jianmin Lv <lvjianmin@loongson.cn> | |
| 6 | + * Huacai Chen <chenhuacai@loongson.cn> | |
| 7 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 8 | + */ | |
| 9 | + | |
| 10 | +#ifndef _ASM_LOONGARCH_ACENV_H | |
| 11 | +#define _ASM_LOONGARCH_ACENV_H | |
| 12 | + | |
| 13 | +/* | |
| 14 | + * This header is required by ACPI core, but we have nothing to fill in | |
| 15 | + * right now. Will be updated later when needed. | |
| 16 | + */ | |
| 17 | + | |
| 18 | +#endif /* _ASM_LOONGARCH_ACENV_H */ | |
| @@ -0,0 +1,38 @@ | ||
| 1 | +/* SPDX-License-Identifier: GPL-2.0 */ | |
| 2 | +/* | |
| 3 | + * Author: Jianmin Lv <lvjianmin@loongson.cn> | |
| 4 | + * Huacai Chen <chenhuacai@loongson.cn> | |
| 5 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 6 | + */ | |
| 7 | + | |
| 8 | +#ifndef _ASM_LOONGARCH_ACPI_H | |
| 9 | +#define _ASM_LOONGARCH_ACPI_H | |
| 10 | + | |
| 11 | +#ifdef CONFIG_ACPI | |
| 12 | +extern int acpi_strict; | |
| 13 | +extern int acpi_disabled; | |
| 14 | +extern int acpi_pci_disabled; | |
| 15 | +extern int acpi_noirq; | |
| 16 | + | |
| 17 | +#define acpi_os_ioremap acpi_os_ioremap | |
| 18 | +void __init __iomem *acpi_os_ioremap(acpi_physical_address phys, acpi_size size); | |
| 19 | + | |
| 20 | +static inline void disable_acpi(void) | |
| 21 | +{ | |
| 22 | + acpi_disabled = 1; | |
| 23 | + acpi_pci_disabled = 1; | |
| 24 | + acpi_noirq = 1; | |
| 25 | +} | |
| 26 | + | |
| 27 | +static inline bool acpi_has_cpu_in_madt(void) | |
| 28 | +{ | |
| 29 | + return true; | |
| 30 | +} | |
| 31 | + | |
| 32 | +extern struct list_head acpi_wakeup_device_list; | |
| 33 | + | |
| 34 | +#endif /* !CONFIG_ACPI */ | |
| 35 | + | |
| 36 | +#define ACPI_TABLE_UPGRADE_MAX_PHYS ARCH_LOW_ADDRESS_LIMIT | |
| 37 | + | |
| 38 | +#endif /* _ASM_LOONGARCH_ACPI_H */ | |
| @@ -0,0 +1,41 @@ | ||
| 1 | +/* SPDX-License-Identifier: GPL-2.0 */ | |
| 2 | +/* | |
| 3 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 4 | + */ | |
| 5 | +#ifndef _ASM_BOOTINFO_H | |
| 6 | +#define _ASM_BOOTINFO_H | |
| 7 | + | |
| 8 | +#include <linux/types.h> | |
| 9 | +#include <asm/setup.h> | |
| 10 | + | |
| 11 | +const char *get_system_type(void); | |
| 12 | + | |
| 13 | +extern void init_environ(void); | |
| 14 | +extern void memblock_init(void); | |
| 15 | +extern void platform_init(void); | |
| 16 | + | |
| 17 | +struct loongson_board_info { | |
| 18 | + int bios_size; | |
| 19 | + const char *bios_vendor; | |
| 20 | + const char *bios_version; | |
| 21 | + const char *bios_release_date; | |
| 22 | + const char *board_name; | |
| 23 | + const char *board_vendor; | |
| 24 | +}; | |
| 25 | + | |
| 26 | +struct loongson_system_configuration { | |
| 27 | + int nr_cpus; | |
| 28 | + int nr_nodes; | |
| 29 | + int nr_io_pics; | |
| 30 | + int boot_cpu_id; | |
| 31 | + int cores_per_node; | |
| 32 | + int cores_per_package; | |
| 33 | + const char *cpuname; | |
| 34 | +}; | |
| 35 | + | |
| 36 | +extern u64 efi_system_table; | |
| 37 | +extern unsigned long fw_arg0, fw_arg1; | |
| 38 | +extern struct loongson_board_info b_info; | |
| 39 | +extern struct loongson_system_configuration loongson_sysconf; | |
| 40 | + | |
| 41 | +#endif /* _ASM_BOOTINFO_H */ | |
| @@ -0,0 +1,24 @@ | ||
| 1 | +/* SPDX-License-Identifier: GPL-2.0 */ | |
| 2 | +/* | |
| 3 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 4 | + */ | |
| 5 | +#ifndef _ASM_DMI_H | |
| 6 | +#define _ASM_DMI_H | |
| 7 | + | |
| 8 | +#include <linux/io.h> | |
| 9 | +#include <linux/memblock.h> | |
| 10 | + | |
| 11 | +#define dmi_early_remap(x, l) dmi_remap(x, l) | |
| 12 | +#define dmi_early_unmap(x, l) dmi_unmap(x) | |
| 13 | +#define dmi_alloc(l) memblock_alloc(l, PAGE_SIZE) | |
| 14 | + | |
| 15 | +static inline void *dmi_remap(u64 phys_addr, unsigned long size) | |
| 16 | +{ | |
| 17 | + return ((void *)TO_CACHE(phys_addr)); | |
| 18 | +} | |
| 19 | + | |
| 20 | +static inline void dmi_unmap(void *addr) | |
| 21 | +{ | |
| 22 | +} | |
| 23 | + | |
| 24 | +#endif /* _ASM_DMI_H */ | |
| @@ -0,0 +1,41 @@ | ||
| 1 | +/* SPDX-License-Identifier: GPL-2.0 */ | |
| 2 | +/* | |
| 3 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 4 | + */ | |
| 5 | +#ifndef _ASM_LOONGARCH_EFI_H | |
| 6 | +#define _ASM_LOONGARCH_EFI_H | |
| 7 | + | |
| 8 | +#include <linux/efi.h> | |
| 9 | + | |
| 10 | +void __init efi_init(void); | |
| 11 | +void __init efi_runtime_init(void); | |
| 12 | +void efifb_setup_from_dmi(struct screen_info *si, const char *opt); | |
| 13 | + | |
| 14 | +#define ARCH_EFI_IRQ_FLAGS_MASK 0x00000004 /* Bit 2: CSR.CRMD.IE */ | |
| 15 | + | |
| 16 | +#define arch_efi_call_virt_setup() \ | |
| 17 | +({ \ | |
| 18 | +}) | |
| 19 | + | |
| 20 | +#define arch_efi_call_virt(p, f, args...) \ | |
| 21 | +({ \ | |
| 22 | + efi_##f##_t * __f; \ | |
| 23 | + __f = p->f; \ | |
| 24 | + __f(args); \ | |
| 25 | +}) | |
| 26 | + | |
| 27 | +#define arch_efi_call_virt_teardown() \ | |
| 28 | +({ \ | |
| 29 | +}) | |
| 30 | + | |
| 31 | +#define EFI_ALLOC_ALIGN SZ_64K | |
| 32 | + | |
| 33 | +struct screen_info *alloc_screen_info(void); | |
| 34 | +void free_screen_info(struct screen_info *si); | |
| 35 | + | |
| 36 | +static inline unsigned long efi_get_max_initrd_addr(unsigned long image_addr) | |
| 37 | +{ | |
| 38 | + return ULONG_MAX; | |
| 39 | +} | |
| 40 | + | |
| 41 | +#endif /* _ASM_LOONGARCH_EFI_H */ | |
| @@ -0,0 +1,10 @@ | ||
| 1 | +/* SPDX-License-Identifier: GPL-2.0 */ | |
| 2 | +/* | |
| 3 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 4 | + */ | |
| 5 | +#ifndef _ASM_REBOOT_H | |
| 6 | +#define _ASM_REBOOT_H | |
| 7 | + | |
| 8 | +extern void (*pm_restart)(void); | |
| 9 | + | |
| 10 | +#endif /* _ASM_REBOOT_H */ | |
| @@ -0,0 +1,21 @@ | ||
| 1 | +/* SPDX-License-Identifier: GPL-2.0 */ | |
| 2 | +/* | |
| 3 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 4 | + */ | |
| 5 | + | |
| 6 | +#ifndef _LOONGARCH_SETUP_H | |
| 7 | +#define _LOONGARCH_SETUP_H | |
| 8 | + | |
| 9 | +#include <linux/types.h> | |
| 10 | +#include <uapi/asm/setup.h> | |
| 11 | + | |
| 12 | +#define VECSIZE 0x200 | |
| 13 | + | |
| 14 | +extern unsigned long eentry; | |
| 15 | +extern unsigned long tlbrentry; | |
| 16 | +extern void cpu_cache_init(void); | |
| 17 | +extern void per_cpu_trap_init(int cpu); | |
| 18 | +extern void set_handler(unsigned long offset, void *addr, unsigned long len); | |
| 19 | +extern void set_merr_handler(unsigned long offset, void *addr, unsigned long len); | |
| 20 | + | |
| 21 | +#endif /* __SETUP_H */ | |
| @@ -0,0 +1,169 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0 | |
| 2 | +/* | |
| 3 | + * acpi.c - Architecture-Specific Low-Level ACPI Boot Support | |
| 4 | + * | |
| 5 | + * Author: Jianmin Lv <lvjianmin@loongson.cn> | |
| 6 | + * Huacai Chen <chenhuacai@loongson.cn> | |
| 7 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 8 | + */ | |
| 9 | + | |
| 10 | +#include <linux/init.h> | |
| 11 | +#include <linux/acpi.h> | |
| 12 | +#include <linux/irq.h> | |
| 13 | +#include <linux/irqdomain.h> | |
| 14 | +#include <linux/memblock.h> | |
| 15 | +#include <linux/serial_core.h> | |
| 16 | +#include <asm/io.h> | |
| 17 | +#include <asm/loongson.h> | |
| 18 | + | |
| 19 | +int acpi_disabled; | |
| 20 | +EXPORT_SYMBOL(acpi_disabled); | |
| 21 | +int acpi_noirq; | |
| 22 | +int acpi_pci_disabled; | |
| 23 | +EXPORT_SYMBOL(acpi_pci_disabled); | |
| 24 | +int acpi_strict = 1; /* We have no workarounds on LoongArch */ | |
| 25 | +int num_processors; | |
| 26 | +int disabled_cpus; | |
| 27 | +enum acpi_irq_model_id acpi_irq_model = ACPI_IRQ_MODEL_PLATFORM; | |
| 28 | + | |
| 29 | +u64 acpi_saved_sp; | |
| 30 | + | |
| 31 | +#define MAX_CORE_PIC 256 | |
| 32 | + | |
| 33 | +#define PREFIX "ACPI: " | |
| 34 | + | |
| 35 | +int acpi_gsi_to_irq(u32 gsi, unsigned int *irqp) | |
| 36 | +{ | |
| 37 | + if (irqp != NULL) | |
| 38 | + *irqp = acpi_register_gsi(NULL, gsi, -1, -1); | |
| 39 | + return (*irqp >= 0) ? 0 : -EINVAL; | |
| 40 | +} | |
| 41 | +EXPORT_SYMBOL_GPL(acpi_gsi_to_irq); | |
| 42 | + | |
| 43 | +int acpi_isa_irq_to_gsi(unsigned int isa_irq, u32 *gsi) | |
| 44 | +{ | |
| 45 | + if (gsi) | |
| 46 | + *gsi = isa_irq; | |
| 47 | + return 0; | |
| 48 | +} | |
| 49 | + | |
| 50 | +/* | |
| 51 | + * success: return IRQ number (>=0) | |
| 52 | + * failure: return < 0 | |
| 53 | + */ | |
| 54 | +int acpi_register_gsi(struct device *dev, u32 gsi, int trigger, int polarity) | |
| 55 | +{ | |
| 56 | + struct irq_fwspec fwspec; | |
| 57 | + | |
| 58 | + switch (gsi) { | |
| 59 | + case GSI_MIN_CPU_IRQ ... GSI_MAX_CPU_IRQ: | |
| 60 | + fwspec.fwnode = liointc_domain->fwnode; | |
| 61 | + fwspec.param[0] = gsi - GSI_MIN_CPU_IRQ; | |
| 62 | + fwspec.param_count = 1; | |
| 63 | + | |
| 64 | + return irq_create_fwspec_mapping(&fwspec); | |
| 65 | + | |
| 66 | + case GSI_MIN_LPC_IRQ ... GSI_MAX_LPC_IRQ: | |
| 67 | + if (!pch_lpc_domain) | |
| 68 | + return -EINVAL; | |
| 69 | + | |
| 70 | + fwspec.fwnode = pch_lpc_domain->fwnode; | |
| 71 | + fwspec.param[0] = gsi - GSI_MIN_LPC_IRQ; | |
| 72 | + fwspec.param[1] = acpi_dev_get_irq_type(trigger, polarity); | |
| 73 | + fwspec.param_count = 2; | |
| 74 | + | |
| 75 | + return irq_create_fwspec_mapping(&fwspec); | |
| 76 | + | |
| 77 | + case GSI_MIN_PCH_IRQ ... GSI_MAX_PCH_IRQ: | |
| 78 | + if (!pch_pic_domain[0]) | |
| 79 | + return -EINVAL; | |
| 80 | + | |
| 81 | + fwspec.fwnode = pch_pic_domain[0]->fwnode; | |
| 82 | + fwspec.param[0] = gsi - GSI_MIN_PCH_IRQ; | |
| 83 | + fwspec.param[1] = IRQ_TYPE_LEVEL_HIGH; | |
| 84 | + fwspec.param_count = 2; | |
| 85 | + | |
| 86 | + return irq_create_fwspec_mapping(&fwspec); | |
| 87 | + } | |
| 88 | + | |
| 89 | + return -EINVAL; | |
| 90 | +} | |
| 91 | +EXPORT_SYMBOL_GPL(acpi_register_gsi); | |
| 92 | + | |
| 93 | +void acpi_unregister_gsi(u32 gsi) | |
| 94 | +{ | |
| 95 | + | |
| 96 | +} | |
| 97 | +EXPORT_SYMBOL_GPL(acpi_unregister_gsi); | |
| 98 | + | |
| 99 | +void __init __iomem * __acpi_map_table(unsigned long phys, unsigned long size) | |
| 100 | +{ | |
| 101 | + | |
| 102 | + if (!phys || !size) | |
| 103 | + return NULL; | |
| 104 | + | |
| 105 | + return early_memremap(phys, size); | |
| 106 | +} | |
| 107 | +void __init __acpi_unmap_table(void __iomem *map, unsigned long size) | |
| 108 | +{ | |
| 109 | + if (!map || !size) | |
| 110 | + return; | |
| 111 | + | |
| 112 | + early_memunmap(map, size); | |
| 113 | +} | |
| 114 | + | |
| 115 | +void __init __iomem *acpi_os_ioremap(acpi_physical_address phys, acpi_size size) | |
| 116 | +{ | |
| 117 | + if (!memblock_is_memory(phys)) | |
| 118 | + return ioremap(phys, size); | |
| 119 | + else | |
| 120 | + return ioremap_cache(phys, size); | |
| 121 | +} | |
| 122 | + | |
| 123 | +void __init acpi_boot_table_init(void) | |
| 124 | +{ | |
| 125 | + /* | |
| 126 | + * If acpi_disabled, bail out | |
| 127 | + */ | |
| 128 | + if (acpi_disabled) | |
| 129 | + return; | |
| 130 | + | |
| 131 | + /* | |
| 132 | + * Initialize the ACPI boot-time table parser. | |
| 133 | + */ | |
| 134 | + if (acpi_table_init()) { | |
| 135 | + disable_acpi(); | |
| 136 | + return; | |
| 137 | + } | |
| 138 | +} | |
| 139 | + | |
| 140 | +static void __init acpi_process_madt(void) | |
| 141 | +{ | |
| 142 | + loongson_sysconf.nr_cpus = num_processors; | |
| 143 | +} | |
| 144 | + | |
| 145 | +int __init acpi_boot_init(void) | |
| 146 | +{ | |
| 147 | + /* | |
| 148 | + * If acpi_disabled, bail out | |
| 149 | + */ | |
| 150 | + if (acpi_disabled) | |
| 151 | + return -1; | |
| 152 | + | |
| 153 | + loongson_sysconf.boot_cpu_id = read_csr_cpuid(); | |
| 154 | + | |
| 155 | + /* | |
| 156 | + * Process the Multiple APIC Description Table (MADT), if present | |
| 157 | + */ | |
| 158 | + acpi_process_madt(); | |
| 159 | + | |
| 160 | + /* Do not enable ACPI SPCR console by default */ | |
| 161 | + acpi_parse_spcr(earlycon_acpi_spcr_enable, false); | |
| 162 | + | |
| 163 | + return 0; | |
| 164 | +} | |
| 165 | + | |
| 166 | +void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size) | |
| 167 | +{ | |
| 168 | + memblock_reserve(addr, size); | |
| 169 | +} | |
| @@ -0,0 +1,122 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0-only | |
| 2 | +/* | |
| 3 | + * LoongArch cacheinfo support | |
| 4 | + * | |
| 5 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 6 | + */ | |
| 7 | +#include <linux/cacheinfo.h> | |
| 8 | + | |
| 9 | +/* Populates leaf and increments to next leaf */ | |
| 10 | +#define populate_cache(cache, leaf, c_level, c_type) \ | |
| 11 | +do { \ | |
| 12 | + leaf->type = c_type; \ | |
| 13 | + leaf->level = c_level; \ | |
| 14 | + leaf->coherency_line_size = c->cache.linesz; \ | |
| 15 | + leaf->number_of_sets = c->cache.sets; \ | |
| 16 | + leaf->ways_of_associativity = c->cache.ways; \ | |
| 17 | + leaf->size = c->cache.linesz * c->cache.sets * \ | |
| 18 | + c->cache.ways; \ | |
| 19 | + leaf++; \ | |
| 20 | +} while (0) | |
| 21 | + | |
| 22 | +int init_cache_level(unsigned int cpu) | |
| 23 | +{ | |
| 24 | + struct cpuinfo_loongarch *c = ¤t_cpu_data; | |
| 25 | + struct cpu_cacheinfo *this_cpu_ci = get_cpu_cacheinfo(cpu); | |
| 26 | + int levels = 0, leaves = 0; | |
| 27 | + | |
| 28 | + /* | |
| 29 | + * If Dcache is not set, we assume the cache structures | |
| 30 | + * are not properly initialized. | |
| 31 | + */ | |
| 32 | + if (c->dcache.waysize) | |
| 33 | + levels += 1; | |
| 34 | + else | |
| 35 | + return -ENOENT; | |
| 36 | + | |
| 37 | + | |
| 38 | + leaves += (c->icache.waysize) ? 2 : 1; | |
| 39 | + | |
| 40 | + if (c->vcache.waysize) { | |
| 41 | + levels++; | |
| 42 | + leaves++; | |
| 43 | + } | |
| 44 | + | |
| 45 | + if (c->scache.waysize) { | |
| 46 | + levels++; | |
| 47 | + leaves++; | |
| 48 | + } | |
| 49 | + | |
| 50 | + if (c->tcache.waysize) { | |
| 51 | + levels++; | |
| 52 | + leaves++; | |
| 53 | + } | |
| 54 | + | |
| 55 | + this_cpu_ci->num_levels = levels; | |
| 56 | + this_cpu_ci->num_leaves = leaves; | |
| 57 | + return 0; | |
| 58 | +} | |
| 59 | + | |
| 60 | +static inline bool cache_leaves_are_shared(struct cacheinfo *this_leaf, | |
| 61 | + struct cacheinfo *sib_leaf) | |
| 62 | +{ | |
| 63 | + return !((this_leaf->level == 1) || (this_leaf->level == 2)); | |
| 64 | +} | |
| 65 | + | |
| 66 | +static void cache_cpumap_setup(unsigned int cpu) | |
| 67 | +{ | |
| 68 | + struct cpu_cacheinfo *this_cpu_ci = get_cpu_cacheinfo(cpu); | |
| 69 | + struct cacheinfo *this_leaf, *sib_leaf; | |
| 70 | + unsigned int index; | |
| 71 | + | |
| 72 | + for (index = 0; index < this_cpu_ci->num_leaves; index++) { | |
| 73 | + unsigned int i; | |
| 74 | + | |
| 75 | + this_leaf = this_cpu_ci->info_list + index; | |
| 76 | + /* skip if shared_cpu_map is already populated */ | |
| 77 | + if (!cpumask_empty(&this_leaf->shared_cpu_map)) | |
| 78 | + continue; | |
| 79 | + | |
| 80 | + cpumask_set_cpu(cpu, &this_leaf->shared_cpu_map); | |
| 81 | + for_each_online_cpu(i) { | |
| 82 | + struct cpu_cacheinfo *sib_cpu_ci = get_cpu_cacheinfo(i); | |
| 83 | + | |
| 84 | + if (i == cpu || !sib_cpu_ci->info_list) | |
| 85 | + continue;/* skip if itself or no cacheinfo */ | |
| 86 | + sib_leaf = sib_cpu_ci->info_list + index; | |
| 87 | + if (cache_leaves_are_shared(this_leaf, sib_leaf)) { | |
| 88 | + cpumask_set_cpu(cpu, &sib_leaf->shared_cpu_map); | |
| 89 | + cpumask_set_cpu(i, &this_leaf->shared_cpu_map); | |
| 90 | + } | |
| 91 | + } | |
| 92 | + } | |
| 93 | +} | |
| 94 | + | |
| 95 | +int populate_cache_leaves(unsigned int cpu) | |
| 96 | +{ | |
| 97 | + int level = 1; | |
| 98 | + struct cpuinfo_loongarch *c = ¤t_cpu_data; | |
| 99 | + struct cpu_cacheinfo *this_cpu_ci = get_cpu_cacheinfo(cpu); | |
| 100 | + struct cacheinfo *this_leaf = this_cpu_ci->info_list; | |
| 101 | + | |
| 102 | + if (c->icache.waysize) { | |
| 103 | + populate_cache(dcache, this_leaf, level, CACHE_TYPE_DATA); | |
| 104 | + populate_cache(icache, this_leaf, level++, CACHE_TYPE_INST); | |
| 105 | + } else { | |
| 106 | + populate_cache(dcache, this_leaf, level++, CACHE_TYPE_UNIFIED); | |
| 107 | + } | |
| 108 | + | |
| 109 | + if (c->vcache.waysize) | |
| 110 | + populate_cache(vcache, this_leaf, level++, CACHE_TYPE_UNIFIED); | |
| 111 | + | |
| 112 | + if (c->scache.waysize) | |
| 113 | + populate_cache(scache, this_leaf, level++, CACHE_TYPE_UNIFIED); | |
| 114 | + | |
| 115 | + if (c->tcache.waysize) | |
| 116 | + populate_cache(tcache, this_leaf, level++, CACHE_TYPE_UNIFIED); | |
| 117 | + | |
| 118 | + cache_cpumap_setup(cpu); | |
| 119 | + this_cpu_ci->cpu_map_populated = true; | |
| 120 | + | |
| 121 | + return 0; | |
| 122 | +} | |
| @@ -0,0 +1,292 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0 | |
| 2 | +/* | |
| 3 | + * Processor capabilities determination functions. | |
| 4 | + * | |
| 5 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 6 | + */ | |
| 7 | +#include <linux/init.h> | |
| 8 | +#include <linux/kernel.h> | |
| 9 | +#include <linux/ptrace.h> | |
| 10 | +#include <linux/smp.h> | |
| 11 | +#include <linux/stddef.h> | |
| 12 | +#include <linux/export.h> | |
| 13 | +#include <linux/printk.h> | |
| 14 | +#include <linux/uaccess.h> | |
| 15 | + | |
| 16 | +#include <asm/cpu-features.h> | |
| 17 | +#include <asm/elf.h> | |
| 18 | +#include <asm/fpu.h> | |
| 19 | +#include <asm/loongarch.h> | |
| 20 | +#include <asm/pgtable-bits.h> | |
| 21 | +#include <asm/setup.h> | |
| 22 | + | |
| 23 | +/* Hardware capabilities */ | |
| 24 | +unsigned int elf_hwcap __read_mostly; | |
| 25 | +EXPORT_SYMBOL_GPL(elf_hwcap); | |
| 26 | + | |
| 27 | +/* | |
| 28 | + * Determine the FCSR mask for FPU hardware. | |
| 29 | + */ | |
| 30 | +static inline void cpu_set_fpu_fcsr_mask(struct cpuinfo_loongarch *c) | |
| 31 | +{ | |
| 32 | + unsigned long sr, mask, fcsr, fcsr0, fcsr1; | |
| 33 | + | |
| 34 | + fcsr = c->fpu_csr0; | |
| 35 | + mask = FPU_CSR_ALL_X | FPU_CSR_ALL_E | FPU_CSR_ALL_S | FPU_CSR_RM; | |
| 36 | + | |
| 37 | + sr = read_csr_euen(); | |
| 38 | + enable_fpu(); | |
| 39 | + | |
| 40 | + fcsr0 = fcsr & mask; | |
| 41 | + write_fcsr(LOONGARCH_FCSR0, fcsr0); | |
| 42 | + fcsr0 = read_fcsr(LOONGARCH_FCSR0); | |
| 43 | + | |
| 44 | + fcsr1 = fcsr | ~mask; | |
| 45 | + write_fcsr(LOONGARCH_FCSR0, fcsr1); | |
| 46 | + fcsr1 = read_fcsr(LOONGARCH_FCSR0); | |
| 47 | + | |
| 48 | + write_fcsr(LOONGARCH_FCSR0, fcsr); | |
| 49 | + | |
| 50 | + write_csr_euen(sr); | |
| 51 | + | |
| 52 | + c->fpu_mask = ~(fcsr0 ^ fcsr1) & ~mask; | |
| 53 | +} | |
| 54 | + | |
| 55 | +static inline void set_elf_platform(int cpu, const char *plat) | |
| 56 | +{ | |
| 57 | + if (cpu == 0) | |
| 58 | + __elf_platform = plat; | |
| 59 | +} | |
| 60 | + | |
| 61 | +/* MAP BASE */ | |
| 62 | +unsigned long vm_map_base; | |
| 63 | +EXPORT_SYMBOL_GPL(vm_map_base); | |
| 64 | + | |
| 65 | +static void cpu_probe_addrbits(struct cpuinfo_loongarch *c) | |
| 66 | +{ | |
| 67 | +#ifdef __NEED_ADDRBITS_PROBE | |
| 68 | + c->pabits = (read_cpucfg(LOONGARCH_CPUCFG1) & CPUCFG1_PABITS) >> 4; | |
| 69 | + c->vabits = (read_cpucfg(LOONGARCH_CPUCFG1) & CPUCFG1_VABITS) >> 12; | |
| 70 | + vm_map_base = 0UL - (1UL << c->vabits); | |
| 71 | +#endif | |
| 72 | +} | |
| 73 | + | |
| 74 | +static void set_isa(struct cpuinfo_loongarch *c, unsigned int isa) | |
| 75 | +{ | |
| 76 | + switch (isa) { | |
| 77 | + case LOONGARCH_CPU_ISA_LA64: | |
| 78 | + c->isa_level |= LOONGARCH_CPU_ISA_LA64; | |
| 79 | + fallthrough; | |
| 80 | + case LOONGARCH_CPU_ISA_LA32S: | |
| 81 | + c->isa_level |= LOONGARCH_CPU_ISA_LA32S; | |
| 82 | + fallthrough; | |
| 83 | + case LOONGARCH_CPU_ISA_LA32R: | |
| 84 | + c->isa_level |= LOONGARCH_CPU_ISA_LA32R; | |
| 85 | + break; | |
| 86 | + } | |
| 87 | +} | |
| 88 | + | |
| 89 | +static void cpu_probe_common(struct cpuinfo_loongarch *c) | |
| 90 | +{ | |
| 91 | + unsigned int config; | |
| 92 | + unsigned long asid_mask; | |
| 93 | + | |
| 94 | + c->options = LOONGARCH_CPU_CPUCFG | LOONGARCH_CPU_CSR | | |
| 95 | + LOONGARCH_CPU_TLB | LOONGARCH_CPU_VINT | LOONGARCH_CPU_WATCH; | |
| 96 | + | |
| 97 | + elf_hwcap |= HWCAP_LOONGARCH_CRC32; | |
| 98 | + | |
| 99 | + config = read_cpucfg(LOONGARCH_CPUCFG1); | |
| 100 | + if (config & CPUCFG1_UAL) { | |
| 101 | + c->options |= LOONGARCH_CPU_UAL; | |
| 102 | + elf_hwcap |= HWCAP_LOONGARCH_UAL; | |
| 103 | + } | |
| 104 | + | |
| 105 | + config = read_cpucfg(LOONGARCH_CPUCFG2); | |
| 106 | + if (config & CPUCFG2_LAM) { | |
| 107 | + c->options |= LOONGARCH_CPU_LAM; | |
| 108 | + elf_hwcap |= HWCAP_LOONGARCH_LAM; | |
| 109 | + } | |
| 110 | + if (config & CPUCFG2_FP) { | |
| 111 | + c->options |= LOONGARCH_CPU_FPU; | |
| 112 | + elf_hwcap |= HWCAP_LOONGARCH_FPU; | |
| 113 | + } | |
| 114 | + if (config & CPUCFG2_COMPLEX) { | |
| 115 | + c->options |= LOONGARCH_CPU_COMPLEX; | |
| 116 | + elf_hwcap |= HWCAP_LOONGARCH_COMPLEX; | |
| 117 | + } | |
| 118 | + if (config & CPUCFG2_CRYPTO) { | |
| 119 | + c->options |= LOONGARCH_CPU_CRYPTO; | |
| 120 | + elf_hwcap |= HWCAP_LOONGARCH_CRYPTO; | |
| 121 | + } | |
| 122 | + if (config & CPUCFG2_LVZP) { | |
| 123 | + c->options |= LOONGARCH_CPU_LVZ; | |
| 124 | + elf_hwcap |= HWCAP_LOONGARCH_LVZ; | |
| 125 | + } | |
| 126 | + | |
| 127 | + config = read_cpucfg(LOONGARCH_CPUCFG6); | |
| 128 | + if (config & CPUCFG6_PMP) | |
| 129 | + c->options |= LOONGARCH_CPU_PMP; | |
| 130 | + | |
| 131 | + config = iocsr_read32(LOONGARCH_IOCSR_FEATURES); | |
| 132 | + if (config & IOCSRF_CSRIPI) | |
| 133 | + c->options |= LOONGARCH_CPU_CSRIPI; | |
| 134 | + if (config & IOCSRF_EXTIOI) | |
| 135 | + c->options |= LOONGARCH_CPU_EXTIOI; | |
| 136 | + if (config & IOCSRF_FREQSCALE) | |
| 137 | + c->options |= LOONGARCH_CPU_SCALEFREQ; | |
| 138 | + if (config & IOCSRF_FLATMODE) | |
| 139 | + c->options |= LOONGARCH_CPU_FLATMODE; | |
| 140 | + if (config & IOCSRF_EIODECODE) | |
| 141 | + c->options |= LOONGARCH_CPU_EIODECODE; | |
| 142 | + if (config & IOCSRF_VM) | |
| 143 | + c->options |= LOONGARCH_CPU_HYPERVISOR; | |
| 144 | + | |
| 145 | + config = csr_read32(LOONGARCH_CSR_ASID); | |
| 146 | + config = (config & CSR_ASID_BIT) >> CSR_ASID_BIT_SHIFT; | |
| 147 | + asid_mask = GENMASK(config - 1, 0); | |
| 148 | + set_cpu_asid_mask(c, asid_mask); | |
| 149 | + | |
| 150 | + config = read_csr_prcfg1(); | |
| 151 | + c->ksave_mask = GENMASK((config & CSR_CONF1_KSNUM) - 1, 0); | |
| 152 | + c->ksave_mask &= ~(EXC_KSAVE_MASK | PERCPU_KSAVE_MASK | KVM_KSAVE_MASK); | |
| 153 | + | |
| 154 | + config = read_csr_prcfg3(); | |
| 155 | + switch (config & CSR_CONF3_TLBTYPE) { | |
| 156 | + case 0: | |
| 157 | + c->tlbsizemtlb = 0; | |
| 158 | + c->tlbsizestlbsets = 0; | |
| 159 | + c->tlbsizestlbways = 0; | |
| 160 | + c->tlbsize = 0; | |
| 161 | + break; | |
| 162 | + case 1: | |
| 163 | + c->tlbsizemtlb = ((config & CSR_CONF3_MTLBSIZE) >> CSR_CONF3_MTLBSIZE_SHIFT) + 1; | |
| 164 | + c->tlbsizestlbsets = 0; | |
| 165 | + c->tlbsizestlbways = 0; | |
| 166 | + c->tlbsize = c->tlbsizemtlb + c->tlbsizestlbsets * c->tlbsizestlbways; | |
| 167 | + break; | |
| 168 | + case 2: | |
| 169 | + c->tlbsizemtlb = ((config & CSR_CONF3_MTLBSIZE) >> CSR_CONF3_MTLBSIZE_SHIFT) + 1; | |
| 170 | + c->tlbsizestlbsets = 1 << ((config & CSR_CONF3_STLBIDX) >> CSR_CONF3_STLBIDX_SHIFT); | |
| 171 | + c->tlbsizestlbways = ((config & CSR_CONF3_STLBWAYS) >> CSR_CONF3_STLBWAYS_SHIFT) + 1; | |
| 172 | + c->tlbsize = c->tlbsizemtlb + c->tlbsizestlbsets * c->tlbsizestlbways; | |
| 173 | + break; | |
| 174 | + default: | |
| 175 | + pr_warn("Warning: unknown TLB type\n"); | |
| 176 | + } | |
| 177 | +} | |
| 178 | + | |
| 179 | +#define MAX_NAME_LEN 32 | |
| 180 | +#define VENDOR_OFFSET 0 | |
| 181 | +#define CPUNAME_OFFSET 9 | |
| 182 | + | |
| 183 | +static char cpu_full_name[MAX_NAME_LEN] = " - "; | |
| 184 | + | |
| 185 | +static inline void cpu_probe_loongson(struct cpuinfo_loongarch *c, unsigned int cpu) | |
| 186 | +{ | |
| 187 | + uint64_t *vendor = (void *)(&cpu_full_name[VENDOR_OFFSET]); | |
| 188 | + uint64_t *cpuname = (void *)(&cpu_full_name[CPUNAME_OFFSET]); | |
| 189 | + | |
| 190 | + __cpu_full_name[cpu] = cpu_full_name; | |
| 191 | + *vendor = iocsr_read64(LOONGARCH_IOCSR_VENDOR); | |
| 192 | + *cpuname = iocsr_read64(LOONGARCH_IOCSR_CPUNAME); | |
| 193 | + | |
| 194 | + switch (c->processor_id & PRID_SERIES_MASK) { | |
| 195 | + case PRID_SERIES_LA132: | |
| 196 | + c->cputype = CPU_LOONGSON32; | |
| 197 | + set_isa(c, LOONGARCH_CPU_ISA_LA32S); | |
| 198 | + __cpu_family[cpu] = "Loongson-32bit"; | |
| 199 | + pr_info("32-bit Loongson Processor probed (LA132 Core)\n"); | |
| 200 | + break; | |
| 201 | + case PRID_SERIES_LA264: | |
| 202 | + c->cputype = CPU_LOONGSON64; | |
| 203 | + set_isa(c, LOONGARCH_CPU_ISA_LA64); | |
| 204 | + __cpu_family[cpu] = "Loongson-64bit"; | |
| 205 | + pr_info("64-bit Loongson Processor probed (LA264 Core)\n"); | |
| 206 | + break; | |
| 207 | + case PRID_SERIES_LA364: | |
| 208 | + c->cputype = CPU_LOONGSON64; | |
| 209 | + set_isa(c, LOONGARCH_CPU_ISA_LA64); | |
| 210 | + __cpu_family[cpu] = "Loongson-64bit"; | |
| 211 | + pr_info("64-bit Loongson Processor probed (LA364 Core)\n"); | |
| 212 | + break; | |
| 213 | + case PRID_SERIES_LA464: | |
| 214 | + c->cputype = CPU_LOONGSON64; | |
| 215 | + set_isa(c, LOONGARCH_CPU_ISA_LA64); | |
| 216 | + __cpu_family[cpu] = "Loongson-64bit"; | |
| 217 | + pr_info("64-bit Loongson Processor probed (LA464 Core)\n"); | |
| 218 | + break; | |
| 219 | + case PRID_SERIES_LA664: | |
| 220 | + c->cputype = CPU_LOONGSON64; | |
| 221 | + set_isa(c, LOONGARCH_CPU_ISA_LA64); | |
| 222 | + __cpu_family[cpu] = "Loongson-64bit"; | |
| 223 | + pr_info("64-bit Loongson Processor probed (LA664 Core)\n"); | |
| 224 | + break; | |
| 225 | + default: /* Default to 64 bit */ | |
| 226 | + c->cputype = CPU_LOONGSON64; | |
| 227 | + set_isa(c, LOONGARCH_CPU_ISA_LA64); | |
| 228 | + __cpu_family[cpu] = "Loongson-64bit"; | |
| 229 | + pr_info("64-bit Loongson Processor probed (Unknown Core)\n"); | |
| 230 | + } | |
| 231 | +} | |
| 232 | + | |
| 233 | +#ifdef CONFIG_64BIT | |
| 234 | +/* For use by uaccess.h */ | |
| 235 | +u64 __ua_limit; | |
| 236 | +EXPORT_SYMBOL(__ua_limit); | |
| 237 | +#endif | |
| 238 | + | |
| 239 | +const char *__cpu_family[NR_CPUS]; | |
| 240 | +const char *__cpu_full_name[NR_CPUS]; | |
| 241 | +const char *__elf_platform; | |
| 242 | + | |
| 243 | +static void cpu_report(void) | |
| 244 | +{ | |
| 245 | + struct cpuinfo_loongarch *c = ¤t_cpu_data; | |
| 246 | + | |
| 247 | + pr_info("CPU%d revision is: %08x (%s)\n", | |
| 248 | + smp_processor_id(), c->processor_id, cpu_family_string()); | |
| 249 | + if (c->options & LOONGARCH_CPU_FPU) | |
| 250 | + pr_info("FPU%d revision is: %08x\n", smp_processor_id(), c->fpu_vers); | |
| 251 | +} | |
| 252 | + | |
| 253 | +void cpu_probe(void) | |
| 254 | +{ | |
| 255 | + unsigned int cpu = smp_processor_id(); | |
| 256 | + struct cpuinfo_loongarch *c = ¤t_cpu_data; | |
| 257 | + | |
| 258 | + /* | |
| 259 | + * Set a default ELF platform, cpu probe may later | |
| 260 | + * overwrite it with a more precise value | |
| 261 | + */ | |
| 262 | + set_elf_platform(cpu, "loongarch"); | |
| 263 | + | |
| 264 | + c->cputype = CPU_UNKNOWN; | |
| 265 | + c->processor_id = read_cpucfg(LOONGARCH_CPUCFG0); | |
| 266 | + c->fpu_vers = (read_cpucfg(LOONGARCH_CPUCFG2) >> 3) & 0x3; | |
| 267 | + | |
| 268 | + c->fpu_csr0 = FPU_CSR_RN; | |
| 269 | + c->fpu_mask = FPU_CSR_RSVD; | |
| 270 | + | |
| 271 | + cpu_probe_common(c); | |
| 272 | + | |
| 273 | + per_cpu_trap_init(cpu); | |
| 274 | + | |
| 275 | + switch (c->processor_id & PRID_COMP_MASK) { | |
| 276 | + case PRID_COMP_LOONGSON: | |
| 277 | + cpu_probe_loongson(c, cpu); | |
| 278 | + break; | |
| 279 | + } | |
| 280 | + | |
| 281 | + BUG_ON(!__cpu_family[cpu]); | |
| 282 | + BUG_ON(c->cputype == CPU_UNKNOWN); | |
| 283 | + | |
| 284 | + cpu_probe_addrbits(c); | |
| 285 | + | |
| 286 | +#ifdef CONFIG_64BIT | |
| 287 | + if (cpu == 0) | |
| 288 | + __ua_limit = ~((1ull << cpu_vabits) - 1); | |
| 289 | +#endif | |
| 290 | + | |
| 291 | + cpu_report(); | |
| 292 | +} | |
| @@ -0,0 +1,72 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0 | |
| 2 | +/* | |
| 3 | + * EFI initialization | |
| 4 | + * | |
| 5 | + * Author: Jianmin Lv <lvjianmin@loongson.cn> | |
| 6 | + * Huacai Chen <chenhuacai@loongson.cn> | |
| 7 | + * | |
| 8 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 9 | + */ | |
| 10 | + | |
| 11 | +#include <linux/acpi.h> | |
| 12 | +#include <linux/efi.h> | |
| 13 | +#include <linux/efi-bgrt.h> | |
| 14 | +#include <linux/init.h> | |
| 15 | +#include <linux/kernel.h> | |
| 16 | +#include <linux/export.h> | |
| 17 | +#include <linux/io.h> | |
| 18 | +#include <linux/kobject.h> | |
| 19 | +#include <linux/memblock.h> | |
| 20 | +#include <linux/reboot.h> | |
| 21 | +#include <linux/uaccess.h> | |
| 22 | + | |
| 23 | +#include <asm/early_ioremap.h> | |
| 24 | +#include <asm/efi.h> | |
| 25 | +#include <asm/loongson.h> | |
| 26 | + | |
| 27 | +static unsigned long efi_nr_tables; | |
| 28 | +static unsigned long efi_config_table; | |
| 29 | + | |
| 30 | +static efi_system_table_t *efi_systab; | |
| 31 | +static efi_config_table_type_t arch_tables[] __initdata = {{},}; | |
| 32 | + | |
| 33 | +void __init efi_runtime_init(void) | |
| 34 | +{ | |
| 35 | + if (!efi_enabled(EFI_BOOT)) | |
| 36 | + return; | |
| 37 | + | |
| 38 | + if (efi_runtime_disabled()) { | |
| 39 | + pr_info("EFI runtime services will be disabled.\n"); | |
| 40 | + return; | |
| 41 | + } | |
| 42 | + | |
| 43 | + efi.runtime = (efi_runtime_services_t *)efi_systab->runtime; | |
| 44 | + efi.runtime_version = (unsigned int)efi.runtime->hdr.revision; | |
| 45 | + | |
| 46 | + efi_native_runtime_setup(); | |
| 47 | + set_bit(EFI_RUNTIME_SERVICES, &efi.flags); | |
| 48 | +} | |
| 49 | + | |
| 50 | +void __init efi_init(void) | |
| 51 | +{ | |
| 52 | + int size; | |
| 53 | + void *config_tables; | |
| 54 | + | |
| 55 | + if (!efi_system_table) | |
| 56 | + return; | |
| 57 | + | |
| 58 | + efi_systab = (efi_system_table_t *)early_memremap_ro(efi_system_table, sizeof(*efi_systab)); | |
| 59 | + if (!efi_systab) { | |
| 60 | + pr_err("Can't find EFI system table.\n"); | |
| 61 | + return; | |
| 62 | + } | |
| 63 | + | |
| 64 | + set_bit(EFI_64BIT, &efi.flags); | |
| 65 | + efi_nr_tables = efi_systab->nr_tables; | |
| 66 | + efi_config_table = (unsigned long)efi_systab->tables; | |
| 67 | + | |
| 68 | + size = sizeof(efi_config_table_t); | |
| 69 | + config_tables = early_memremap(efi_config_table, efi_nr_tables * size); | |
| 70 | + efi_config_parse_tables(config_tables, efi_systab->nr_tables, arch_tables); | |
| 71 | + early_memunmap(config_tables, efi_nr_tables * size); | |
| 72 | +} | |
| @@ -0,0 +1,101 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0 | |
| 2 | +/* | |
| 3 | + * Author: Huacai Chen <chenhuacai@loongson.cn> | |
| 4 | + * | |
| 5 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 6 | + */ | |
| 7 | +#include <linux/acpi.h> | |
| 8 | +#include <linux/efi.h> | |
| 9 | +#include <linux/export.h> | |
| 10 | +#include <linux/memblock.h> | |
| 11 | +#include <linux/of_fdt.h> | |
| 12 | +#include <asm/early_ioremap.h> | |
| 13 | +#include <asm/bootinfo.h> | |
| 14 | +#include <asm/loongson.h> | |
| 15 | + | |
| 16 | +u64 efi_system_table; | |
| 17 | +struct loongson_system_configuration loongson_sysconf; | |
| 18 | +EXPORT_SYMBOL(loongson_sysconf); | |
| 19 | + | |
| 20 | +u64 loongson_chipcfg[MAX_PACKAGES]; | |
| 21 | +u64 loongson_chiptemp[MAX_PACKAGES]; | |
| 22 | +u64 loongson_freqctrl[MAX_PACKAGES]; | |
| 23 | +unsigned long long smp_group[MAX_PACKAGES]; | |
| 24 | + | |
| 25 | +static void __init register_addrs_set(u64 *registers, const u64 addr, int num) | |
| 26 | +{ | |
| 27 | + u64 i; | |
| 28 | + | |
| 29 | + for (i = 0; i < num; i++) { | |
| 30 | + *registers = (i << 44) | addr; | |
| 31 | + registers++; | |
| 32 | + } | |
| 33 | +} | |
| 34 | + | |
| 35 | +void __init init_environ(void) | |
| 36 | +{ | |
| 37 | + int efi_boot = fw_arg0; | |
| 38 | + struct efi_memory_map_data data; | |
| 39 | + void *fdt_ptr = early_memremap_ro(fw_arg1, SZ_64K); | |
| 40 | + | |
| 41 | + if (efi_boot) | |
| 42 | + set_bit(EFI_BOOT, &efi.flags); | |
| 43 | + else | |
| 44 | + clear_bit(EFI_BOOT, &efi.flags); | |
| 45 | + | |
| 46 | + early_init_dt_scan(fdt_ptr); | |
| 47 | + early_init_fdt_reserve_self(); | |
| 48 | + efi_system_table = efi_get_fdt_params(&data); | |
| 49 | + | |
| 50 | + efi_memmap_init_early(&data); | |
| 51 | + memblock_reserve(data.phys_map & PAGE_MASK, | |
| 52 | + PAGE_ALIGN(data.size + (data.phys_map & ~PAGE_MASK))); | |
| 53 | + | |
| 54 | + register_addrs_set(smp_group, TO_UNCACHE(0x1fe01000), 16); | |
| 55 | + register_addrs_set(loongson_chipcfg, TO_UNCACHE(0x1fe00180), 16); | |
| 56 | + register_addrs_set(loongson_chiptemp, TO_UNCACHE(0x1fe0019c), 16); | |
| 57 | + register_addrs_set(loongson_freqctrl, TO_UNCACHE(0x1fe001d0), 16); | |
| 58 | +} | |
| 59 | + | |
| 60 | +static int __init init_cpu_fullname(void) | |
| 61 | +{ | |
| 62 | + int cpu; | |
| 63 | + | |
| 64 | + if (loongson_sysconf.cpuname && !strncmp(loongson_sysconf.cpuname, "Loongson", 8)) { | |
| 65 | + for (cpu = 0; cpu < NR_CPUS; cpu++) | |
| 66 | + __cpu_full_name[cpu] = loongson_sysconf.cpuname; | |
| 67 | + } | |
| 68 | + return 0; | |
| 69 | +} | |
| 70 | +arch_initcall(init_cpu_fullname); | |
| 71 | + | |
| 72 | +static ssize_t boardinfo_show(struct kobject *kobj, | |
| 73 | + struct kobj_attribute *attr, char *buf) | |
| 74 | +{ | |
| 75 | + return sprintf(buf, | |
| 76 | + "BIOS Information\n" | |
| 77 | + "Vendor\t\t\t: %s\n" | |
| 78 | + "Version\t\t\t: %s\n" | |
| 79 | + "ROM Size\t\t: %d KB\n" | |
| 80 | + "Release Date\t\t: %s\n\n" | |
| 81 | + "Board Information\n" | |
| 82 | + "Manufacturer\t\t: %s\n" | |
| 83 | + "Board Name\t\t: %s\n" | |
| 84 | + "Family\t\t\t: LOONGSON64\n\n", | |
| 85 | + b_info.bios_vendor, b_info.bios_version, | |
| 86 | + b_info.bios_size, b_info.bios_release_date, | |
| 87 | + b_info.board_vendor, b_info.board_name); | |
| 88 | +} | |
| 89 | + | |
| 90 | +static struct kobj_attribute boardinfo_attr = __ATTR(boardinfo, 0444, | |
| 91 | + boardinfo_show, NULL); | |
| 92 | + | |
| 93 | +static int __init boardinfo_init(void) | |
| 94 | +{ | |
| 95 | + struct kobject *loongson_kobj; | |
| 96 | + | |
| 97 | + loongson_kobj = kobject_create_and_add("loongson", firmware_kobj); | |
| 98 | + | |
| 99 | + return sysfs_create_file(loongson_kobj, &boardinfo_attr.attr); | |
| 100 | +} | |
| 101 | +late_initcall(boardinfo_init); | |
| @@ -0,0 +1,68 @@ | ||
| 1 | +/* SPDX-License-Identifier: GPL-2.0 */ | |
| 2 | +/* | |
| 3 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 4 | + */ | |
| 5 | +#include <linux/init.h> | |
| 6 | +#include <linux/threads.h> | |
| 7 | + | |
| 8 | +#include <asm/addrspace.h> | |
| 9 | +#include <asm/asm.h> | |
| 10 | +#include <asm/asmmacro.h> | |
| 11 | +#include <asm/regdef.h> | |
| 12 | +#include <asm/loongarch.h> | |
| 13 | +#include <asm/stackframe.h> | |
| 14 | + | |
| 15 | + __REF | |
| 16 | + | |
| 17 | +SYM_ENTRY(_stext, SYM_L_GLOBAL, SYM_A_NONE) | |
| 18 | + | |
| 19 | +SYM_CODE_START(kernel_entry) # kernel entry point | |
| 20 | + | |
| 21 | + /* Config direct window and set PG */ | |
| 22 | + li.d t0, CSR_DMW0_INIT # UC, PLV0, 0x8000 xxxx xxxx xxxx | |
| 23 | + csrwr t0, LOONGARCH_CSR_DMWIN0 | |
| 24 | + li.d t0, CSR_DMW1_INIT # CA, PLV0, 0x9000 xxxx xxxx xxxx | |
| 25 | + csrwr t0, LOONGARCH_CSR_DMWIN1 | |
| 26 | + /* Enable PG */ | |
| 27 | + li.w t0, 0xb0 # PLV=0, IE=0, PG=1 | |
| 28 | + csrwr t0, LOONGARCH_CSR_CRMD | |
| 29 | + li.w t0, 0x04 # PLV=0, PIE=1, PWE=0 | |
| 30 | + csrwr t0, LOONGARCH_CSR_PRMD | |
| 31 | + li.w t0, 0x00 # FPE=0, SXE=0, ASXE=0, BTE=0 | |
| 32 | + csrwr t0, LOONGARCH_CSR_EUEN | |
| 33 | + | |
| 34 | + /* We might not get launched at the address the kernel is linked to, | |
| 35 | + so we jump there. */ | |
| 36 | + la.abs t0, 0f | |
| 37 | + jirl zero, t0, 0 | |
| 38 | +0: | |
| 39 | + la t0, __bss_start # clear .bss | |
| 40 | + st.d zero, t0, 0 | |
| 41 | + la t1, __bss_stop - LONGSIZE | |
| 42 | +1: | |
| 43 | + addi.d t0, t0, LONGSIZE | |
| 44 | + st.d zero, t0, 0 | |
| 45 | + bne t0, t1, 1b | |
| 46 | + | |
| 47 | + la t0, fw_arg0 | |
| 48 | + st.d a0, t0, 0 # firmware arguments | |
| 49 | + la t0, fw_arg1 | |
| 50 | + st.d a1, t0, 0 | |
| 51 | + | |
| 52 | + /* KSave3 used for percpu base, initialized as 0 */ | |
| 53 | + csrwr zero, PERCPU_BASE_KS | |
| 54 | + /* GPR21 used for percpu base (runtime), initialized as 0 */ | |
| 55 | + or u0, zero, zero | |
| 56 | + | |
| 57 | + la tp, init_thread_union | |
| 58 | + /* Set the SP after an empty pt_regs. */ | |
| 59 | + PTR_LI sp, (_THREAD_SIZE - 32 - PT_SIZE) | |
| 60 | + PTR_ADD sp, sp, tp | |
| 61 | + set_saved_sp sp, t0, t1 | |
| 62 | + PTR_ADDI sp, sp, -4 * SZREG # init stack pointer | |
| 63 | + | |
| 64 | + bl start_kernel | |
| 65 | + | |
| 66 | +SYM_CODE_END(kernel_entry) | |
| 67 | + | |
| 68 | +SYM_ENTRY(kernel_entry_end, SYM_L_GLOBAL, SYM_A_NONE) | |
| @@ -0,0 +1,64 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0-or-later | |
| 2 | +/* | |
| 3 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 4 | + */ | |
| 5 | +#include <linux/efi.h> | |
| 6 | +#include <linux/initrd.h> | |
| 7 | +#include <linux/memblock.h> | |
| 8 | + | |
| 9 | +#include <asm/bootinfo.h> | |
| 10 | +#include <asm/loongson.h> | |
| 11 | +#include <asm/sections.h> | |
| 12 | + | |
| 13 | +void __init memblock_init(void) | |
| 14 | +{ | |
| 15 | + u32 mem_type; | |
| 16 | + u64 mem_start, mem_end, mem_size; | |
| 17 | + efi_memory_desc_t *md; | |
| 18 | + | |
| 19 | + /* Parse memory information */ | |
| 20 | + for_each_efi_memory_desc(md) { | |
| 21 | + mem_type = md->type; | |
| 22 | + mem_start = md->phys_addr; | |
| 23 | + mem_size = md->num_pages << EFI_PAGE_SHIFT; | |
| 24 | + mem_end = mem_start + mem_size; | |
| 25 | + | |
| 26 | + switch (mem_type) { | |
| 27 | + case EFI_LOADER_CODE: | |
| 28 | + case EFI_LOADER_DATA: | |
| 29 | + case EFI_BOOT_SERVICES_CODE: | |
| 30 | + case EFI_BOOT_SERVICES_DATA: | |
| 31 | + case EFI_PERSISTENT_MEMORY: | |
| 32 | + case EFI_CONVENTIONAL_MEMORY: | |
| 33 | + memblock_add(mem_start, mem_size); | |
| 34 | + if (max_low_pfn < (mem_end >> PAGE_SHIFT)) | |
| 35 | + max_low_pfn = mem_end >> PAGE_SHIFT; | |
| 36 | + break; | |
| 37 | + case EFI_PAL_CODE: | |
| 38 | + case EFI_UNUSABLE_MEMORY: | |
| 39 | + case EFI_ACPI_RECLAIM_MEMORY: | |
| 40 | + memblock_add(mem_start, mem_size); | |
| 41 | + fallthrough; | |
| 42 | + case EFI_RESERVED_TYPE: | |
| 43 | + case EFI_RUNTIME_SERVICES_CODE: | |
| 44 | + case EFI_RUNTIME_SERVICES_DATA: | |
| 45 | + case EFI_MEMORY_MAPPED_IO: | |
| 46 | + case EFI_MEMORY_MAPPED_IO_PORT_SPACE: | |
| 47 | + memblock_reserve(mem_start, mem_size); | |
| 48 | + break; | |
| 49 | + } | |
| 50 | + } | |
| 51 | + | |
| 52 | + memblock_set_current_limit(PFN_PHYS(max_low_pfn)); | |
| 53 | + memblock_set_node(0, PHYS_ADDR_MAX, &memblock.memory, 0); | |
| 54 | + | |
| 55 | + /* Reserve the first 2MB */ | |
| 56 | + memblock_reserve(PHYS_OFFSET, 0x200000); | |
| 57 | + | |
| 58 | + /* Reserve the kernel text/data/bss */ | |
| 59 | + memblock_reserve(__pa_symbol(&_text), | |
| 60 | + __pa_symbol(&_end) - __pa_symbol(&_text)); | |
| 61 | + | |
| 62 | + /* Reserve the initrd */ | |
| 63 | + reserve_initrd_mem(); | |
| 64 | +} | |
| @@ -0,0 +1,90 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0 | |
| 2 | +/* | |
| 3 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 4 | + */ | |
| 5 | +#include <linux/kernel.h> | |
| 6 | +#include <linux/acpi.h> | |
| 7 | +#include <linux/efi.h> | |
| 8 | +#include <linux/export.h> | |
| 9 | +#include <linux/pm.h> | |
| 10 | +#include <linux/types.h> | |
| 11 | +#include <linux/reboot.h> | |
| 12 | +#include <linux/delay.h> | |
| 13 | +#include <linux/console.h> | |
| 14 | + | |
| 15 | +#include <acpi/reboot.h> | |
| 16 | +#include <asm/compiler.h> | |
| 17 | +#include <asm/idle.h> | |
| 18 | +#include <asm/loongarch.h> | |
| 19 | +#include <asm/reboot.h> | |
| 20 | + | |
| 21 | +static void default_halt(void) | |
| 22 | +{ | |
| 23 | + local_irq_disable(); | |
| 24 | + clear_csr_ecfg(ECFG0_IM); | |
| 25 | + | |
| 26 | + pr_notice("\n\n** You can safely turn off the power now **\n\n"); | |
| 27 | + console_flush_on_panic(CONSOLE_FLUSH_PENDING); | |
| 28 | + | |
| 29 | + while (true) { | |
| 30 | + __arch_cpu_idle(); | |
| 31 | + } | |
| 32 | +} | |
| 33 | + | |
| 34 | +static void default_poweroff(void) | |
| 35 | +{ | |
| 36 | +#ifdef CONFIG_EFI | |
| 37 | + efi.reset_system(EFI_RESET_SHUTDOWN, EFI_SUCCESS, 0, NULL); | |
| 38 | +#endif | |
| 39 | + while (true) { | |
| 40 | + __arch_cpu_idle(); | |
| 41 | + } | |
| 42 | +} | |
| 43 | + | |
| 44 | +static void default_restart(void) | |
| 45 | +{ | |
| 46 | +#ifdef CONFIG_EFI | |
| 47 | + if (efi_capsule_pending(NULL)) | |
| 48 | + efi_reboot(REBOOT_WARM, NULL); | |
| 49 | + else | |
| 50 | + efi_reboot(REBOOT_COLD, NULL); | |
| 51 | +#endif | |
| 52 | + if (!acpi_disabled) | |
| 53 | + acpi_reboot(); | |
| 54 | + | |
| 55 | + while (true) { | |
| 56 | + __arch_cpu_idle(); | |
| 57 | + } | |
| 58 | +} | |
| 59 | + | |
| 60 | +void (*pm_restart)(void); | |
| 61 | +EXPORT_SYMBOL(pm_restart); | |
| 62 | + | |
| 63 | +void (*pm_power_off)(void); | |
| 64 | +EXPORT_SYMBOL(pm_power_off); | |
| 65 | + | |
| 66 | +void machine_halt(void) | |
| 67 | +{ | |
| 68 | + default_halt(); | |
| 69 | +} | |
| 70 | + | |
| 71 | +void machine_power_off(void) | |
| 72 | +{ | |
| 73 | + pm_power_off(); | |
| 74 | +} | |
| 75 | + | |
| 76 | +void machine_restart(char *command) | |
| 77 | +{ | |
| 78 | + do_kernel_restart(command); | |
| 79 | + pm_restart(); | |
| 80 | +} | |
| 81 | + | |
| 82 | +static int __init loongarch_reboot_setup(void) | |
| 83 | +{ | |
| 84 | + pm_restart = default_restart; | |
| 85 | + pm_power_off = default_poweroff; | |
| 86 | + | |
| 87 | + return 0; | |
| 88 | +} | |
| 89 | + | |
| 90 | +arch_initcall(loongarch_reboot_setup); | |
| @@ -0,0 +1,341 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0 | |
| 2 | +/* | |
| 3 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 4 | + * | |
| 5 | + * Derived from MIPS: | |
| 6 | + * Copyright (C) 1995 Linus Torvalds | |
| 7 | + * Copyright (C) 1995 Waldorf Electronics | |
| 8 | + * Copyright (C) 1994, 95, 96, 97, 98, 99, 2000, 01, 02, 03 Ralf Baechle | |
| 9 | + * Copyright (C) 1996 Stoned Elipot | |
| 10 | + * Copyright (C) 1999 Silicon Graphics, Inc. | |
| 11 | + * Copyright (C) 2000, 2001, 2002, 2007 Maciej W. Rozycki | |
| 12 | + */ | |
| 13 | +#include <linux/init.h> | |
| 14 | +#include <linux/acpi.h> | |
| 15 | +#include <linux/dmi.h> | |
| 16 | +#include <linux/efi.h> | |
| 17 | +#include <linux/export.h> | |
| 18 | +#include <linux/screen_info.h> | |
| 19 | +#include <linux/memblock.h> | |
| 20 | +#include <linux/initrd.h> | |
| 21 | +#include <linux/ioport.h> | |
| 22 | +#include <linux/root_dev.h> | |
| 23 | +#include <linux/console.h> | |
| 24 | +#include <linux/pfn.h> | |
| 25 | +#include <linux/platform_device.h> | |
| 26 | +#include <linux/sizes.h> | |
| 27 | +#include <linux/device.h> | |
| 28 | +#include <linux/dma-map-ops.h> | |
| 29 | +#include <linux/swiotlb.h> | |
| 30 | + | |
| 31 | +#include <asm/addrspace.h> | |
| 32 | +#include <asm/bootinfo.h> | |
| 33 | +#include <asm/cache.h> | |
| 34 | +#include <asm/cpu.h> | |
| 35 | +#include <asm/dma.h> | |
| 36 | +#include <asm/efi.h> | |
| 37 | +#include <asm/loongson.h> | |
| 38 | +#include <asm/pgalloc.h> | |
| 39 | +#include <asm/sections.h> | |
| 40 | +#include <asm/setup.h> | |
| 41 | +#include <asm/time.h> | |
| 42 | + | |
| 43 | +#define SMBIOS_BIOSSIZE_OFFSET 0x09 | |
| 44 | +#define SMBIOS_BIOSEXTERN_OFFSET 0x13 | |
| 45 | +#define SMBIOS_FREQLOW_OFFSET 0x16 | |
| 46 | +#define SMBIOS_FREQHIGH_OFFSET 0x17 | |
| 47 | +#define SMBIOS_FREQLOW_MASK 0xFF | |
| 48 | +#define SMBIOS_CORE_PACKAGE_OFFSET 0x23 | |
| 49 | +#define LOONGSON_EFI_ENABLE (1 << 3) | |
| 50 | + | |
| 51 | +#ifdef CONFIG_VT | |
| 52 | +struct screen_info screen_info; | |
| 53 | +#endif | |
| 54 | + | |
| 55 | +unsigned long fw_arg0, fw_arg1; | |
| 56 | +DEFINE_PER_CPU(unsigned long, kernelsp); | |
| 57 | +struct cpuinfo_loongarch cpu_data[NR_CPUS] __read_mostly; | |
| 58 | + | |
| 59 | +EXPORT_SYMBOL(cpu_data); | |
| 60 | + | |
| 61 | +struct loongson_board_info b_info; | |
| 62 | +static const char dmi_empty_string[] = " "; | |
| 63 | + | |
| 64 | +/* | |
| 65 | + * Setup information | |
| 66 | + * | |
| 67 | + * These are initialized so they are in the .data section | |
| 68 | + */ | |
| 69 | + | |
| 70 | +static int num_standard_resources; | |
| 71 | +static struct resource *standard_resources; | |
| 72 | + | |
| 73 | +static struct resource code_resource = { .name = "Kernel code", }; | |
| 74 | +static struct resource data_resource = { .name = "Kernel data", }; | |
| 75 | +static struct resource bss_resource = { .name = "Kernel bss", }; | |
| 76 | + | |
| 77 | +const char *get_system_type(void) | |
| 78 | +{ | |
| 79 | + return "generic-loongson-machine"; | |
| 80 | +} | |
| 81 | + | |
| 82 | +static const char *dmi_string_parse(const struct dmi_header *dm, u8 s) | |
| 83 | +{ | |
| 84 | + const u8 *bp = ((u8 *) dm) + dm->length; | |
| 85 | + | |
| 86 | + if (s) { | |
| 87 | + s--; | |
| 88 | + while (s > 0 && *bp) { | |
| 89 | + bp += strlen(bp) + 1; | |
| 90 | + s--; | |
| 91 | + } | |
| 92 | + | |
| 93 | + if (*bp != 0) { | |
| 94 | + size_t len = strlen(bp)+1; | |
| 95 | + size_t cmp_len = len > 8 ? 8 : len; | |
| 96 | + | |
| 97 | + if (!memcmp(bp, dmi_empty_string, cmp_len)) | |
| 98 | + return dmi_empty_string; | |
| 99 | + | |
| 100 | + return bp; | |
| 101 | + } | |
| 102 | + } | |
| 103 | + | |
| 104 | + return ""; | |
| 105 | +} | |
| 106 | + | |
| 107 | +static void __init parse_cpu_table(const struct dmi_header *dm) | |
| 108 | +{ | |
| 109 | + long freq_temp = 0; | |
| 110 | + char *dmi_data = (char *)dm; | |
| 111 | + | |
| 112 | + freq_temp = ((*(dmi_data + SMBIOS_FREQHIGH_OFFSET) << 8) + | |
| 113 | + ((*(dmi_data + SMBIOS_FREQLOW_OFFSET)) & SMBIOS_FREQLOW_MASK)); | |
| 114 | + cpu_clock_freq = freq_temp * 1000000; | |
| 115 | + | |
| 116 | + loongson_sysconf.cpuname = (void *)dmi_string_parse(dm, dmi_data[16]); | |
| 117 | + loongson_sysconf.cores_per_package = *(dmi_data + SMBIOS_CORE_PACKAGE_OFFSET); | |
| 118 | + | |
| 119 | + pr_info("CpuClock = %llu\n", cpu_clock_freq); | |
| 120 | +} | |
| 121 | + | |
| 122 | +static void __init parse_bios_table(const struct dmi_header *dm) | |
| 123 | +{ | |
| 124 | + int bios_extern; | |
| 125 | + char *dmi_data = (char *)dm; | |
| 126 | + | |
| 127 | + bios_extern = *(dmi_data + SMBIOS_BIOSEXTERN_OFFSET); | |
| 128 | + b_info.bios_size = *(dmi_data + SMBIOS_BIOSSIZE_OFFSET); | |
| 129 | + | |
| 130 | + if (bios_extern & LOONGSON_EFI_ENABLE) | |
| 131 | + set_bit(EFI_BOOT, &efi.flags); | |
| 132 | + else | |
| 133 | + clear_bit(EFI_BOOT, &efi.flags); | |
| 134 | +} | |
| 135 | + | |
| 136 | +static void __init find_tokens(const struct dmi_header *dm, void *dummy) | |
| 137 | +{ | |
| 138 | + switch (dm->type) { | |
| 139 | + case 0x0: /* Extern BIOS */ | |
| 140 | + parse_bios_table(dm); | |
| 141 | + break; | |
| 142 | + case 0x4: /* Calling interface */ | |
| 143 | + parse_cpu_table(dm); | |
| 144 | + break; | |
| 145 | + } | |
| 146 | +} | |
| 147 | +static void __init smbios_parse(void) | |
| 148 | +{ | |
| 149 | + b_info.bios_vendor = (void *)dmi_get_system_info(DMI_BIOS_VENDOR); | |
| 150 | + b_info.bios_version = (void *)dmi_get_system_info(DMI_BIOS_VERSION); | |
| 151 | + b_info.bios_release_date = (void *)dmi_get_system_info(DMI_BIOS_DATE); | |
| 152 | + b_info.board_vendor = (void *)dmi_get_system_info(DMI_BOARD_VENDOR); | |
| 153 | + b_info.board_name = (void *)dmi_get_system_info(DMI_BOARD_NAME); | |
| 154 | + dmi_walk(find_tokens, NULL); | |
| 155 | +} | |
| 156 | + | |
| 157 | +static int usermem __initdata; | |
| 158 | + | |
| 159 | +static int __init early_parse_mem(char *p) | |
| 160 | +{ | |
| 161 | + phys_addr_t start, size; | |
| 162 | + | |
| 163 | + if (!p) { | |
| 164 | + pr_err("mem parameter is empty, do nothing\n"); | |
| 165 | + return -EINVAL; | |
| 166 | + } | |
| 167 | + | |
| 168 | + /* | |
| 169 | + * If a user specifies memory size, we | |
| 170 | + * blow away any automatically generated | |
| 171 | + * size. | |
| 172 | + */ | |
| 173 | + if (usermem == 0) { | |
| 174 | + usermem = 1; | |
| 175 | + memblock_remove(memblock_start_of_DRAM(), | |
| 176 | + memblock_end_of_DRAM() - memblock_start_of_DRAM()); | |
| 177 | + } | |
| 178 | + start = 0; | |
| 179 | + size = memparse(p, &p); | |
| 180 | + if (*p == '@') | |
| 181 | + start = memparse(p + 1, &p); | |
| 182 | + else { | |
| 183 | + pr_err("Invalid format!\n"); | |
| 184 | + return -EINVAL; | |
| 185 | + } | |
| 186 | + | |
| 187 | + memblock_add(start, size); | |
| 188 | + | |
| 189 | + return 0; | |
| 190 | +} | |
| 191 | +early_param("mem", early_parse_mem); | |
| 192 | + | |
| 193 | +void __init platform_init(void) | |
| 194 | +{ | |
| 195 | + efi_init(); | |
| 196 | +#ifdef CONFIG_ACPI_TABLE_UPGRADE | |
| 197 | + acpi_table_upgrade(); | |
| 198 | +#endif | |
| 199 | +#ifdef CONFIG_ACPI | |
| 200 | + acpi_gbl_use_default_register_widths = false; | |
| 201 | + acpi_boot_table_init(); | |
| 202 | + acpi_boot_init(); | |
| 203 | +#endif | |
| 204 | + | |
| 205 | + dmi_setup(); | |
| 206 | + smbios_parse(); | |
| 207 | + pr_info("The BIOS Version: %s\n", b_info.bios_version); | |
| 208 | + | |
| 209 | + efi_runtime_init(); | |
| 210 | +} | |
| 211 | + | |
| 212 | +static void __init check_kernel_sections_mem(void) | |
| 213 | +{ | |
| 214 | + phys_addr_t start = __pa_symbol(&_text); | |
| 215 | + phys_addr_t size = __pa_symbol(&_end) - start; | |
| 216 | + | |
| 217 | + if (!memblock_is_region_memory(start, size)) { | |
| 218 | + pr_info("Kernel sections are not in the memory maps\n"); | |
| 219 | + memblock_add(start, size); | |
| 220 | + } | |
| 221 | +} | |
| 222 | + | |
| 223 | +/* | |
| 224 | + * arch_mem_init - initialize memory management subsystem | |
| 225 | + */ | |
| 226 | +static void __init arch_mem_init(char **cmdline_p) | |
| 227 | +{ | |
| 228 | + if (usermem) | |
| 229 | + pr_info("User-defined physical RAM map overwrite\n"); | |
| 230 | + | |
| 231 | + check_kernel_sections_mem(); | |
| 232 | + | |
| 233 | + /* | |
| 234 | + * In order to reduce the possibility of kernel panic when failed to | |
| 235 | + * get IO TLB memory under CONFIG_SWIOTLB, it is better to allocate | |
| 236 | + * low memory as small as possible before plat_swiotlb_setup(), so | |
| 237 | + * make sparse_init() using top-down allocation. | |
| 238 | + */ | |
| 239 | + memblock_set_bottom_up(false); | |
| 240 | + sparse_init(); | |
| 241 | + memblock_set_bottom_up(true); | |
| 242 | + | |
| 243 | + swiotlb_init(true, SWIOTLB_VERBOSE); | |
| 244 | + | |
| 245 | + dma_contiguous_reserve(PFN_PHYS(max_low_pfn)); | |
| 246 | + | |
| 247 | + memblock_dump_all(); | |
| 248 | + | |
| 249 | + early_memtest(PFN_PHYS(ARCH_PFN_OFFSET), PFN_PHYS(max_low_pfn)); | |
| 250 | +} | |
| 251 | + | |
| 252 | +static void __init resource_init(void) | |
| 253 | +{ | |
| 254 | + long i = 0; | |
| 255 | + size_t res_size; | |
| 256 | + struct resource *res; | |
| 257 | + struct memblock_region *region; | |
| 258 | + | |
| 259 | + code_resource.start = __pa_symbol(&_text); | |
| 260 | + code_resource.end = __pa_symbol(&_etext) - 1; | |
| 261 | + data_resource.start = __pa_symbol(&_etext); | |
| 262 | + data_resource.end = __pa_symbol(&_edata) - 1; | |
| 263 | + bss_resource.start = __pa_symbol(&__bss_start); | |
| 264 | + bss_resource.end = __pa_symbol(&__bss_stop) - 1; | |
| 265 | + | |
| 266 | + num_standard_resources = memblock.memory.cnt; | |
| 267 | + res_size = num_standard_resources * sizeof(*standard_resources); | |
| 268 | + standard_resources = memblock_alloc(res_size, SMP_CACHE_BYTES); | |
| 269 | + | |
| 270 | + for_each_mem_region(region) { | |
| 271 | + res = &standard_resources[i++]; | |
| 272 | + if (!memblock_is_nomap(region)) { | |
| 273 | + res->name = "System RAM"; | |
| 274 | + res->flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY; | |
| 275 | + res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region)); | |
| 276 | + res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1; | |
| 277 | + } else { | |
| 278 | + res->name = "Reserved"; | |
| 279 | + res->flags = IORESOURCE_MEM; | |
| 280 | + res->start = __pfn_to_phys(memblock_region_reserved_base_pfn(region)); | |
| 281 | + res->end = __pfn_to_phys(memblock_region_reserved_end_pfn(region)) - 1; | |
| 282 | + } | |
| 283 | + | |
| 284 | + request_resource(&iomem_resource, res); | |
| 285 | + | |
| 286 | + /* | |
| 287 | + * We don't know which RAM region contains kernel data, | |
| 288 | + * so we try it repeatedly and let the resource manager | |
| 289 | + * test it. | |
| 290 | + */ | |
| 291 | + request_resource(res, &code_resource); | |
| 292 | + request_resource(res, &data_resource); | |
| 293 | + request_resource(res, &bss_resource); | |
| 294 | + } | |
| 295 | +} | |
| 296 | + | |
| 297 | +static int __init reserve_memblock_reserved_regions(void) | |
| 298 | +{ | |
| 299 | + u64 i, j; | |
| 300 | + | |
| 301 | + for (i = 0; i < num_standard_resources; ++i) { | |
| 302 | + struct resource *mem = &standard_resources[i]; | |
| 303 | + phys_addr_t r_start, r_end, mem_size = resource_size(mem); | |
| 304 | + | |
| 305 | + if (!memblock_is_region_reserved(mem->start, mem_size)) | |
| 306 | + continue; | |
| 307 | + | |
| 308 | + for_each_reserved_mem_range(j, &r_start, &r_end) { | |
| 309 | + resource_size_t start, end; | |
| 310 | + | |
| 311 | + start = max(PFN_PHYS(PFN_DOWN(r_start)), mem->start); | |
| 312 | + end = min(PFN_PHYS(PFN_UP(r_end)) - 1, mem->end); | |
| 313 | + | |
| 314 | + if (start > mem->end || end < mem->start) | |
| 315 | + continue; | |
| 316 | + | |
| 317 | + reserve_region_with_split(mem, start, end, "Reserved"); | |
| 318 | + } | |
| 319 | + } | |
| 320 | + | |
| 321 | + return 0; | |
| 322 | +} | |
| 323 | +arch_initcall(reserve_memblock_reserved_regions); | |
| 324 | + | |
| 325 | +void __init setup_arch(char **cmdline_p) | |
| 326 | +{ | |
| 327 | + cpu_probe(); | |
| 328 | + *cmdline_p = boot_command_line; | |
| 329 | + | |
| 330 | + init_environ(); | |
| 331 | + memblock_init(); | |
| 332 | + parse_early_param(); | |
| 333 | + | |
| 334 | + platform_init(); | |
| 335 | + pagetable_init(); | |
| 336 | + arch_mem_init(cmdline_p); | |
| 337 | + | |
| 338 | + resource_init(); | |
| 339 | + | |
| 340 | + paging_init(); | |
| 341 | +} | |
| @@ -0,0 +1,213 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0 | |
| 2 | +/* | |
| 3 | + * Common time service routines for LoongArch machines. | |
| 4 | + * | |
| 5 | + * Copyright (C) 2020-2022 Loongson Technology Corporation Limited | |
| 6 | + */ | |
| 7 | +#include <linux/clockchips.h> | |
| 8 | +#include <linux/delay.h> | |
| 9 | +#include <linux/export.h> | |
| 10 | +#include <linux/init.h> | |
| 11 | +#include <linux/interrupt.h> | |
| 12 | +#include <linux/kernel.h> | |
| 13 | +#include <linux/sched_clock.h> | |
| 14 | +#include <linux/spinlock.h> | |
| 15 | + | |
| 16 | +#include <asm/cpu-features.h> | |
| 17 | +#include <asm/loongarch.h> | |
| 18 | +#include <asm/time.h> | |
| 19 | + | |
| 20 | +u64 cpu_clock_freq; | |
| 21 | +EXPORT_SYMBOL(cpu_clock_freq); | |
| 22 | +u64 const_clock_freq; | |
| 23 | +EXPORT_SYMBOL(const_clock_freq); | |
| 24 | + | |
| 25 | +static DEFINE_RAW_SPINLOCK(state_lock); | |
| 26 | +static DEFINE_PER_CPU(struct clock_event_device, constant_clockevent_device); | |
| 27 | + | |
| 28 | +static void constant_event_handler(struct clock_event_device *dev) | |
| 29 | +{ | |
| 30 | +} | |
| 31 | + | |
| 32 | +irqreturn_t constant_timer_interrupt(int irq, void *data) | |
| 33 | +{ | |
| 34 | + int cpu = smp_processor_id(); | |
| 35 | + struct clock_event_device *cd; | |
| 36 | + | |
| 37 | + /* Clear Timer Interrupt */ | |
| 38 | + write_csr_tintclear(CSR_TINTCLR_TI); | |
| 39 | + cd = &per_cpu(constant_clockevent_device, cpu); | |
| 40 | + cd->event_handler(cd); | |
| 41 | + | |
| 42 | + return IRQ_HANDLED; | |
| 43 | +} | |
| 44 | + | |
| 45 | +static int constant_set_state_oneshot(struct clock_event_device *evt) | |
| 46 | +{ | |
| 47 | + unsigned long timer_config; | |
| 48 | + | |
| 49 | + raw_spin_lock(&state_lock); | |
| 50 | + | |
| 51 | + timer_config = csr_read64(LOONGARCH_CSR_TCFG); | |
| 52 | + timer_config |= CSR_TCFG_EN; | |
| 53 | + timer_config &= ~CSR_TCFG_PERIOD; | |
| 54 | + csr_write64(timer_config, LOONGARCH_CSR_TCFG); | |
| 55 | + | |
| 56 | + raw_spin_unlock(&state_lock); | |
| 57 | + | |
| 58 | + return 0; | |
| 59 | +} | |
| 60 | + | |
| 61 | +static int constant_set_state_oneshot_stopped(struct clock_event_device *evt) | |
| 62 | +{ | |
| 63 | + unsigned long timer_config; | |
| 64 | + | |
| 65 | + raw_spin_lock(&state_lock); | |
| 66 | + | |
| 67 | + timer_config = csr_read64(LOONGARCH_CSR_TCFG); | |
| 68 | + timer_config &= ~CSR_TCFG_EN; | |
| 69 | + csr_write64(timer_config, LOONGARCH_CSR_TCFG); | |
| 70 | + | |
| 71 | + raw_spin_unlock(&state_lock); | |
| 72 | + | |
| 73 | + return 0; | |
| 74 | +} | |
| 75 | + | |
| 76 | +static int constant_set_state_periodic(struct clock_event_device *evt) | |
| 77 | +{ | |
| 78 | + unsigned long period; | |
| 79 | + unsigned long timer_config; | |
| 80 | + | |
| 81 | + raw_spin_lock(&state_lock); | |
| 82 | + | |
| 83 | + period = const_clock_freq / HZ; | |
| 84 | + timer_config = period & CSR_TCFG_VAL; | |
| 85 | + timer_config |= (CSR_TCFG_PERIOD | CSR_TCFG_EN); | |
| 86 | + csr_write64(timer_config, LOONGARCH_CSR_TCFG); | |
| 87 | + | |
| 88 | + raw_spin_unlock(&state_lock); | |
| 89 | + | |
| 90 | + return 0; | |
| 91 | +} | |
| 92 | + | |
| 93 | +static int constant_set_state_shutdown(struct clock_event_device *evt) | |
| 94 | +{ | |
| 95 | + return 0; | |
| 96 | +} | |
| 97 | + | |
| 98 | +static int constant_timer_next_event(unsigned long delta, struct clock_event_device *evt) | |
| 99 | +{ | |
| 100 | + unsigned long timer_config; | |
| 101 | + | |
| 102 | + delta &= CSR_TCFG_VAL; | |
| 103 | + timer_config = delta | CSR_TCFG_EN; | |
| 104 | + csr_write64(timer_config, LOONGARCH_CSR_TCFG); | |
| 105 | + | |
| 106 | + return 0; | |
| 107 | +} | |
| 108 | + | |
| 109 | +static unsigned long __init get_loops_per_jiffy(void) | |
| 110 | +{ | |
| 111 | + unsigned long lpj = (unsigned long)const_clock_freq; | |
| 112 | + | |
| 113 | + do_div(lpj, HZ); | |
| 114 | + | |
| 115 | + return lpj; | |
| 116 | +} | |
| 117 | + | |
| 118 | +static long init_timeval; | |
| 119 | + | |
| 120 | +void sync_counter(void) | |
| 121 | +{ | |
| 122 | + /* Ensure counter begin at 0 */ | |
| 123 | + csr_write64(-init_timeval, LOONGARCH_CSR_CNTC); | |
| 124 | +} | |
| 125 | + | |
| 126 | +int constant_clockevent_init(void) | |
| 127 | +{ | |
| 128 | + unsigned int irq; | |
| 129 | + unsigned int cpu = smp_processor_id(); | |
| 130 | + unsigned long min_delta = 0x600; | |
| 131 | + unsigned long max_delta = (1UL << 48) - 1; | |
| 132 | + struct clock_event_device *cd; | |
| 133 | + static int timer_irq_installed = 0; | |
| 134 | + | |
| 135 | + irq = EXCCODE_TIMER - EXCCODE_INT_START; | |
| 136 | + | |
| 137 | + cd = &per_cpu(constant_clockevent_device, cpu); | |
| 138 | + | |
| 139 | + cd->name = "Constant"; | |
| 140 | + cd->features = CLOCK_EVT_FEAT_ONESHOT | CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_PERCPU; | |
| 141 | + | |
| 142 | + cd->irq = irq; | |
| 143 | + cd->rating = 320; | |
| 144 | + cd->cpumask = cpumask_of(cpu); | |
| 145 | + cd->set_state_oneshot = constant_set_state_oneshot; | |
| 146 | + cd->set_state_oneshot_stopped = constant_set_state_oneshot_stopped; | |
| 147 | + cd->set_state_periodic = constant_set_state_periodic; | |
| 148 | + cd->set_state_shutdown = constant_set_state_shutdown; | |
| 149 | + cd->set_next_event = constant_timer_next_event; | |
| 150 | + cd->event_handler = constant_event_handler; | |
| 151 | + | |
| 152 | + clockevents_config_and_register(cd, const_clock_freq, min_delta, max_delta); | |
| 153 | + | |
| 154 | + if (timer_irq_installed) | |
| 155 | + return 0; | |
| 156 | + | |
| 157 | + timer_irq_installed = 1; | |
| 158 | + | |
| 159 | + sync_counter(); | |
| 160 | + | |
| 161 | + if (request_irq(irq, constant_timer_interrupt, IRQF_PERCPU | IRQF_TIMER, "timer", NULL)) | |
| 162 | + pr_err("Failed to request irq %d (timer)\n", irq); | |
| 163 | + | |
| 164 | + lpj_fine = get_loops_per_jiffy(); | |
| 165 | + pr_info("Constant clock event device register\n"); | |
| 166 | + | |
| 167 | + return 0; | |
| 168 | +} | |
| 169 | + | |
| 170 | +static u64 read_const_counter(struct clocksource *clk) | |
| 171 | +{ | |
| 172 | + return drdtime(); | |
| 173 | +} | |
| 174 | + | |
| 175 | +static u64 native_sched_clock(void) | |
| 176 | +{ | |
| 177 | + return read_const_counter(NULL); | |
| 178 | +} | |
| 179 | + | |
| 180 | +static struct clocksource clocksource_const = { | |
| 181 | + .name = "Constant", | |
| 182 | + .rating = 400, | |
| 183 | + .read = read_const_counter, | |
| 184 | + .mask = CLOCKSOURCE_MASK(64), | |
| 185 | + .flags = CLOCK_SOURCE_IS_CONTINUOUS, | |
| 186 | +}; | |
| 187 | + | |
| 188 | +int __init constant_clocksource_init(void) | |
| 189 | +{ | |
| 190 | + int res; | |
| 191 | + unsigned long freq = const_clock_freq; | |
| 192 | + | |
| 193 | + res = clocksource_register_hz(&clocksource_const, freq); | |
| 194 | + | |
| 195 | + sched_clock_register(native_sched_clock, 64, freq); | |
| 196 | + | |
| 197 | + pr_info("Constant clock source device register\n"); | |
| 198 | + | |
| 199 | + return res; | |
| 200 | +} | |
| 201 | + | |
| 202 | +void __init time_init(void) | |
| 203 | +{ | |
| 204 | + if (!cpu_has_cpucfg) | |
| 205 | + const_clock_freq = cpu_clock_freq; | |
| 206 | + else | |
| 207 | + const_clock_freq = calc_const_freq(); | |
| 208 | + | |
| 209 | + init_timeval = drdtime() - csr_read64(LOONGARCH_CSR_CNTC); | |
| 210 | + | |
| 211 | + constant_clockevent_init(); | |
| 212 | + constant_clocksource_init(); | |
| 213 | +} | |
| @@ -0,0 +1,13 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0 | |
| 2 | +#include <linux/cpu.h> | |
| 3 | +#include <linux/init.h> | |
| 4 | +#include <linux/percpu.h> | |
| 5 | + | |
| 6 | +static struct cpu cpu_device; | |
| 7 | + | |
| 8 | +static int __init topology_init(void) | |
| 9 | +{ | |
| 10 | + return register_cpu(&cpu_device, 0); | |
| 11 | +} | |
| 12 | + | |
| 13 | +subsys_initcall(topology_init); | |