mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-29 11:11:45 -04:00
Merge branch 'parisc-4.14-1' of git://git.kernel.org/pub/scm/linux/kernel/git/deller/parisc-linux
Pull parisc updates from Helge Deller:
"Major changes include:
- Full support of the firmware Page Deallocation Table with
MADV_HWPOISON and MADV_SOFT_OFFLINE. A kernel thread scans
regularily for new bad memory pages.
- Full support for self-extracting kernel.
- Added UBSAN support.
- Lots of section mismatch fixes across all parisc drivers.
- Added examples for %pF and %pS usage in printk-formats.txt"
* 'parisc-4.14-1' of git://git.kernel.org/pub/scm/linux/kernel/git/deller/parisc-linux: (28 commits)
printk-formats.txt: Add examples for %pF and %pS usage
parisc: Fix up devices below a PCI-PCI MegaRAID controller bridge
parisc/core: Fix section mismatches
parisc/ipmi_si_intf: Fix section mismatches on parisc platform
parisc/input/hilkbd: Fix section mismatches
parisc/net/lasi_82596: Fix section mismatches
parisc/serio: Fix section mismatches in gscps2 and hp_sdc drivers
parisc: Fix section mismatches in parisc core drivers
parisc/parport_gsc: Fix section mismatches
parisc/scsi/lasi700: Fix section mismatches
parisc/scsi/zalon: Fix section mismatches
parisc/8250_gsc: Fix section mismatches
parisc/mux: Fix section mismatches
parisc/sticore: Fix section mismatches
parisc/harmony: Fix section mismatches
parisc: Wire up support for self-extracting kernel
parisc: Make existing core files reuseable for bootloader
parisc: Add core code for self-extracting kernel
parisc: Enable UBSAN support
parisc/random: Add machine specific randomness
...
This commit is contained in:
Linus Torvalds
commit
f32c9e059e
49 changed files with 1182 additions and 157 deletions
|
|
@ -9,6 +9,9 @@ config PARISC
|
|||
select ARCH_WANT_FRAME_POINTERS
|
||||
select ARCH_HAS_ELF_RANDOMIZE
|
||||
select ARCH_HAS_STRICT_KERNEL_RWX
|
||||
select ARCH_HAS_UBSAN_SANITIZE_ALL
|
||||
select ARCH_WANTS_UBSAN_NO_NULL
|
||||
select ARCH_SUPPORTS_MEMORY_FAILURE
|
||||
select RTC_CLASS
|
||||
select RTC_DRV_GENERIC
|
||||
select INIT_ALL_POSSIBLE
|
||||
|
|
@ -17,6 +20,12 @@ config PARISC
|
|||
select BUG
|
||||
select BUILDTIME_EXTABLE_SORT
|
||||
select HAVE_PERF_EVENTS
|
||||
select HAVE_KERNEL_BZIP2
|
||||
select HAVE_KERNEL_GZIP
|
||||
select HAVE_KERNEL_LZ4
|
||||
select HAVE_KERNEL_LZMA
|
||||
select HAVE_KERNEL_LZO
|
||||
select HAVE_KERNEL_XZ
|
||||
select GENERIC_ATOMIC64 if !64BIT
|
||||
select GENERIC_IRQ_PROBE
|
||||
select GENERIC_PCI_IOMAP
|
||||
|
|
|
|||
|
|
@ -24,15 +24,20 @@ KBUILD_DEFCONFIG := default_defconfig
|
|||
NM = sh $(srctree)/arch/parisc/nm
|
||||
CHECKFLAGS += -D__hppa__=1
|
||||
LIBGCC = $(shell $(CC) $(KBUILD_CFLAGS) -print-libgcc-file-name)
|
||||
export LIBGCC
|
||||
|
||||
ifdef CONFIG_64BIT
|
||||
UTS_MACHINE := parisc64
|
||||
CHECKFLAGS += -D__LP64__=1 -m64
|
||||
CC_ARCHES = hppa64
|
||||
LD_BFD := elf64-hppa-linux
|
||||
else # 32-bit
|
||||
CC_ARCHES = hppa hppa2.0 hppa1.1
|
||||
LD_BFD := elf32-hppa-linux
|
||||
endif
|
||||
|
||||
export LD_BFD
|
||||
|
||||
ifneq ($(SUBARCH),$(UTS_MACHINE))
|
||||
ifeq ($(CROSS_COMPILE),)
|
||||
CC_SUFFIXES = linux linux-gnu unknown-linux-gnu
|
||||
|
|
@ -88,6 +93,8 @@ libs-y += arch/parisc/lib/ $(LIBGCC)
|
|||
|
||||
drivers-$(CONFIG_OPROFILE) += arch/parisc/oprofile/
|
||||
|
||||
boot := arch/parisc/boot
|
||||
|
||||
PALO := $(shell if (which palo 2>&1); then : ; \
|
||||
elif [ -x /sbin/palo ]; then echo /sbin/palo; \
|
||||
fi)
|
||||
|
|
@ -116,11 +123,14 @@ INSTALL_TARGETS = zinstall install
|
|||
|
||||
PHONY += bzImage $(BOOT_TARGETS) $(INSTALL_TARGETS)
|
||||
|
||||
bzImage zImage: vmlinuz
|
||||
zImage: vmlinuz
|
||||
Image: vmlinux
|
||||
|
||||
vmlinuz: vmlinux
|
||||
@gzip -cf -9 $< > $@
|
||||
bzImage: vmlinux
|
||||
$(Q)$(MAKE) $(build)=$(boot) $(boot)/$@
|
||||
|
||||
vmlinuz: bzImage
|
||||
$(OBJCOPY) $(boot)/bzImage $@
|
||||
|
||||
install:
|
||||
$(CONFIG_SHELL) $(src)/arch/parisc/install.sh \
|
||||
|
|
|
|||
2
arch/parisc/boot/.gitignore
vendored
Normal file
2
arch/parisc/boot/.gitignore
vendored
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
image
|
||||
bzImage
|
||||
26
arch/parisc/boot/Makefile
Normal file
26
arch/parisc/boot/Makefile
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
#
|
||||
# Makefile for the linux parisc-specific parts of the boot image creator.
|
||||
#
|
||||
|
||||
COMPILE_VERSION := __linux_compile_version_id__`hostname | \
|
||||
tr -c '[0-9A-Za-z]' '_'`__`date | \
|
||||
tr -c '[0-9A-Za-z]' '_'`_t
|
||||
|
||||
ccflags-y := -DCOMPILE_VERSION=$(COMPILE_VERSION) -gstabs -I.
|
||||
|
||||
targets := image
|
||||
targets += bzImage
|
||||
subdir- := compressed
|
||||
|
||||
$(obj)/image: vmlinux FORCE
|
||||
$(call if_changed,objcopy)
|
||||
|
||||
$(obj)/bzImage: $(obj)/compressed/vmlinux FORCE
|
||||
$(call if_changed,objcopy)
|
||||
|
||||
$(obj)/compressed/vmlinux: FORCE
|
||||
$(Q)$(MAKE) $(build)=$(obj)/compressed $@
|
||||
|
||||
install: $(CONFIGURE) $(obj)/bzImage
|
||||
sh -x $(srctree)/$(obj)/install.sh $(KERNELRELEASE) $(obj)/bzImage \
|
||||
System.map "$(INSTALL_PATH)"
|
||||
3
arch/parisc/boot/compressed/.gitignore
vendored
Normal file
3
arch/parisc/boot/compressed/.gitignore
vendored
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
sizes.h
|
||||
vmlinux
|
||||
vmlinux.lds
|
||||
86
arch/parisc/boot/compressed/Makefile
Normal file
86
arch/parisc/boot/compressed/Makefile
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
#
|
||||
# linux/arch/parisc/boot/compressed/Makefile
|
||||
#
|
||||
# create a compressed self-extracting vmlinux image from the original vmlinux
|
||||
#
|
||||
|
||||
KCOV_INSTRUMENT := n
|
||||
GCOV_PROFILE := n
|
||||
UBSAN_SANITIZE := n
|
||||
|
||||
targets := vmlinux.lds vmlinux vmlinux.bin vmlinux.bin.gz vmlinux.bin.bz2
|
||||
targets += vmlinux.bin.xz vmlinux.bin.lzma vmlinux.bin.lzo vmlinux.bin.lz4
|
||||
targets += misc.o piggy.o sizes.h head.o real2.o firmware.o
|
||||
|
||||
KBUILD_CFLAGS := -D__KERNEL__ -O2 -DBOOTLOADER
|
||||
KBUILD_CFLAGS += -DDISABLE_BRANCH_PROFILING
|
||||
KBUILD_CFLAGS += $(cflags-y) -fno-delete-null-pointer-checks
|
||||
KBUILD_CFLAGS += -fno-PIE -mno-space-regs -mdisable-fpregs
|
||||
ifndef CONFIG_64BIT
|
||||
KBUILD_CFLAGS += -mfast-indirect-calls
|
||||
endif
|
||||
|
||||
OBJECTS += $(obj)/head.o $(obj)/real2.o $(obj)/firmware.o $(obj)/misc.o $(obj)/piggy.o
|
||||
|
||||
# LDFLAGS_vmlinux := -X --whole-archive -e startup -T
|
||||
LDFLAGS_vmlinux := -X -e startup --as-needed -T
|
||||
$(obj)/vmlinux: $(obj)/vmlinux.lds $(OBJECTS) $(LIBGCC)
|
||||
$(call if_changed,ld)
|
||||
|
||||
sed-sizes := -e 's/^\([0-9a-fA-F]*\) . \(__bss_start\|_end\|parisc_kernel_start\)$$/\#define SZ\2 0x\1/p'
|
||||
|
||||
quiet_cmd_sizes = GEN $@
|
||||
cmd_sizes = $(NM) $< | sed -n $(sed-sizes) > $@
|
||||
|
||||
$(obj)/sizes.h: vmlinux
|
||||
$(call if_changed,sizes)
|
||||
|
||||
AFLAGS_head.o += -I$(objtree)/$(obj) -DBOOTLOADER
|
||||
$(obj)/head.o: $(obj)/sizes.h
|
||||
|
||||
CFLAGS_misc.o += -I$(objtree)/$(obj)
|
||||
$(obj)/misc.o: $(obj)/sizes.h
|
||||
|
||||
$(obj)/firmware.o: $(obj)/firmware.c
|
||||
$(obj)/firmware.c: $(srctree)/arch/$(SRCARCH)/kernel/firmware.c
|
||||
$(call cmd,shipped)
|
||||
|
||||
AFLAGS_real2.o += -DBOOTLOADER
|
||||
$(obj)/real2.o: $(obj)/real2.S
|
||||
$(obj)/real2.S: $(srctree)/arch/$(SRCARCH)/kernel/real2.S
|
||||
$(call cmd,shipped)
|
||||
|
||||
$(obj)/misc.o: $(obj)/sizes.h
|
||||
|
||||
CPPFLAGS_vmlinux.lds += -I$(objtree)/$(obj) -DBOOTLOADER
|
||||
$(obj)/vmlinux.lds: $(obj)/sizes.h
|
||||
|
||||
OBJCOPYFLAGS_vmlinux.bin := -O binary -R .comment -S
|
||||
$(obj)/vmlinux.bin: vmlinux
|
||||
$(call if_changed,objcopy)
|
||||
|
||||
vmlinux.bin.all-y := $(obj)/vmlinux.bin
|
||||
|
||||
suffix-$(CONFIG_KERNEL_GZIP) := gz
|
||||
suffix-$(CONFIG_KERNEL_BZIP2) := bz2
|
||||
suffix-$(CONFIG_KERNEL_LZ4) := lz4
|
||||
suffix-$(CONFIG_KERNEL_LZMA) := lzma
|
||||
suffix-$(CONFIG_KERNEL_LZO) := lzo
|
||||
suffix-$(CONFIG_KERNEL_XZ) := xz
|
||||
|
||||
$(obj)/vmlinux.bin.gz: $(vmlinux.bin.all-y)
|
||||
$(call if_changed,gzip)
|
||||
$(obj)/vmlinux.bin.bz2: $(vmlinux.bin.all-y)
|
||||
$(call if_changed,bzip2)
|
||||
$(obj)/vmlinux.bin.lz4: $(vmlinux.bin.all-y)
|
||||
$(call if_changed,lz4)
|
||||
$(obj)/vmlinux.bin.lzma: $(vmlinux.bin.all-y)
|
||||
$(call if_changed,lzma)
|
||||
$(obj)/vmlinux.bin.lzo: $(vmlinux.bin.all-y)
|
||||
$(call if_changed,lzo)
|
||||
$(obj)/vmlinux.bin.xz: $(vmlinux.bin.all-y)
|
||||
$(call if_changed,xzkern)
|
||||
|
||||
LDFLAGS_piggy.o := -r --format binary --oformat $(LD_BFD) -T
|
||||
$(obj)/piggy.o: $(obj)/vmlinux.scr $(obj)/vmlinux.bin.$(suffix-y)
|
||||
$(call if_changed,ld)
|
||||
85
arch/parisc/boot/compressed/head.S
Normal file
85
arch/parisc/boot/compressed/head.S
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
/*
|
||||
* Startup glue code to uncompress the kernel
|
||||
*
|
||||
* (C) 2017 Helge Deller <deller@gmx.de>
|
||||
*/
|
||||
|
||||
#include <linux/init.h>
|
||||
#include <linux/linkage.h>
|
||||
#include <asm/asm-offsets.h>
|
||||
#include <asm/page.h>
|
||||
#include <asm/psw.h>
|
||||
#include <asm/pdc.h>
|
||||
#include <asm/assembly.h>
|
||||
#include "sizes.h"
|
||||
|
||||
#define BOOTADDR(x) (x)
|
||||
|
||||
#ifndef CONFIG_64BIT
|
||||
.import $global$ /* forward declaration */
|
||||
#endif /*!CONFIG_64BIT*/
|
||||
|
||||
__HEAD
|
||||
|
||||
ENTRY(startup)
|
||||
.level LEVEL
|
||||
|
||||
#define PSW_W_SM 0x200
|
||||
#define PSW_W_BIT 36
|
||||
|
||||
;! nuke the W bit, saving original value
|
||||
.level 2.0
|
||||
rsm PSW_W_SM, %r1
|
||||
|
||||
.level 1.1
|
||||
extrw,u %r1, PSW_W_BIT-32, 1, %r1
|
||||
copy %r1, %arg0
|
||||
|
||||
/* Make sure sr4-sr7 are set to zero for the kernel address space */
|
||||
mtsp %r0,%sr4
|
||||
mtsp %r0,%sr5
|
||||
mtsp %r0,%sr6
|
||||
mtsp %r0,%sr7
|
||||
|
||||
/* Clear BSS */
|
||||
|
||||
.import _bss,data
|
||||
.import _ebss,data
|
||||
|
||||
load32 BOOTADDR(_bss),%r3
|
||||
load32 BOOTADDR(_ebss),%r4
|
||||
ldo FRAME_SIZE(%r4),%sp /* stack at end of bss */
|
||||
$bss_loop:
|
||||
cmpb,<<,n %r3,%r4,$bss_loop
|
||||
stw,ma %r0,4(%r3)
|
||||
|
||||
/* Initialize the global data pointer */
|
||||
loadgp
|
||||
|
||||
/* arg0..arg4 were set by palo. */
|
||||
copy %arg1, %r6 /* command line */
|
||||
copy %arg2, %r7 /* rd-start */
|
||||
copy %arg3, %r8 /* rd-end */
|
||||
load32 BOOTADDR(decompress_kernel),%r3
|
||||
|
||||
#ifdef CONFIG_64BIT
|
||||
.level LEVEL
|
||||
ssm PSW_W_SM, %r0 /* set W-bit */
|
||||
depdi 0, 31, 32, %r3
|
||||
#endif
|
||||
load32 BOOTADDR(startup_continue), %r2
|
||||
bv,n 0(%r3)
|
||||
|
||||
startup_continue:
|
||||
#ifdef CONFIG_64BIT
|
||||
.level LEVEL
|
||||
rsm PSW_W_SM, %r0 /* clear W-bit */
|
||||
#endif
|
||||
|
||||
load32 KERNEL_BINARY_TEXT_START, %arg0 /* free mem */
|
||||
copy %r6, %arg1 /* command line */
|
||||
copy %r7, %arg2 /* rd-start */
|
||||
copy %r8, %arg3 /* rd-end */
|
||||
|
||||
bv,n 0(%ret0)
|
||||
END(startup)
|
||||
301
arch/parisc/boot/compressed/misc.c
Normal file
301
arch/parisc/boot/compressed/misc.c
Normal file
|
|
@ -0,0 +1,301 @@
|
|||
/*
|
||||
* Definitions and wrapper functions for kernel decompressor
|
||||
*
|
||||
* (C) 2017 Helge Deller <deller@gmx.de>
|
||||
*/
|
||||
|
||||
#include <linux/uaccess.h>
|
||||
#include <asm/unaligned.h>
|
||||
#include <asm/page.h>
|
||||
#include "sizes.h"
|
||||
|
||||
/*
|
||||
* gzip declarations
|
||||
*/
|
||||
#define STATIC static
|
||||
|
||||
#undef memmove
|
||||
#define memmove memmove
|
||||
#define memzero(s, n) memset((s), 0, (n))
|
||||
|
||||
#define malloc malloc_gzip
|
||||
#define free free_gzip
|
||||
|
||||
/* Symbols defined by linker scripts */
|
||||
extern char input_data[];
|
||||
extern int input_len;
|
||||
extern __le32 output_len; /* at unaligned address, little-endian */
|
||||
extern char _text, _end;
|
||||
extern char _bss, _ebss;
|
||||
extern char _startcode_end;
|
||||
extern void startup_continue(void *entry, unsigned long cmdline,
|
||||
unsigned long rd_start, unsigned long rd_end) __noreturn;
|
||||
|
||||
void error(char *m) __noreturn;
|
||||
|
||||
static unsigned long free_mem_ptr;
|
||||
static unsigned long free_mem_end_ptr;
|
||||
|
||||
#ifdef CONFIG_KERNEL_GZIP
|
||||
#include "../../../../lib/decompress_inflate.c"
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_KERNEL_BZIP2
|
||||
#include "../../../../lib/decompress_bunzip2.c"
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_KERNEL_LZ4
|
||||
#include "../../../../lib/decompress_unlz4.c"
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_KERNEL_LZMA
|
||||
#include "../../../../lib/decompress_unlzma.c"
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_KERNEL_LZO
|
||||
#include "../../../../lib/decompress_unlzo.c"
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_KERNEL_XZ
|
||||
#include "../../../../lib/decompress_unxz.c"
|
||||
#endif
|
||||
|
||||
void *memmove(void *dest, const void *src, size_t n)
|
||||
{
|
||||
const char *s = src;
|
||||
char *d = dest;
|
||||
|
||||
if (d <= s) {
|
||||
while (n--)
|
||||
*d++ = *s++;
|
||||
} else {
|
||||
d += n;
|
||||
s += n;
|
||||
while (n--)
|
||||
*--d = *--s;
|
||||
}
|
||||
return dest;
|
||||
}
|
||||
|
||||
void *memset(void *s, int c, size_t count)
|
||||
{
|
||||
char *xs = (char *)s;
|
||||
|
||||
while (count--)
|
||||
*xs++ = c;
|
||||
return s;
|
||||
}
|
||||
|
||||
void *memcpy(void *d, const void *s, size_t len)
|
||||
{
|
||||
char *dest = (char *)d;
|
||||
const char *source = (const char *)s;
|
||||
|
||||
while (len--)
|
||||
*dest++ = *source++;
|
||||
return d;
|
||||
}
|
||||
|
||||
size_t strlen(const char *s)
|
||||
{
|
||||
const char *sc;
|
||||
|
||||
for (sc = s; *sc != '\0'; ++sc)
|
||||
;
|
||||
return sc - s;
|
||||
}
|
||||
|
||||
char *strchr(const char *s, int c)
|
||||
{
|
||||
while (*s) {
|
||||
if (*s == (char)c)
|
||||
return (char *)s;
|
||||
++s;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int puts(const char *s)
|
||||
{
|
||||
const char *nuline = s;
|
||||
|
||||
while ((nuline = strchr(s, '\n')) != NULL) {
|
||||
if (nuline != s)
|
||||
pdc_iodc_print(s, nuline - s);
|
||||
pdc_iodc_print("\r\n", 2);
|
||||
s = nuline + 1;
|
||||
}
|
||||
if (*s != '\0')
|
||||
pdc_iodc_print(s, strlen(s));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int putchar(int c)
|
||||
{
|
||||
char buf[2];
|
||||
|
||||
buf[0] = c;
|
||||
buf[1] = '\0';
|
||||
puts(buf);
|
||||
return c;
|
||||
}
|
||||
|
||||
void __noreturn error(char *x)
|
||||
{
|
||||
puts("\n\n");
|
||||
puts(x);
|
||||
puts("\n\n -- System halted");
|
||||
while (1) /* wait forever */
|
||||
;
|
||||
}
|
||||
|
||||
static int print_hex(unsigned long num)
|
||||
{
|
||||
const char hex[] = "0123456789abcdef";
|
||||
char str[40];
|
||||
int i = sizeof(str)-1;
|
||||
|
||||
str[i--] = '\0';
|
||||
do {
|
||||
str[i--] = hex[num & 0x0f];
|
||||
num >>= 4;
|
||||
} while (num);
|
||||
|
||||
str[i--] = 'x';
|
||||
str[i] = '0';
|
||||
puts(&str[i]);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int printf(const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
int i = 0;
|
||||
|
||||
va_start(args, fmt);
|
||||
|
||||
while (fmt[i]) {
|
||||
if (fmt[i] != '%') {
|
||||
put:
|
||||
putchar(fmt[i++]);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (fmt[++i] == '%')
|
||||
goto put;
|
||||
++i;
|
||||
print_hex(va_arg(args, unsigned long));
|
||||
}
|
||||
|
||||
va_end(args);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* helper functions for libgcc */
|
||||
void abort(void)
|
||||
{
|
||||
error("aborted.");
|
||||
}
|
||||
|
||||
#undef malloc
|
||||
void *malloc(size_t size)
|
||||
{
|
||||
return malloc_gzip(size);
|
||||
}
|
||||
|
||||
#undef free
|
||||
void free(void *ptr)
|
||||
{
|
||||
return free_gzip(ptr);
|
||||
}
|
||||
|
||||
|
||||
static void flush_data_cache(char *start, unsigned long length)
|
||||
{
|
||||
char *end = start + length;
|
||||
|
||||
do {
|
||||
asm volatile("fdc 0(%0)" : : "r" (start));
|
||||
asm volatile("fic 0(%%sr0,%0)" : : "r" (start));
|
||||
start += 16;
|
||||
} while (start < end);
|
||||
asm volatile("fdc 0(%0)" : : "r" (end));
|
||||
|
||||
asm ("sync");
|
||||
}
|
||||
|
||||
unsigned long decompress_kernel(unsigned int started_wide,
|
||||
unsigned int command_line,
|
||||
const unsigned int rd_start,
|
||||
const unsigned int rd_end)
|
||||
{
|
||||
char *output;
|
||||
unsigned long len, len_all;
|
||||
|
||||
#ifdef CONFIG_64BIT
|
||||
parisc_narrow_firmware = 0;
|
||||
#endif
|
||||
|
||||
set_firmware_width_unlocked();
|
||||
|
||||
putchar('U'); /* if you get this p and no more, string storage */
|
||||
/* in $GLOBAL$ is wrong or %dp is wrong */
|
||||
puts("ncompressing ...\n");
|
||||
|
||||
output = (char *) KERNEL_BINARY_TEXT_START;
|
||||
len_all = __pa(SZ_end) - __pa(SZparisc_kernel_start);
|
||||
|
||||
if ((unsigned long) &_startcode_end > (unsigned long) output)
|
||||
error("Bootcode overlaps kernel code");
|
||||
|
||||
len = get_unaligned_le32(&output_len);
|
||||
if (len > len_all)
|
||||
error("Output len too big.");
|
||||
else
|
||||
memset(&output[len], 0, len_all - len);
|
||||
|
||||
/*
|
||||
* Initialize free_mem_ptr and free_mem_end_ptr.
|
||||
*/
|
||||
free_mem_ptr = (unsigned long) &_ebss;
|
||||
free_mem_ptr += 2*1024*1024; /* leave 2 MB for stack */
|
||||
|
||||
/* Limit memory for bootoader to 1GB */
|
||||
#define ARTIFICIAL_LIMIT (1*1024*1024*1024)
|
||||
free_mem_end_ptr = PAGE0->imm_max_mem;
|
||||
if (free_mem_end_ptr > ARTIFICIAL_LIMIT)
|
||||
free_mem_end_ptr = ARTIFICIAL_LIMIT;
|
||||
|
||||
#ifdef CONFIG_BLK_DEV_INITRD
|
||||
/* if we have ramdisk this is at end of memory */
|
||||
if (rd_start && rd_start < free_mem_end_ptr)
|
||||
free_mem_end_ptr = rd_start;
|
||||
#endif
|
||||
|
||||
#ifdef DEBUG
|
||||
printf("startcode_end = %x\n", &_startcode_end);
|
||||
printf("commandline = %x\n", command_line);
|
||||
printf("rd_start = %x\n", rd_start);
|
||||
printf("rd_end = %x\n", rd_end);
|
||||
|
||||
printf("free_ptr = %x\n", free_mem_ptr);
|
||||
printf("free_ptr_end = %x\n", free_mem_end_ptr);
|
||||
|
||||
printf("input_data = %x\n", input_data);
|
||||
printf("input_len = %x\n", input_len);
|
||||
printf("output = %x\n", output);
|
||||
printf("output_len = %x\n", len);
|
||||
printf("output_max = %x\n", len_all);
|
||||
#endif
|
||||
|
||||
__decompress(input_data, input_len, NULL, NULL,
|
||||
output, 0, NULL, error);
|
||||
|
||||
flush_data_cache(output, len);
|
||||
|
||||
printf("Booting kernel ...\n\n");
|
||||
|
||||
return (unsigned long) output;
|
||||
}
|
||||
101
arch/parisc/boot/compressed/vmlinux.lds.S
Normal file
101
arch/parisc/boot/compressed/vmlinux.lds.S
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
#include <asm-generic/vmlinux.lds.h>
|
||||
#include <asm/page.h>
|
||||
#include "sizes.h"
|
||||
|
||||
#ifndef CONFIG_64BIT
|
||||
OUTPUT_FORMAT("elf32-hppa-linux")
|
||||
OUTPUT_ARCH(hppa)
|
||||
#else
|
||||
OUTPUT_FORMAT("elf64-hppa-linux")
|
||||
OUTPUT_ARCH(hppa:hppa2.0w)
|
||||
#endif
|
||||
|
||||
ENTRY(startup)
|
||||
|
||||
SECTIONS
|
||||
{
|
||||
/* palo loads at 0x60000 */
|
||||
/* loaded kernel will move to 0x10000 */
|
||||
. = 0xe0000; /* should not overwrite palo code */
|
||||
|
||||
.head.text : {
|
||||
_head = . ;
|
||||
HEAD_TEXT
|
||||
_ehead = . ;
|
||||
}
|
||||
|
||||
/* keep __gp below 0x1000000 */
|
||||
#ifdef CONFIG_64BIT
|
||||
. = ALIGN(16);
|
||||
/* Linkage tables */
|
||||
.opd : {
|
||||
*(.opd)
|
||||
} PROVIDE (__gp = .);
|
||||
.plt : {
|
||||
*(.plt)
|
||||
}
|
||||
.dlt : {
|
||||
*(.dlt)
|
||||
}
|
||||
#endif
|
||||
_startcode_end = .;
|
||||
|
||||
/* bootloader code and data starts behind area of extracted kernel */
|
||||
. = (SZ_end - SZparisc_kernel_start + KERNEL_BINARY_TEXT_START);
|
||||
|
||||
/* align on next page boundary */
|
||||
. = ALIGN(4096);
|
||||
.text : {
|
||||
_text = .; /* Text */
|
||||
*(.text)
|
||||
*(.text.*)
|
||||
_etext = . ;
|
||||
}
|
||||
. = ALIGN(8);
|
||||
.data : {
|
||||
_data = . ;
|
||||
*(.data)
|
||||
*(.data.*)
|
||||
_edata = . ;
|
||||
}
|
||||
. = ALIGN(8);
|
||||
.rodata : {
|
||||
_rodata = . ;
|
||||
*(.rodata) /* read-only data */
|
||||
*(.rodata.*)
|
||||
_erodata = . ;
|
||||
}
|
||||
. = ALIGN(8);
|
||||
.rodata.compressed : {
|
||||
*(.rodata.compressed)
|
||||
}
|
||||
. = ALIGN(8);
|
||||
.bss : {
|
||||
_bss = . ;
|
||||
*(.bss)
|
||||
*(.bss.*)
|
||||
*(COMMON)
|
||||
. = ALIGN(4096);
|
||||
_ebss = .;
|
||||
}
|
||||
|
||||
STABS_DEBUG
|
||||
.note 0 : { *(.note) }
|
||||
|
||||
/* Sections to be discarded */
|
||||
DISCARDS
|
||||
/DISCARD/ : {
|
||||
#ifdef CONFIG_64BIT
|
||||
/* temporary hack until binutils is fixed to not emit these
|
||||
* for static binaries
|
||||
*/
|
||||
*(.PARISC.unwind) /* no unwind data */
|
||||
*(.interp)
|
||||
*(.dynsym)
|
||||
*(.dynstr)
|
||||
*(.dynamic)
|
||||
*(.hash)
|
||||
*(.gnu.hash)
|
||||
#endif
|
||||
}
|
||||
}
|
||||
10
arch/parisc/boot/compressed/vmlinux.scr
Normal file
10
arch/parisc/boot/compressed/vmlinux.scr
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
SECTIONS
|
||||
{
|
||||
.rodata.compressed : {
|
||||
input_len = .;
|
||||
LONG(input_data_end - input_data) input_data = .;
|
||||
*(.data)
|
||||
output_len = . - 4; /* can be at unaligned address */
|
||||
input_data_end = .;
|
||||
}
|
||||
}
|
||||
65
arch/parisc/boot/install.sh
Normal file
65
arch/parisc/boot/install.sh
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
#!/bin/sh
|
||||
#
|
||||
# arch/parisc/install.sh, derived from arch/i386/boot/install.sh
|
||||
#
|
||||
# This file is subject to the terms and conditions of the GNU General Public
|
||||
# License. See the file "COPYING" in the main directory of this archive
|
||||
# for more details.
|
||||
#
|
||||
# Copyright (C) 1995 by Linus Torvalds
|
||||
#
|
||||
# Adapted from code in arch/i386/boot/Makefile by H. Peter Anvin
|
||||
#
|
||||
# "make install" script for i386 architecture
|
||||
#
|
||||
# Arguments:
|
||||
# $1 - kernel version
|
||||
# $2 - kernel image file
|
||||
# $3 - kernel map file
|
||||
# $4 - default install path (blank if root directory)
|
||||
#
|
||||
|
||||
verify () {
|
||||
if [ ! -f "$1" ]; then
|
||||
echo "" 1>&2
|
||||
echo " *** Missing file: $1" 1>&2
|
||||
echo ' *** You need to run "make" before "make install".' 1>&2
|
||||
echo "" 1>&2
|
||||
exit 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Make sure the files actually exist
|
||||
|
||||
verify "$2"
|
||||
verify "$3"
|
||||
|
||||
# User may have a custom install script
|
||||
|
||||
if [ -n "${INSTALLKERNEL}" ]; then
|
||||
if [ -x ~/bin/${INSTALLKERNEL} ]; then exec ~/bin/${INSTALLKERNEL} "$@"; fi
|
||||
if [ -x /sbin/${INSTALLKERNEL} ]; then exec /sbin/${INSTALLKERNEL} "$@"; fi
|
||||
fi
|
||||
|
||||
# Default install
|
||||
|
||||
if [ "$(basename $2)" = "zImage" ]; then
|
||||
# Compressed install
|
||||
echo "Installing compressed kernel"
|
||||
base=vmlinuz
|
||||
else
|
||||
# Normal install
|
||||
echo "Installing normal kernel"
|
||||
base=vmlinux
|
||||
fi
|
||||
|
||||
if [ -f $4/$base-$1 ]; then
|
||||
mv $4/$base-$1 $4/$base-$1.old
|
||||
fi
|
||||
cat $2 > $4/$base-$1
|
||||
|
||||
# Install system map file
|
||||
if [ -f $4/System.map-$1 ]; then
|
||||
mv $4/System.map-$1 $4/System.map-$1.old
|
||||
fi
|
||||
cp $3 $4/System.map-$1
|
||||
|
|
@ -63,6 +63,9 @@ static inline void switch_mm(struct mm_struct *prev,
|
|||
{
|
||||
unsigned long flags;
|
||||
|
||||
if (prev == next)
|
||||
return;
|
||||
|
||||
local_irq_save(flags);
|
||||
switch_mm_irqs_off(prev, next, tsk);
|
||||
local_irq_restore(flags);
|
||||
|
|
|
|||
|
|
@ -116,11 +116,15 @@ extern int npmem_ranges;
|
|||
/* This governs the relationship between virtual and physical addresses.
|
||||
* If you alter it, make sure to take care of our various fixed mapping
|
||||
* segments in fixmap.h */
|
||||
#if defined(BOOTLOADER)
|
||||
#define __PAGE_OFFSET (0) /* bootloader uses physical addresses */
|
||||
#else
|
||||
#ifdef CONFIG_64BIT
|
||||
#define __PAGE_OFFSET (0x40000000) /* 1GB */
|
||||
#else
|
||||
#define __PAGE_OFFSET (0x10000000) /* 256MB */
|
||||
#endif
|
||||
#endif /* BOOTLOADER */
|
||||
|
||||
#define PAGE_OFFSET ((unsigned long)__PAGE_OFFSET)
|
||||
|
||||
|
|
|
|||
|
|
@ -5,6 +5,8 @@
|
|||
|
||||
#if !defined(__ASSEMBLY__)
|
||||
|
||||
extern int parisc_narrow_firmware;
|
||||
|
||||
extern int pdc_type;
|
||||
extern unsigned long parisc_cell_num; /* cell number the CPU runs on (PAT) */
|
||||
extern unsigned long parisc_cell_loc; /* cell location of CPU (PAT) */
|
||||
|
|
|
|||
|
|
@ -223,6 +223,18 @@ struct pdc_pat_mem_retinfo { /* PDC_PAT_MEM/PDC_PAT_MEM_PD_INFO (return info) */
|
|||
unsigned long clear_time; /* last PDT clear time (since Jan 1970) */
|
||||
};
|
||||
|
||||
struct pdc_pat_mem_cell_pdt_retinfo { /* PDC_PAT_MEM/PDC_PAT_MEM_CELL_INFO */
|
||||
u64 reserved:32;
|
||||
u64 cs:1; /* clear status: cleared since the last call? */
|
||||
u64 current_pdt_entries:15;
|
||||
u64 ic:1; /* interleaving had to be changed ? */
|
||||
u64 max_pdt_entries:15;
|
||||
unsigned long good_mem;
|
||||
unsigned long first_dbe_loc; /* first location of double bit error */
|
||||
unsigned long clear_time; /* last PDT clear time (since Jan 1970) */
|
||||
};
|
||||
|
||||
|
||||
struct pdc_pat_mem_read_pd_retinfo { /* PDC_PAT_MEM/PDC_PAT_MEM_PD_READ */
|
||||
unsigned long actual_count_bytes;
|
||||
unsigned long pdt_entries;
|
||||
|
|
@ -325,6 +337,8 @@ extern int pdc_pat_io_pci_cfg_read(unsigned long pci_addr, int pci_size, u32 *va
|
|||
extern int pdc_pat_io_pci_cfg_write(unsigned long pci_addr, int pci_size, u32 val);
|
||||
|
||||
extern int pdc_pat_mem_pdt_info(struct pdc_pat_mem_retinfo *rinfo);
|
||||
extern int pdc_pat_mem_pdt_cell_info(struct pdc_pat_mem_cell_pdt_retinfo *rinfo,
|
||||
unsigned long cell);
|
||||
extern int pdc_pat_mem_read_cell_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
|
||||
unsigned long *pdt_entries_ptr, unsigned long max_entries);
|
||||
extern int pdc_pat_mem_read_pd_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
|
||||
|
|
|
|||
|
|
@ -40,9 +40,6 @@
|
|||
#define MADV_SEQUENTIAL 2 /* expect sequential page references */
|
||||
#define MADV_WILLNEED 3 /* will need these pages */
|
||||
#define MADV_DONTNEED 4 /* don't need these pages */
|
||||
#define MADV_SPACEAVAIL 5 /* insure that resources are reserved */
|
||||
#define MADV_VPS_PURGE 6 /* Purge pages from VM page cache */
|
||||
#define MADV_VPS_INHERIT 7 /* Inherit parents page size */
|
||||
|
||||
/* common/generic parameters */
|
||||
#define MADV_FREE 8 /* free pages only if memory pressure */
|
||||
|
|
@ -60,6 +57,9 @@
|
|||
overrides the coredump filter bits */
|
||||
#define MADV_DODUMP 70 /* Clear the MADV_NODUMP flag */
|
||||
|
||||
#define MADV_HWPOISON 100 /* poison a page for testing */
|
||||
#define MADV_SOFT_OFFLINE 101 /* soft offline page for testing */
|
||||
|
||||
/* compatibility flags */
|
||||
#define MAP_FILE 0
|
||||
#define MAP_VARIABLE 0
|
||||
|
|
|
|||
|
|
@ -69,7 +69,15 @@
|
|||
#include <asm/pdcpat.h>
|
||||
#include <asm/processor.h> /* for boot_cpu_data */
|
||||
|
||||
#if defined(BOOTLOADER)
|
||||
# undef spin_lock_irqsave
|
||||
# define spin_lock_irqsave(a, b) { b = 1; }
|
||||
# undef spin_unlock_irqrestore
|
||||
# define spin_unlock_irqrestore(a, b)
|
||||
#else
|
||||
static DEFINE_SPINLOCK(pdc_lock);
|
||||
#endif
|
||||
|
||||
extern unsigned long pdc_result[NUM_PDC_RESULT];
|
||||
extern unsigned long pdc_result2[NUM_PDC_RESULT];
|
||||
|
||||
|
|
@ -142,8 +150,8 @@ static void convert_to_wide(unsigned long *addr)
|
|||
int i;
|
||||
unsigned int *p = (unsigned int *)addr;
|
||||
|
||||
if(unlikely(parisc_narrow_firmware)) {
|
||||
for(i = 31; i >= 0; --i)
|
||||
if (unlikely(parisc_narrow_firmware)) {
|
||||
for (i = (NUM_PDC_RESULT-1); i >= 0; --i)
|
||||
addr[i] = p[i];
|
||||
}
|
||||
#endif
|
||||
|
|
@ -186,6 +194,8 @@ void set_firmware_width(void)
|
|||
}
|
||||
#endif /*CONFIG_64BIT*/
|
||||
|
||||
|
||||
#if !defined(BOOTLOADER)
|
||||
/**
|
||||
* pdc_emergency_unlock - Unlock the linux pdc lock
|
||||
*
|
||||
|
|
@ -979,16 +989,22 @@ int pdc_mem_pdt_read_entries(struct pdc_mem_read_pdt *pret,
|
|||
|
||||
spin_lock_irqsave(&pdc_lock, flags);
|
||||
retval = mem_pdc_call(PDC_MEM, PDC_MEM_READ_PDT, __pa(pdc_result),
|
||||
__pa(pdc_result2));
|
||||
__pa(pdt_entries_ptr));
|
||||
if (retval == PDC_OK) {
|
||||
convert_to_wide(pdc_result);
|
||||
memcpy(pret, pdc_result, sizeof(*pret));
|
||||
convert_to_wide(pdc_result2);
|
||||
memcpy(pdt_entries_ptr, pdc_result2,
|
||||
pret->pdt_entries * sizeof(*pdt_entries_ptr));
|
||||
}
|
||||
spin_unlock_irqrestore(&pdc_lock, flags);
|
||||
|
||||
#ifdef CONFIG_64BIT
|
||||
/*
|
||||
* 64-bit kernels should not call this PDT function in narrow mode.
|
||||
* The pdt_entries_ptr array above will now contain 32-bit values
|
||||
*/
|
||||
if (WARN_ON_ONCE((retval == PDC_OK) && parisc_narrow_firmware))
|
||||
return PDC_ERROR;
|
||||
#endif
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
|
@ -1143,6 +1159,8 @@ void pdc_io_reset_devices(void)
|
|||
spin_unlock_irqrestore(&pdc_lock, flags);
|
||||
}
|
||||
|
||||
#endif /* defined(BOOTLOADER) */
|
||||
|
||||
/* locked by pdc_console_lock */
|
||||
static int __attribute__((aligned(8))) iodc_retbuf[32];
|
||||
static char __attribute__((aligned(64))) iodc_dbuf[4096];
|
||||
|
|
@ -1187,6 +1205,7 @@ print:
|
|||
return i;
|
||||
}
|
||||
|
||||
#if !defined(BOOTLOADER)
|
||||
/**
|
||||
* pdc_iodc_getc - Read a character (non-blocking) from the PDC console.
|
||||
*
|
||||
|
|
@ -1439,6 +1458,29 @@ int pdc_pat_mem_pdt_info(struct pdc_pat_mem_retinfo *rinfo)
|
|||
return retval;
|
||||
}
|
||||
|
||||
/**
|
||||
* pdc_pat_mem_pdt_cell_info - Retrieve information about page deallocation
|
||||
* table of a cell
|
||||
* @rinfo: memory pdt information
|
||||
* @cell: cell number
|
||||
*
|
||||
*/
|
||||
int pdc_pat_mem_pdt_cell_info(struct pdc_pat_mem_cell_pdt_retinfo *rinfo,
|
||||
unsigned long cell)
|
||||
{
|
||||
int retval;
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&pdc_lock, flags);
|
||||
retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_CELL_INFO,
|
||||
__pa(&pdc_result), cell);
|
||||
if (retval == PDC_OK)
|
||||
memcpy(rinfo, &pdc_result, sizeof(*rinfo));
|
||||
spin_unlock_irqrestore(&pdc_lock, flags);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
/**
|
||||
* pdc_pat_mem_read_cell_pdt - Read PDT entries from (old) PAT firmware
|
||||
* @pret: array of PDT entries
|
||||
|
|
@ -1455,14 +1497,14 @@ int pdc_pat_mem_read_cell_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
|
|||
spin_lock_irqsave(&pdc_lock, flags);
|
||||
/* PDC_PAT_MEM_CELL_READ is available on early PAT machines only */
|
||||
retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_CELL_READ,
|
||||
__pa(&pdc_result), parisc_cell_num, __pa(&pdc_result2));
|
||||
__pa(&pdc_result), parisc_cell_num,
|
||||
__pa(pdt_entries_ptr));
|
||||
|
||||
if (retval == PDC_OK) {
|
||||
/* build up return value as for PDC_PAT_MEM_PD_READ */
|
||||
entries = min(pdc_result[0], max_entries);
|
||||
pret->pdt_entries = entries;
|
||||
pret->actual_count_bytes = entries * sizeof(unsigned long);
|
||||
memcpy(pdt_entries_ptr, &pdc_result2, pret->actual_count_bytes);
|
||||
}
|
||||
|
||||
spin_unlock_irqrestore(&pdc_lock, flags);
|
||||
|
|
@ -1474,6 +1516,8 @@ int pdc_pat_mem_read_cell_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
|
|||
* pdc_pat_mem_read_pd_pdt - Read PDT entries from (newer) PAT firmware
|
||||
* @pret: array of PDT entries
|
||||
* @pdt_entries_ptr: ptr to hold number of PDT entries
|
||||
* @count: number of bytes to read
|
||||
* @offset: offset to start (in bytes)
|
||||
*
|
||||
*/
|
||||
int pdc_pat_mem_read_pd_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
|
||||
|
|
@ -1524,6 +1568,7 @@ int pdc_pat_mem_get_dimm_phys_location(
|
|||
return retval;
|
||||
}
|
||||
#endif /* CONFIG_64BIT */
|
||||
#endif /* defined(BOOTLOADER) */
|
||||
|
||||
|
||||
/***************** 32-bit real-mode calls ***********/
|
||||
|
|
@ -1633,4 +1678,3 @@ long real64_call(unsigned long fn, ...)
|
|||
}
|
||||
|
||||
#endif /* CONFIG_64BIT */
|
||||
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ static unsigned long pcxl_used_bytes __read_mostly = 0;
|
|||
static unsigned long pcxl_used_pages __read_mostly = 0;
|
||||
|
||||
extern unsigned long pcxl_dma_start; /* Start of pcxl dma mapping area */
|
||||
static spinlock_t pcxl_res_lock;
|
||||
static DEFINE_SPINLOCK(pcxl_res_lock);
|
||||
static char *pcxl_res_map;
|
||||
static int pcxl_res_hint;
|
||||
static int pcxl_res_size;
|
||||
|
|
@ -390,7 +390,6 @@ pcxl_dma_init(void)
|
|||
if (pcxl_dma_start == 0)
|
||||
return 0;
|
||||
|
||||
spin_lock_init(&pcxl_res_lock);
|
||||
pcxl_res_size = PCXL_DMA_MAP_SIZE >> (PAGE_SHIFT + 3);
|
||||
pcxl_res_hint = 0;
|
||||
pcxl_res_map = (char *)__get_free_pages(GFP_KERNEL,
|
||||
|
|
|
|||
|
|
@ -1,19 +1,20 @@
|
|||
/*
|
||||
* Page Deallocation Table (PDT) support
|
||||
*
|
||||
* The Page Deallocation Table (PDT) holds a table with pointers to bad
|
||||
* memory (broken RAM modules) which is maintained by firmware.
|
||||
* The Page Deallocation Table (PDT) is maintained by firmware and holds a
|
||||
* list of memory addresses in which memory errors were detected.
|
||||
* The list contains both single-bit (correctable) and double-bit
|
||||
* (uncorrectable) errors.
|
||||
*
|
||||
* Copyright 2017 by Helge Deller <deller@gmx.de>
|
||||
*
|
||||
* TODO:
|
||||
* - check regularily for new bad memory
|
||||
* - add userspace interface with procfs or sysfs
|
||||
* - increase number of PDT entries dynamically
|
||||
* possible future enhancements:
|
||||
* - add userspace interface via procfs or sysfs to clear PDT
|
||||
*/
|
||||
|
||||
#include <linux/memblock.h>
|
||||
#include <linux/seq_file.h>
|
||||
#include <linux/kthread.h>
|
||||
|
||||
#include <asm/pdc.h>
|
||||
#include <asm/pdcpat.h>
|
||||
|
|
@ -24,11 +25,16 @@ enum pdt_access_type {
|
|||
PDT_NONE,
|
||||
PDT_PDC,
|
||||
PDT_PAT_NEW,
|
||||
PDT_PAT_OLD
|
||||
PDT_PAT_CELL
|
||||
};
|
||||
|
||||
static enum pdt_access_type pdt_type;
|
||||
|
||||
/* PDT poll interval: 1 minute if errors, 5 minutes if everything OK. */
|
||||
#define PDT_POLL_INTERVAL_DEFAULT (5*60*HZ)
|
||||
#define PDT_POLL_INTERVAL_SHORT (1*60*HZ)
|
||||
static unsigned long pdt_poll_interval = PDT_POLL_INTERVAL_DEFAULT;
|
||||
|
||||
/* global PDT status information */
|
||||
static struct pdc_mem_retinfo pdt_status;
|
||||
|
||||
|
|
@ -36,6 +42,21 @@ static struct pdc_mem_retinfo pdt_status;
|
|||
#define MAX_PDT_ENTRIES (MAX_PDT_TABLE_SIZE / sizeof(unsigned long))
|
||||
static unsigned long pdt_entry[MAX_PDT_ENTRIES] __page_aligned_bss;
|
||||
|
||||
/*
|
||||
* Constants for the pdt_entry format:
|
||||
* A pdt_entry holds the physical address in bits 0-57, bits 58-61 are
|
||||
* reserved, bit 62 is the perm bit and bit 63 is the error_type bit.
|
||||
* The perm bit indicates whether the error have been verified as a permanent
|
||||
* error (value of 1) or has not been verified, and may be transient (value
|
||||
* of 0). The error_type bit indicates whether the error is a single bit error
|
||||
* (value of 1) or a multiple bit error.
|
||||
* On non-PAT machines phys_addr is encoded in bits 0-59 and error_type in bit
|
||||
* 63. Those machines don't provide the perm bit.
|
||||
*/
|
||||
|
||||
#define PDT_ADDR_PHYS_MASK (pdt_type != PDT_PDC ? ~0x3f : ~0x0f)
|
||||
#define PDT_ADDR_PERM_ERR (pdt_type != PDT_PDC ? 2UL : 0UL)
|
||||
#define PDT_ADDR_SINGLE_ERR 1UL
|
||||
|
||||
/* report PDT entries via /proc/meminfo */
|
||||
void arch_report_meminfo(struct seq_file *m)
|
||||
|
|
@ -49,6 +70,68 @@ void arch_report_meminfo(struct seq_file *m)
|
|||
pdt_status.pdt_entries);
|
||||
}
|
||||
|
||||
static int get_info_pat_new(void)
|
||||
{
|
||||
struct pdc_pat_mem_retinfo pat_rinfo;
|
||||
int ret;
|
||||
|
||||
/* newer PAT machines like C8000 report info for all cells */
|
||||
if (is_pdc_pat())
|
||||
ret = pdc_pat_mem_pdt_info(&pat_rinfo);
|
||||
else
|
||||
return PDC_BAD_PROC;
|
||||
|
||||
pdt_status.pdt_size = pat_rinfo.max_pdt_entries;
|
||||
pdt_status.pdt_entries = pat_rinfo.current_pdt_entries;
|
||||
pdt_status.pdt_status = 0;
|
||||
pdt_status.first_dbe_loc = pat_rinfo.first_dbe_loc;
|
||||
pdt_status.good_mem = pat_rinfo.good_mem;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int get_info_pat_cell(void)
|
||||
{
|
||||
struct pdc_pat_mem_cell_pdt_retinfo cell_rinfo;
|
||||
int ret;
|
||||
|
||||
/* older PAT machines like rp5470 report cell info only */
|
||||
if (is_pdc_pat())
|
||||
ret = pdc_pat_mem_pdt_cell_info(&cell_rinfo, parisc_cell_num);
|
||||
else
|
||||
return PDC_BAD_PROC;
|
||||
|
||||
pdt_status.pdt_size = cell_rinfo.max_pdt_entries;
|
||||
pdt_status.pdt_entries = cell_rinfo.current_pdt_entries;
|
||||
pdt_status.pdt_status = 0;
|
||||
pdt_status.first_dbe_loc = cell_rinfo.first_dbe_loc;
|
||||
pdt_status.good_mem = cell_rinfo.good_mem;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void report_mem_err(unsigned long pde)
|
||||
{
|
||||
struct pdc_pat_mem_phys_mem_location loc;
|
||||
unsigned long addr;
|
||||
char dimm_txt[32];
|
||||
|
||||
addr = pde & PDT_ADDR_PHYS_MASK;
|
||||
|
||||
/* show DIMM slot description on PAT machines */
|
||||
if (is_pdc_pat()) {
|
||||
pdc_pat_mem_get_dimm_phys_location(&loc, addr);
|
||||
sprintf(dimm_txt, "DIMM slot %02x, ", loc.dimm_slot);
|
||||
} else
|
||||
dimm_txt[0] = 0;
|
||||
|
||||
pr_warn("PDT: BAD MEMORY at 0x%08lx, %s%s%s-bit error.\n",
|
||||
addr, dimm_txt,
|
||||
pde & PDT_ADDR_PERM_ERR ? "permanent ":"",
|
||||
pde & PDT_ADDR_SINGLE_ERR ? "single":"multi");
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* pdc_pdt_init()
|
||||
*
|
||||
|
|
@ -63,18 +146,17 @@ void __init pdc_pdt_init(void)
|
|||
unsigned long entries;
|
||||
struct pdc_mem_read_pdt pdt_read_ret;
|
||||
|
||||
if (is_pdc_pat()) {
|
||||
struct pdc_pat_mem_retinfo pat_rinfo;
|
||||
pdt_type = PDT_PAT_NEW;
|
||||
ret = get_info_pat_new();
|
||||
|
||||
pdt_type = PDT_PAT_NEW;
|
||||
ret = pdc_pat_mem_pdt_info(&pat_rinfo);
|
||||
pdt_status.pdt_size = pat_rinfo.max_pdt_entries;
|
||||
pdt_status.pdt_entries = pat_rinfo.current_pdt_entries;
|
||||
pdt_status.pdt_status = 0;
|
||||
pdt_status.first_dbe_loc = pat_rinfo.first_dbe_loc;
|
||||
pdt_status.good_mem = pat_rinfo.good_mem;
|
||||
} else {
|
||||
if (ret != PDC_OK) {
|
||||
pdt_type = PDT_PAT_CELL;
|
||||
ret = get_info_pat_cell();
|
||||
}
|
||||
|
||||
if (ret != PDC_OK) {
|
||||
pdt_type = PDT_PDC;
|
||||
/* non-PAT machines provide the standard PDC call */
|
||||
ret = pdc_mem_pdt_info(&pdt_status);
|
||||
}
|
||||
|
||||
|
|
@ -86,13 +168,17 @@ void __init pdc_pdt_init(void)
|
|||
}
|
||||
|
||||
entries = pdt_status.pdt_entries;
|
||||
WARN_ON(entries > MAX_PDT_ENTRIES);
|
||||
if (WARN_ON(entries > MAX_PDT_ENTRIES))
|
||||
entries = pdt_status.pdt_entries = MAX_PDT_ENTRIES;
|
||||
|
||||
pr_info("PDT: size %lu, entries %lu, status %lu, dbe_loc 0x%lx,"
|
||||
" good_mem %lu\n",
|
||||
pr_info("PDT: type %s, size %lu, entries %lu, status %lu, dbe_loc 0x%lx,"
|
||||
" good_mem %lu MB\n",
|
||||
pdt_type == PDT_PDC ? __stringify(PDT_PDC) :
|
||||
pdt_type == PDT_PAT_CELL ? __stringify(PDT_PAT_CELL)
|
||||
: __stringify(PDT_PAT_NEW),
|
||||
pdt_status.pdt_size, pdt_status.pdt_entries,
|
||||
pdt_status.pdt_status, pdt_status.first_dbe_loc,
|
||||
pdt_status.good_mem);
|
||||
pdt_status.good_mem / 1024 / 1024);
|
||||
|
||||
if (entries == 0) {
|
||||
pr_info("PDT: Firmware reports all memory OK.\n");
|
||||
|
|
@ -112,15 +198,12 @@ void __init pdc_pdt_init(void)
|
|||
#ifdef CONFIG_64BIT
|
||||
struct pdc_pat_mem_read_pd_retinfo pat_pret;
|
||||
|
||||
/* try old obsolete PAT firmware function first */
|
||||
pdt_type = PDT_PAT_OLD;
|
||||
ret = pdc_pat_mem_read_cell_pdt(&pat_pret, pdt_entry,
|
||||
MAX_PDT_ENTRIES);
|
||||
if (ret != PDC_OK) {
|
||||
pdt_type = PDT_PAT_NEW;
|
||||
if (pdt_type == PDT_PAT_CELL)
|
||||
ret = pdc_pat_mem_read_cell_pdt(&pat_pret, pdt_entry,
|
||||
MAX_PDT_ENTRIES);
|
||||
else
|
||||
ret = pdc_pat_mem_read_pd_pdt(&pat_pret, pdt_entry,
|
||||
MAX_PDT_TABLE_SIZE, 0);
|
||||
}
|
||||
#else
|
||||
ret = PDC_BAD_PROC;
|
||||
#endif
|
||||
|
|
@ -128,27 +211,142 @@ void __init pdc_pdt_init(void)
|
|||
|
||||
if (ret != PDC_OK) {
|
||||
pdt_type = PDT_NONE;
|
||||
pr_debug("PDT type %d, retval = %d\n", pdt_type, ret);
|
||||
pr_warn("PDT: Get PDT entries failed with %d\n", ret);
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < pdt_status.pdt_entries; i++) {
|
||||
struct pdc_pat_mem_phys_mem_location loc;
|
||||
|
||||
/* get DIMM slot number */
|
||||
loc.dimm_slot = 0xff;
|
||||
#ifdef CONFIG_64BIT
|
||||
pdc_pat_mem_get_dimm_phys_location(&loc, pdt_entry[i]);
|
||||
#endif
|
||||
|
||||
pr_warn("PDT: BAD PAGE #%d at 0x%08lx, "
|
||||
"DIMM slot %02x (error_type = %lu)\n",
|
||||
i,
|
||||
pdt_entry[i] & PAGE_MASK,
|
||||
loc.dimm_slot,
|
||||
pdt_entry[i] & 1);
|
||||
report_mem_err(pdt_entry[i]);
|
||||
|
||||
/* mark memory page bad */
|
||||
memblock_reserve(pdt_entry[i] & PAGE_MASK, PAGE_SIZE);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* This is the PDT kernel thread main loop.
|
||||
*/
|
||||
|
||||
static int pdt_mainloop(void *unused)
|
||||
{
|
||||
struct pdc_mem_read_pdt pdt_read_ret;
|
||||
struct pdc_pat_mem_read_pd_retinfo pat_pret __maybe_unused;
|
||||
unsigned long old_num_entries;
|
||||
unsigned long *bad_mem_ptr;
|
||||
int num, ret;
|
||||
|
||||
for (;;) {
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
|
||||
old_num_entries = pdt_status.pdt_entries;
|
||||
|
||||
schedule_timeout(pdt_poll_interval);
|
||||
if (kthread_should_stop())
|
||||
break;
|
||||
|
||||
/* Do we have new PDT entries? */
|
||||
switch (pdt_type) {
|
||||
case PDT_PAT_NEW:
|
||||
ret = get_info_pat_new();
|
||||
break;
|
||||
case PDT_PAT_CELL:
|
||||
ret = get_info_pat_cell();
|
||||
break;
|
||||
default:
|
||||
ret = pdc_mem_pdt_info(&pdt_status);
|
||||
break;
|
||||
}
|
||||
|
||||
if (ret != PDC_OK) {
|
||||
pr_warn("PDT: unexpected failure %d\n", ret);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* if no new PDT entries, just wait again */
|
||||
num = pdt_status.pdt_entries - old_num_entries;
|
||||
if (num <= 0)
|
||||
continue;
|
||||
|
||||
/* decrease poll interval in case we found memory errors */
|
||||
if (pdt_status.pdt_entries &&
|
||||
pdt_poll_interval == PDT_POLL_INTERVAL_DEFAULT)
|
||||
pdt_poll_interval = PDT_POLL_INTERVAL_SHORT;
|
||||
|
||||
/* limit entries to get */
|
||||
if (num > MAX_PDT_ENTRIES) {
|
||||
num = MAX_PDT_ENTRIES;
|
||||
pdt_status.pdt_entries = old_num_entries + num;
|
||||
}
|
||||
|
||||
/* get new entries */
|
||||
switch (pdt_type) {
|
||||
#ifdef CONFIG_64BIT
|
||||
case PDT_PAT_CELL:
|
||||
if (pdt_status.pdt_entries > MAX_PDT_ENTRIES) {
|
||||
pr_crit("PDT: too many entries.\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
ret = pdc_pat_mem_read_cell_pdt(&pat_pret, pdt_entry,
|
||||
MAX_PDT_ENTRIES);
|
||||
bad_mem_ptr = &pdt_entry[old_num_entries];
|
||||
break;
|
||||
case PDT_PAT_NEW:
|
||||
ret = pdc_pat_mem_read_pd_pdt(&pat_pret,
|
||||
pdt_entry,
|
||||
num * sizeof(unsigned long),
|
||||
old_num_entries * sizeof(unsigned long));
|
||||
bad_mem_ptr = &pdt_entry[0];
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
ret = pdc_mem_pdt_read_entries(&pdt_read_ret,
|
||||
pdt_entry);
|
||||
bad_mem_ptr = &pdt_entry[old_num_entries];
|
||||
break;
|
||||
}
|
||||
|
||||
/* report and mark memory broken */
|
||||
while (num--) {
|
||||
unsigned long pde = *bad_mem_ptr++;
|
||||
|
||||
report_mem_err(pde);
|
||||
|
||||
#ifdef CONFIG_MEMORY_FAILURE
|
||||
if ((pde & PDT_ADDR_PERM_ERR) ||
|
||||
((pde & PDT_ADDR_SINGLE_ERR) == 0))
|
||||
memory_failure(pde >> PAGE_SHIFT, 0, 0);
|
||||
else
|
||||
soft_offline_page(
|
||||
pfn_to_page(pde >> PAGE_SHIFT), 0);
|
||||
#else
|
||||
pr_crit("PDT: memory error at 0x%lx ignored.\n"
|
||||
"Rebuild kernel with CONFIG_MEMORY_FAILURE=y "
|
||||
"for real handling.\n",
|
||||
pde & PDT_ADDR_PHYS_MASK);
|
||||
#endif
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static int __init pdt_initcall(void)
|
||||
{
|
||||
struct task_struct *kpdtd_task;
|
||||
|
||||
if (pdt_type == PDT_NONE)
|
||||
return -ENODEV;
|
||||
|
||||
kpdtd_task = kthread_create(pdt_mainloop, NULL, "kpdtd");
|
||||
if (IS_ERR(kpdtd_task))
|
||||
return PTR_ERR(kpdtd_task);
|
||||
|
||||
wake_up_process(kpdtd_task);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
late_initcall(pdt_initcall);
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ struct rdr_tbl_ent {
|
|||
|
||||
static int perf_processor_interface __read_mostly = UNKNOWN_INTF;
|
||||
static int perf_enabled __read_mostly;
|
||||
static spinlock_t perf_lock;
|
||||
static DEFINE_SPINLOCK(perf_lock);
|
||||
struct parisc_device *cpu_device __read_mostly;
|
||||
|
||||
/* RDRs to write for PCX-W */
|
||||
|
|
@ -533,8 +533,6 @@ static int __init perf_init(void)
|
|||
/* Patch the images to match the system */
|
||||
perf_patch_images();
|
||||
|
||||
spin_lock_init(&perf_lock);
|
||||
|
||||
/* TODO: this only lets us access the first cpu.. what to do for SMP? */
|
||||
cpu_device = per_cpu(cpu_data, 0).dev;
|
||||
printk("Performance monitoring counters enabled for %s\n",
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@
|
|||
#include <linux/mm.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/seq_file.h>
|
||||
#include <linux/random.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/cpu.h>
|
||||
#include <asm/param.h>
|
||||
|
|
@ -89,7 +90,7 @@ init_percpu_prof(unsigned long cpunum)
|
|||
* (return 1). If so, initialize the chip and tell other partners in crime
|
||||
* they have work to do.
|
||||
*/
|
||||
static int processor_probe(struct parisc_device *dev)
|
||||
static int __init processor_probe(struct parisc_device *dev)
|
||||
{
|
||||
unsigned long txn_addr;
|
||||
unsigned long cpuid;
|
||||
|
|
@ -237,28 +238,45 @@ static int processor_probe(struct parisc_device *dev)
|
|||
*/
|
||||
void __init collect_boot_cpu_data(void)
|
||||
{
|
||||
unsigned long cr16_seed;
|
||||
|
||||
memset(&boot_cpu_data, 0, sizeof(boot_cpu_data));
|
||||
|
||||
cr16_seed = get_cycles();
|
||||
add_device_randomness(&cr16_seed, sizeof(cr16_seed));
|
||||
|
||||
boot_cpu_data.cpu_hz = 100 * PAGE0->mem_10msec; /* Hz of this PARISC */
|
||||
|
||||
/* get CPU-Model Information... */
|
||||
#define p ((unsigned long *)&boot_cpu_data.pdc.model)
|
||||
if (pdc_model_info(&boot_cpu_data.pdc.model) == PDC_OK)
|
||||
if (pdc_model_info(&boot_cpu_data.pdc.model) == PDC_OK) {
|
||||
printk(KERN_INFO
|
||||
"model %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
|
||||
p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8]);
|
||||
|
||||
add_device_randomness(&boot_cpu_data.pdc.model,
|
||||
sizeof(boot_cpu_data.pdc.model));
|
||||
}
|
||||
#undef p
|
||||
|
||||
if (pdc_model_versions(&boot_cpu_data.pdc.versions, 0) == PDC_OK)
|
||||
if (pdc_model_versions(&boot_cpu_data.pdc.versions, 0) == PDC_OK) {
|
||||
printk(KERN_INFO "vers %08lx\n",
|
||||
boot_cpu_data.pdc.versions);
|
||||
|
||||
if (pdc_model_cpuid(&boot_cpu_data.pdc.cpuid) == PDC_OK)
|
||||
add_device_randomness(&boot_cpu_data.pdc.versions,
|
||||
sizeof(boot_cpu_data.pdc.versions));
|
||||
}
|
||||
|
||||
if (pdc_model_cpuid(&boot_cpu_data.pdc.cpuid) == PDC_OK) {
|
||||
printk(KERN_INFO "CPUID vers %ld rev %ld (0x%08lx)\n",
|
||||
(boot_cpu_data.pdc.cpuid >> 5) & 127,
|
||||
boot_cpu_data.pdc.cpuid & 31,
|
||||
boot_cpu_data.pdc.cpuid);
|
||||
|
||||
add_device_randomness(&boot_cpu_data.pdc.cpuid,
|
||||
sizeof(boot_cpu_data.pdc.cpuid));
|
||||
}
|
||||
|
||||
if (pdc_model_capabilities(&boot_cpu_data.pdc.capabilities) == PDC_OK)
|
||||
printk(KERN_INFO "capabilities 0x%lx\n",
|
||||
boot_cpu_data.pdc.capabilities);
|
||||
|
|
@ -414,12 +432,12 @@ show_cpuinfo (struct seq_file *m, void *v)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static const struct parisc_device_id processor_tbl[] = {
|
||||
static const struct parisc_device_id processor_tbl[] __initconst = {
|
||||
{ HPHW_NPROC, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, SVERSION_ANY_ID },
|
||||
{ 0, }
|
||||
};
|
||||
|
||||
static struct parisc_driver cpu_driver = {
|
||||
static struct parisc_driver cpu_driver __refdata = {
|
||||
.name = "CPU",
|
||||
.id_table = processor_tbl,
|
||||
.probe = processor_probe
|
||||
|
|
|
|||
|
|
@ -162,6 +162,7 @@ ENDPROC_CFI(restore_control_regs)
|
|||
.text
|
||||
.align 128
|
||||
ENTRY_CFI(rfi_virt2real)
|
||||
#if !defined(BOOTLOADER)
|
||||
/* switch to real mode... */
|
||||
rsm PSW_SM_I,%r0
|
||||
load32 PA(rfi_v2r_1), %r1
|
||||
|
|
@ -191,6 +192,7 @@ ENTRY_CFI(rfi_virt2real)
|
|||
nop
|
||||
rfi_v2r_1:
|
||||
tophys_r1 %r2
|
||||
#endif /* defined(BOOTLOADER) */
|
||||
bv 0(%r2)
|
||||
nop
|
||||
ENDPROC_CFI(rfi_virt2real)
|
||||
|
|
@ -198,6 +200,7 @@ ENDPROC_CFI(rfi_virt2real)
|
|||
.text
|
||||
.align 128
|
||||
ENTRY_CFI(rfi_real2virt)
|
||||
#if !defined(BOOTLOADER)
|
||||
rsm PSW_SM_I,%r0
|
||||
load32 (rfi_r2v_1), %r1
|
||||
nop
|
||||
|
|
@ -226,6 +229,7 @@ ENTRY_CFI(rfi_real2virt)
|
|||
nop
|
||||
rfi_r2v_1:
|
||||
tovirt_r1 %r2
|
||||
#endif /* defined(BOOTLOADER) */
|
||||
bv 0(%r2)
|
||||
nop
|
||||
ENDPROC_CFI(rfi_real2virt)
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@
|
|||
extern struct unwind_table_entry __start___unwind[];
|
||||
extern struct unwind_table_entry __stop___unwind[];
|
||||
|
||||
static spinlock_t unwind_lock;
|
||||
static DEFINE_SPINLOCK(unwind_lock);
|
||||
/*
|
||||
* the kernel unwind block is not dynamically allocated so that
|
||||
* we can call unwind_init as early in the bootup process as
|
||||
|
|
@ -181,8 +181,6 @@ int __init unwind_init(void)
|
|||
start = (long)&__start___unwind[0];
|
||||
stop = (long)&__stop___unwind[0];
|
||||
|
||||
spin_lock_init(&unwind_lock);
|
||||
|
||||
printk("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n",
|
||||
start, stop,
|
||||
(stop - start) / sizeof(struct unwind_table_entry));
|
||||
|
|
|
|||
|
|
@ -27,8 +27,6 @@
|
|||
#include <linux/compiler.h>
|
||||
#include <linux/uaccess.h>
|
||||
|
||||
DECLARE_PER_CPU(struct exception_data, exception_data);
|
||||
|
||||
#define get_user_space() (uaccess_kernel() ? 0 : mfsp(3))
|
||||
#define get_kernel_space() (0)
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue