mainmenu "Linux Kernel Configuration"
 
-config ARCH_S390
+config S390
        bool
        default y
 
 config UID16
        bool
        default y
-       depends on ARCH_S390X = 'n'
+       depends on !64BIT
 
 source "init/Kconfig"
 
 
 comment "Processor type and features"
 
-config ARCH_S390X
+config 64BIT
        bool "64 bit kernel"
        help
          Select this option if you have a 64 bit IBM zSeries machine
          and want to use the 64 bit addressing mode.
 
-config 64BIT
-       def_bool ARCH_S390X
-
-config ARCH_S390_31
-       bool
-       depends on ARCH_S390X = 'n'
-       default y
-
 config SMP
        bool "Symmetric multi-processing support"
        ---help---
          on older S/390 machines. Say Y unless you know your machine doesn't
          need this.
 
-config S390_SUPPORT
+config COMPAT
        bool "Kernel support for 31 bit emulation"
-       depends on ARCH_S390X
+       depends on 64BIT
        help
          Select this option if you want to enable your system kernel to
          handle system-calls from ELF binaries for 31 bit ESA.  This option
          (and some other stuff like libraries and such) is needed for
          executing 31 bit applications.  It is safe to say "Y".
 
-config COMPAT
-       bool
-       depends on S390_SUPPORT
-       default y
-
 config SYSVIPC_COMPAT
        bool
        depends on COMPAT && SYSVIPC
 
 config BINFMT_ELF32
        tristate "Kernel support for 31 bit ELF binaries"
-       depends on S390_SUPPORT
+       depends on COMPAT
        help
          This allows you to run 32-bit Linux/ELF binaries on your zSeries
          in 64 bit mode. Everybody wants this; say Y.
 
 config MARCH_G5
        bool "S/390 model G5 and G6"
-       depends on ARCH_S390_31
+       depends on !64BIT
        help
          Select this to build a 31 bit kernel that works
          on all S/390 and zSeries machines.
 
 # Copyright (C) 1994 by Linus Torvalds
 #
 
-ifdef CONFIG_ARCH_S390_31
+ifndef CONFIG_64BIT
 LDFLAGS                := -m elf_s390
 CFLAGS         += -m31
 AFLAGS         += -m31
 UTS_MACHINE    := s390
 STACK_SIZE     := 8192
 CHECKFLAGS     += -D__s390__
-endif
-
-ifdef CONFIG_ARCH_S390X
+else
 LDFLAGS                := -m elf64_s390
 MODFLAGS       += -fpic -D__PIC__
 CFLAGS         += -m64
 
 
 #define TOD_MICRO      0x01000                 /* nr. of TOD clock units
                                                   for 1 microsecond */
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
 
 #define APPLDATA_START_INTERVAL_REC 0x00       /* Function codes for */
 #define APPLDATA_STOP_REC          0x01        /* DIAG 0xDC      */
 #define APPLDATA_GEN_EVENT_RECORD   0x82
 #define APPLDATA_START_CONFIG_REC   0x83
 
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
 
 
 /*
  * Parameter list for DIAGNOSE X'DC'
  */
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
 struct appldata_parameter_list {
        u16 diag;               /* The DIAGNOSE code X'00DC'          */
        u8  function;           /* The function code for the DIAGNOSE */
        u64 product_id_addr;
        u64 buffer_addr;
 };
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
 
 /*
  * /proc entries (sysctl)
 
  * [ret] is the variable to receive the error code
  * [ERR] is the error code value
  */
-#ifndef __s390x__
+#ifndef CONFIG_64BIT
 #define __crypt_s390_fixup \
        ".section .fixup,\"ax\" \n"     \
        "7:     lhi     %0,%h[e1] \n"   \
        "       .long   0b,7b \n"       \
        "       .long   1b,8b \n"       \
        ".previous"
-#else /* __s390x__ */
+#else /* CONFIG_64BIT */
 #define __crypt_s390_fixup \
        ".section .fixup,\"ax\" \n"     \
        "7:     lhi     %0,%h[e1] \n"   \
        "       .quad   0b,7b \n"       \
        "       .quad   1b,8b \n"       \
        ".previous"
-#endif /* __s390x__ */
+#endif /* CONFIG_64BIT */
 
 /*
  * Standard code for setting the result of s390 crypto instructions.
  * [result]: the register containing the result (e.g. second operand length
  * to compute number of processed bytes].
  */
-#ifndef __s390x__
+#ifndef CONFIG_64BIT
 #define __crypt_s390_set_result \
        "       lr      %0,%[result] \n"
-#else /* __s390x__ */
+#else /* CONFIG_64BIT */
 #define __crypt_s390_set_result \
        "       lgr     %0,%[result] \n"
 #endif
 
 CONFIG_MMU=y
 CONFIG_RWSEM_XCHGADD_ALGORITHM=y
 CONFIG_GENERIC_CALIBRATE_DELAY=y
-CONFIG_ARCH_S390=y
+CONFIG_S390=y
 CONFIG_UID16=y
 
 #
 #
 # Processor type and features
 #
-# CONFIG_ARCH_S390X is not set
 # CONFIG_64BIT is not set
-CONFIG_ARCH_S390_31=y
 CONFIG_SMP=y
 CONFIG_NR_CPUS=32
 CONFIG_HOTPLUG_CPU=y
 
             setup.o sys_s390.o ptrace.o signal.o cpcmd.o ebcdic.o \
             semaphore.o s390_ext.o debug.o profile.o irq.o reipl_diag.o
 
+obj-y  += $(if $(CONFIG_64BIT),entry64.o,entry.o)
+obj-y  += $(if $(CONFIG_64BIT),reipl64.o,reipl.o)
+
 extra-y                                += head.o init_task.o vmlinux.lds
 
 obj-$(CONFIG_MODULES)          += s390_ksyms.o module.o
 obj-$(CONFIG_SMP)              += smp.o
 
-obj-$(CONFIG_S390_SUPPORT)     += compat_linux.o compat_signal.o \
+obj-$(CONFIG_COMPAT)           += compat_linux.o compat_signal.o \
                                        compat_ioctl.o compat_wrapper.o \
                                        compat_exec_domain.o
 obj-$(CONFIG_BINFMT_ELF32)     += binfmt_elf32.o
 
-obj-$(CONFIG_ARCH_S390_31)     += entry.o reipl.o
-obj-$(CONFIG_ARCH_S390X)       += entry64.o reipl64.o
-
 obj-$(CONFIG_VIRT_TIMER)       += vtime.o
 
 # Kexec part
 S390_KEXEC_OBJS := machine_kexec.o crash.o
-ifeq ($(CONFIG_ARCH_S390X),y)
-S390_KEXEC_OBJS += relocate_kernel64.o
-else
-S390_KEXEC_OBJS += relocate_kernel.o
-endif
+S390_KEXEC_OBJS += $(if $(CONFIG_64BIT),relocate_kernel64.o,relocate_kernel.o)
 obj-$(CONFIG_KEXEC) += $(S390_KEXEC_OBJS)
 
-
 #
 # This is just to get the dependencies...
 #
 
 
        if (response != NULL && rlen > 0) {
                memset(response, 0, rlen);
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
                asm volatile (  "lra    2,0(%2)\n"
                                "lr     4,%3\n"
                                "o      4,%6\n"
                                : "a" (cpcmd_buf), "d" (cmdlen),
                                "a" (response), "d" (rlen), "m" (mask)
                                : "cc", "2", "3", "4", "5" );
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
                 asm volatile ( "lrag   2,0(%2)\n"
                                "lgr    4,%3\n"
                                "o      4,%6\n"
                                : "a" (cpcmd_buf), "d" (cmdlen),
                                "a" (response), "d" (rlen), "m" (mask)
                                : "cc", "2", "3", "4", "5" );
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
                 EBCASC(response, rlen);
         } else {
                return_len = 0;
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
                 asm volatile ( "lra    2,0(%1)\n"
                                "lr     3,%2\n"
                                "diag   2,3,0x8\n"
                                : "=d" (return_code)
                                : "a" (cpcmd_buf), "d" (cmdlen)
                                : "2", "3"  );
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
                 asm volatile ( "lrag   2,0(%1)\n"
                                "lgr    3,%2\n"
                                "sam31\n"
                                : "=d" (return_code)
                                : "a" (cpcmd_buf), "d" (cmdlen)
                                : "2", "3" );
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
         }
        spin_unlock_irqrestore(&cpcmd_lock, flags);
        if (response_code != NULL)
 
 EXPORT_SYMBOL(__cpcmd);
 
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
 int cpcmd(const char *cmd, char *response, int rlen, int *response_code)
 {
        char *lowbuf;
 }
 
 EXPORT_SYMBOL(cpcmd);
-#endif         /* CONFIG_ARCH_S390X */
+#endif         /* CONFIG_64BIT */
 
        mvc     SP_ARGS(8,%r15),SP_R7(%r15)
 sysc_do_restart:
        larl    %r10,sys_call_table
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
        tm      __TI_flags+5(%r9),(_TIF_31BIT>>16)  # running in 31 bit mode ?
        jno     sysc_noemu
        larl    %r10,sys_call_table_emu  # use 31 bit emulation system calls
         la      %r2,SP_PTREGS(%r15)    # load pt_regs
         jg      sys_clone              # branch to sys_clone
 
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
 sys32_clone_glue: 
         la      %r2,SP_PTREGS(%r15)    # load pt_regs
         jg      sys32_clone            # branch to sys32_clone
         bnz     0(%r12)               # it did fail -> store result in gpr2
         b       6(%r12)               # SKIP STG 2,SP_R2(15) in
                                       # system_call/sysc_tracesys
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
 sys32_execve_glue:        
         la      %r2,SP_PTREGS(%r15)   # load pt_regs
        lgr     %r12,%r14             # save return address
         la      %r2,SP_PTREGS(%r15)   # load pt_regs as parameter
         jg      sys_sigreturn         # branch to sys_sigreturn
 
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
 sys32_sigreturn_glue:     
         la      %r2,SP_PTREGS(%r15)   # load pt_regs as parameter
         jg      sys32_sigreturn       # branch to sys32_sigreturn
         la      %r2,SP_PTREGS(%r15)   # load pt_regs as parameter
         jg      sys_rt_sigreturn      # branch to sys_sigreturn
 
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
 sys32_rt_sigreturn_glue:     
         la      %r2,SP_PTREGS(%r15)   # load pt_regs as parameter
         jg      sys32_rt_sigreturn    # branch to sys32_sigreturn
        la      %r14,6(%r14)          # skip store of return value
         jg      sys_sigsuspend        # branch to sys_sigsuspend
 
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
 sys32_sigsuspend_glue:    
        llgfr   %r4,%r4               # unsigned long                   
         lgr     %r5,%r4               # move mask back
        la      %r14,6(%r14)          # skip store of return value
         jg      sys_rt_sigsuspend     # branch to sys_rt_sigsuspend
 
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
 sys32_rt_sigsuspend_glue: 
        llgfr   %r3,%r3               # size_t                  
         lgr     %r4,%r3               # move sigsetsize parameter
         la      %r4,SP_PTREGS(%r15)   # load pt_regs as parameter
         jg      sys_sigaltstack       # branch to sys_sigreturn
 
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
 sys32_sigaltstack_glue:
         la      %r4,SP_PTREGS(%r15)   # load pt_regs as parameter
         jg      sys32_sigaltstack_wrapper # branch to sys_sigreturn
 #include "syscalls.S"
 #undef SYSCALL
 
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
 
 #define SYSCALL(esa,esame,emu) .long emu
        .globl  sys_call_table_emu
 
 #include <asm/thread_info.h>
 #include <asm/page.h>
 
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
 #define ARCH_OFFSET    4
 #else
 #define ARCH_OFFSET    0
        .word 0
 .endm
 
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
 #include "head64.S"
 #else
 #include "head31.S"
 
 #define DEBUGP(fmt , ...)
 #endif
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
 #define PLT_ENTRY_SIZE 12
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
 #define PLT_ENTRY_SIZE 20
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
 
 void *module_alloc(unsigned long size)
 {
                        unsigned int *ip;
                        ip = me->module_core + me->arch.plt_offset +
                                info->plt_offset;
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
                        ip[0] = 0x0d105810; /* basr 1,0; l 1,6(1); br 1 */
                        ip[1] = 0x100607f1;
                        ip[2] = val;
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
                        ip[0] = 0x0d10e310; /* basr 1,0; lg 1,10(1); br 1 */
                        ip[1] = 0x100a0004;
                        ip[2] = 0x07f10000;
                        ip[3] = (unsigned int) (val >> 32);
                        ip[4] = (unsigned int) val;
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
                        info->plt_initialized = 1;
                }
                if (r_type == R_390_PLTOFF16 ||
 
        /* Save access registers to new thread structure. */
        save_access_regs(&p->thread.acrs[0]);
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
         /*
         * save fprs to current->thread.fp_regs to merge them with
         * the emulated registers and then copy the result to the child.
        /* Set a new TLS ?  */
        if (clone_flags & CLONE_SETTLS)
                p->thread.acrs[0] = regs->gprs[6];
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
        /* Save the fpu registers to new thread structure. */
        save_fp_regs(&p->thread.fp_regs);
         p->thread.user_seg = __pa((unsigned long) p->mm->pgd) | _REGION_TABLE;
                        p->thread.acrs[1] = (unsigned int) regs->gprs[6];
                }
        }
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
        /* start new process with ar4 pointing to the correct address space */
        p->thread.mm_segment = get_fs();
         /* Don't copy debug registers */
  */
 int dump_fpu (struct pt_regs * regs, s390_fp_regs *fpregs)
 {
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
         /*
         * save fprs to current->thread.fp_regs to merge them with
         * the emulated registers and then copy the result to the dump.
         */
        save_fp_regs(¤t->thread.fp_regs);
        memcpy(fpregs, ¤t->thread.fp_regs, sizeof(s390_fp_regs));
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
        save_fp_regs(fpregs);
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
        return 1;
 }
 
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
 
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
 #include "compat_ptrace.h"
 #endif
 
        
        if (per_info->single_step) {
                per_info->control_regs.bits.starting_addr = 0;
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
                if (test_thread_flag(TIF_31BIT))
                        per_info->control_regs.bits.ending_addr = 0x7fffffffUL;
                else
        clear_single_step(child);
 }
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
 # define __ADDR_MASK 3
 #else
 # define __ADDR_MASK 7
         * an alignment of 4. Programmers from hell...
         */
        mask = __ADDR_MASK;
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
        if (addr >= (addr_t) &dummy->regs.acrs &&
            addr < (addr_t) &dummy->regs.orig_gpr2)
                mask = 3;
                 * access registers are stored in the thread structure
                 */
                offset = addr - (addr_t) &dummy->regs.acrs;
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
                /*
                 * Very special case: old & broken 64 bit gdb reading
                 * from acrs[15]. Result is a 64 bit value. Read the
         * an alignment of 4. Programmers from hell indeed...
         */
        mask = __ADDR_MASK;
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
        if (addr >= (addr_t) &dummy->regs.acrs &&
            addr < (addr_t) &dummy->regs.orig_gpr2)
                mask = 3;
                 * psw and gprs are stored on the stack
                 */
                if (addr == (addr_t) &dummy->regs.psw.mask &&
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
                    data != PSW_MASK_MERGE(PSW_USER32_BITS, data) &&
 #endif
                    data != PSW_MASK_MERGE(PSW_USER_BITS, data))
                        /* Invalid psw mask. */
                        return -EINVAL;
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
                if (addr == (addr_t) &dummy->regs.psw.addr)
                        /* I'd like to reject addresses without the
                           high order bit but older gdb's rely on it */
                 * access registers are stored in the thread structure
                 */
                offset = addr - (addr_t) &dummy->regs.acrs;
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
                /*
                 * Very special case: old & broken 64 bit gdb writing
                 * to acrs[15] with a 64 bit value. Ignore the lower
        return ptrace_request(child, request, addr, data);
 }
 
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
 /*
  * Now the fun part starts... a 31 bit program running in the
  * 31 bit emulation tracing another program. PTRACE_PEEKTEXT,
                        return peek_user(child, addr, data);
                if (request == PTRACE_POKEUSR && addr == PT_IEEE_IP)
                        return poke_user(child, addr, data);
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
                if (request == PTRACE_PEEKUSR &&
                    addr == PT32_IEEE_IP && test_thread_flag(TIF_31BIT))
                        return peek_user_emu31(child, addr, data);
 
        /* Do requests that differ for 31/64 bit */
        default:
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
                if (test_thread_flag(TIF_31BIT))
                        return do_ptrace_emu31(child, request, addr, data);
 #endif
 
                "   st   %%r4,%0\n"
                "   st   %%r5,%1\n"
                 ".section __ex_table,\"a\"\n"
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
                 "   .align 8\n"
                 "   .quad 0b, 0b\n"
 #else
 
                __alloc_bootmem(PAGE_SIZE, PAGE_SIZE, 0) + PAGE_SIZE;
        lc->current_task = (unsigned long) init_thread_union.thread_info.task;
        lc->thread_info = (unsigned long) &init_thread_union;
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
        if (MACHINE_HAS_IEEE) {
                lc->extended_save_area_addr = (__u32)
                        __alloc_bootmem(PAGE_SIZE, PAGE_SIZE, 0);
         /*
          * print what head.S has found out about the machine
          */
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
        printk((MACHINE_IS_VM) ?
               "We are running under VM (31 bit mode)\n" :
               "We are running native (31 bit mode)\n");
        printk((MACHINE_HAS_IEEE) ?
               "This machine has an IEEE fpu\n" :
               "This machine has no IEEE fpu\n");
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
        printk((MACHINE_IS_VM) ?
               "We are running under VM (64 bit mode)\n" :
               "We are running native (64 bit mode)\n");
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
 
         ROOT_DEV = Root_RAM0;
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
        memory_end = memory_size & ~0x400000UL;  /* align memory end to 4MB */
         /*
          * We need some free virtual space to be able to do vmalloc.
          */
         if (memory_end > 1920*1024*1024)
                 memory_end = 1920*1024*1024;
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
        memory_end = memory_size & ~0x200000UL;  /* detected in head.s */
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
 
        init_mm.start_code = PAGE_OFFSET;
        init_mm.end_code = (unsigned long) &_etext;
 
 
        if (signr > 0) {
                /* Whee!  Actually deliver the signal.  */
-#ifdef CONFIG_S390_SUPPORT
+#ifdef CONFIG_COMPAT
                if (test_thread_flag(TIF_31BIT)) {
                        extern void handle_signal32(unsigned long sig,
                                                    struct k_sigaction *ka,
 
         }
 }
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
 /*
  * this function sends a 'purge tlb' signal to another CPU.
  */
         on_each_cpu(smp_ptlb_callback, NULL, 0, 1);
 }
 EXPORT_SYMBOL(smp_ptlb_all);
-#endif /* ! CONFIG_ARCH_S390X */
+#endif /* ! CONFIG_64BIT */
 
 /*
  * this function sends a 'reschedule' IPI to another CPU.
                if (stack == 0ULL)
                        panic("smp_boot_cpus failed to allocate memory\n");
                lowcore_ptr[i]->panic_stack = stack + (PAGE_SIZE);
-#ifndef __s390x__
+#ifndef CONFIG_64BIT
                if (MACHINE_HAS_IEEE) {
                        lowcore_ptr[i]->extended_save_area_addr =
                                (__u32) __get_free_pages(GFP_KERNEL,0);
                }
 #endif
        }
-#ifndef __s390x__
+#ifndef CONFIG_64BIT
        if (MACHINE_HAS_IEEE)
                ctl_set_bit(14, 29); /* enable extended save area */
 #endif
 
 #include <linux/mman.h>
 #include <linux/file.h>
 #include <linux/utsname.h>
-#ifdef CONFIG_ARCH_S390X
 #include <linux/personality.h>
-#endif /* CONFIG_ARCH_S390X */
 
 #include <asm/uaccess.h>
 #include <asm/ipc.h>
        return error;
 }
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
 struct sel_arg_struct {
        unsigned long n;
        fd_set *inp, *outp, *exp;
        return sys_select(a.n, a.inp, a.outp, a.exp, a.tvp);
 
 }
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
 
 /*
  * sys_ipc() is the de-multiplexer for the SysV IPC calls..
        return -EINVAL;
 }
 
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
 asmlinkage long s390x_newuname(struct new_utsname __user *name)
 {
        int ret = sys_newuname(name);
 
        return ret;
 }
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
 
 /*
  * Wrapper function for sys_fadvise64/fadvise64_64
  */
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
 
 asmlinkage long
 s390_fadvise64(int fd, u32 offset_high, u32 offset_low, size_t len, int advice)
 
 
 #define stack_pointer ({ void **sp; asm("la %0,0(15)" : "=&d" (sp)); sp; })
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
 #define FOURLONG "%08lx %08lx %08lx %08lx\n"
 static int kstack_depth_to_print = 12;
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
 #define FOURLONG "%016lx %016lx %016lx %016lx\n"
 static int kstack_depth_to_print = 20;
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
 
 /*
  * For show_trace we have tree different stack to consider:
         pgm_check_table[0x11] = &do_dat_exception;
         pgm_check_table[0x12] = &translation_exception;
         pgm_check_table[0x13] = &special_op_exception;
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
         pgm_check_table[0x38] = &do_dat_exception;
        pgm_check_table[0x39] = &do_dat_exception;
        pgm_check_table[0x3A] = &do_dat_exception;
         pgm_check_table[0x3B] = &do_dat_exception;
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
         pgm_check_table[0x15] = &operand_exception;
         pgm_check_table[0x1C] = &space_switch_exception;
         pgm_check_table[0x1D] = &hfp_sqrt_exception;
 
 #include <asm-generic/vmlinux.lds.h>
 #include <linux/config.h>
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
 OUTPUT_FORMAT("elf32-s390", "elf32-s390", "elf32-s390")
 OUTPUT_ARCH(s390)
 ENTRY(_start)
 
 
 EXTRA_AFLAGS := -traditional
 
-lib-y += delay.o string.o
-lib-$(CONFIG_ARCH_S390_31) += uaccess.o spinlock.o
-lib-$(CONFIG_ARCH_S390X) += uaccess64.o spinlock.o
+lib-y += delay.o string.o spinlock.o
+lib-y += $(if $(CONFIG_64BIT),uaccess64.o,uaccess.o)
 
 static inline void
 _diag44(void)
 {
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
        if (MACHINE_HAS_DIAG44)
 #endif
                asm volatile("diag 0,0,0x44");
 
        rx = (unsigned long) parameter;
        ry = (unsigned long) func;
        __asm__ __volatile__(
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
                "   sam31\n" // switch to 31 bit
                "   diag    %0,%1,0x64\n"
                "   sam64\n" // switch back to 64 bit
 
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
 #define __FAIL_ADDR_MASK 0x7ffff000
 #define __FIXUP_MASK 0x7fffffff
 #define __SUBCODE_MASK 0x0200
 #define __PF_RES_FIELD 0ULL
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
 #define __FAIL_ADDR_MASK -4096L
 #define __FIXUP_MASK ~0L
 #define __SUBCODE_MASK 0x0600
 #define __PF_RES_FIELD 0x8000000000000000ULL
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
 
 #ifdef CONFIG_SYSCTL
 extern int sysctl_userprocess_debug;
                "2:\n"
                ".section __ex_table,\"a\"\n"
                "   .align 4\n"
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
                "   .long  0b,1b\n"
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
                "   .quad  0b,1b\n"
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
                ".previous"
                 : "=d" (rc) : "a" (&refbk), "m" (refbk) : "cc" );
         __ctl_set_bit(0, 9);
                "0:\n"
                ".section __ex_table,\"a\"\n"
                "   .align 4\n"
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
                "   .long  0b,0b\n"
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
                "   .quad  0b,0b\n"
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
                ".previous"
                : : "a" (&refbk), "m" (refbk) : "cc" );
 }
 
 {
         if (addr >= 0x7ff00000)
                 return;
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
         asm volatile (
                "   sam31\n"
                "   diag %0,%0,0x10\n"
  * paging_init() sets up the page tables
  */
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
 void __init paging_init(void)
 {
         pgd_t * pg_dir;
         return;
 }
 
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
 void __init paging_init(void)
 {
         pgd_t * pg_dir;
 
         return;
 }
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
 
 void __init mem_init(void)
 {
 
 
 static inline int mmap_is_legacy(void)
 {
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
        /*
         * Force standard allocation for 64 bit programs.
         */
 
 #for instance.
 config LBD
        bool "Support for Large Block Devices"
-       depends on X86 || (MIPS && 32BIT) || PPC32 || ARCH_S390_31 || SUPERH || UML
+       depends on X86 || (MIPS && 32BIT) || PPC32 || (S390 && !64BIT) || SUPERH || UML
        help
          Say Y here if you want to attach large (bigger than 2TB) discs to
          your machine, or if you want to have a raid or loopback device
 
 
 config CRYPTO_SHA1_S390
        tristate "SHA1 digest algorithm (s390)"
-       depends on CRYPTO && ARCH_S390
+       depends on CRYPTO && S390
        help
          This is the s390 hardware accelerated implementation of the
          SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
 
 config CRYPTO_SHA256_S390
        tristate "SHA256 digest algorithm (s390)"
-       depends on CRYPTO && ARCH_S390
+       depends on CRYPTO && S390
        help
          This is the s390 hardware accelerated implementation of the
          SHA256 secure hash standard (DFIPS 180-2).
 
 config CRYPTO_DES_S390
        tristate "DES and Triple DES cipher algorithms (s390)"
-       depends on CRYPTO && ARCH_S390
+       depends on CRYPTO && S390
        help
          DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
 
 
 config CRYPTO_AES_S390
        tristate "AES cipher algorithms (s390)"
-       depends on CRYPTO && ARCH_S390
+       depends on CRYPTO && S390
        help
          This is the s390 hardware accelerated implementation of the
          AES cipher algorithms (FIPS-197). AES uses the Rijndael
 
 
 config HANGCHECK_TIMER
        tristate "Hangcheck timer"
-       depends on X86 || IA64 || PPC64 || ARCH_S390
+       depends on X86 || IA64 || PPC64 || S390
        help
          The hangcheck-timer module detects when the system has gone
          out to lunch past a certain margin.  It can reboot the system
 
 #if defined(CONFIG_X86)
 # define HAVE_MONOTONIC
 # define TIMER_FREQ 1000000000ULL
-#elif defined(CONFIG_ARCH_S390)
+#elif defined(CONFIG_S390)
 /* FA240000 is 1 Second in the IBM time universe (Page 4-38 Principles of Op for zSeries */
 # define TIMER_FREQ 0xFA240000ULL
 #elif defined(CONFIG_IA64)
 
 
 config ZVM_WATCHDOG
        tristate "z/VM Watchdog Timer"
-       depends on WATCHDOG && ARCH_S390
+       depends on WATCHDOG && S390
        help
          IBM s/390 and zSeries machines running under z/VM 5.1 or later
          provide a virtual watchdog timer to their guest that cause a
 
 #  define COMPAT_TEST test_thread_flag(TIF_IA32)
 #elif defined(CONFIG_IA64)
 #  define COMPAT_TEST IS_IA32_PROCESS(ia64_task_regs(current))
-#elif defined(CONFIG_ARCH_S390)
+#elif defined(CONFIG_S390)
 #  define COMPAT_TEST test_thread_flag(TIF_31BIT)
 #elif defined(CONFIG_MIPS)
 #  define COMPAT_TEST (current->thread.mflags & MF_32BIT_ADDR)
 
 
 config PHYLIB
        tristate "PHY Device support and infrastructure"
-       depends on NET_ETHERNET && (BROKEN || !ARCH_S390)
+       depends on NET_ETHERNET && (BROKEN || !S390)
        help
          Ethernet controllers are usually attached to PHY
          devices.  This option provides infrastructure for
 
-if ARCH_S390
+if S390
 
 comment "S/390 block device drivers"
-       depends on ARCH_S390
+       depends on S390
 
 config BLK_DEV_XPRAM
        tristate "XPRAM disk support"
-       depends on ARCH_S390
+       depends on S390
        help
          Select this option if you want to use your expanded storage on S/390
          or zSeries as a disk.  This is useful as a _fast_ swap device if you
 
 config DASD_DIAG
        tristate "Support for DIAG access to Disks"
-       depends on DASD && ( ARCH_S390X = 'n' || EXPERIMENTAL)
+       depends on DASD && ( 64BIT = 'n' || EXPERIMENTAL)
        help
          Select this option if you want to use Diagnose250 command to access
          Disks under VM.  If you are not running under VM or unsure what it is,
 
 void
 dasd_kfree_request(struct dasd_ccw_req * cqr, struct dasd_device * device)
 {
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
        struct ccw1 *ccw;
 
        /* Clear any idals used for the request. */
 
        int rc;
 
        __asm__ __volatile__(
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
                "       lghi    %0,3\n"
                "       lgr     0,%3\n"
                "       diag    0,%2,0x250\n"
 
 } __attribute__ ((packed, aligned(4)));
 
 
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
 #define DASD_DIAG_FLAGA_DEFAULT                DASD_DIAG_FLAGA_FORMAT_64BIT
 
 typedef u64 blocknum_t;
        struct dasd_diag_bio *bio_list;
        u8  spare4[8];
 } __attribute__ ((packed, aligned(8)));
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
 #define DASD_DIAG_FLAGA_DEFAULT                0x0
 
 typedef u32 blocknum_t;
        u32 interrupt_params;
        u8 spare3[20];
 } __attribute__ ((packed, aligned(8)));
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
 
                                /* Eckd can only do full blocks. */
                                return ERR_PTR(-EINVAL);
                        count += bv->bv_len >> (device->s2b_shift + 9);
-#if defined(CONFIG_ARCH_S390X)
+#if defined(CONFIG_64BIT)
                        if (idal_is_needed (page_address(bv->bv_page),
                                            bv->bv_len))
                                cidaw += bv->bv_len >> (device->s2b_shift + 9);
 
                                /* Fba can only do full blocks. */
                                return ERR_PTR(-EINVAL);
                        count += bv->bv_len >> (device->s2b_shift + 9);
-#if defined(CONFIG_ARCH_S390X)
+#if defined(CONFIG_64BIT)
                        if (idal_is_needed (page_address(bv->bv_page),
                                            bv->bv_len))
                                cidaw += bv->bv_len / blksize;
 
                 "0: ipm   %0\n"
                "   srl   %0,28\n"
                "1:\n"
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
                ".section __ex_table,\"a\"\n"
                "   .align 4\n"
                "   .long  0b,1b\n"
                 "0: ipm   %0\n"
                "   srl   %0,28\n"
                "1:\n"
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
                ".section __ex_table,\"a\"\n"
                "   .align 4\n"
                "   .long  0b,1b\n"
 
        __cmdl = len;
        err = 0;
        asm volatile (
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
                       "diag %2,%4,0x288\n"
                "1:     \n"
                ".section .fixup,\"ax\"\n"
 
        sch->orb.spnd = sch->options.suspend;
        sch->orb.ssic = sch->options.suspend && sch->options.inter;
        sch->orb.lpm = (lpm != 0) ? (lpm & sch->opm) : sch->lpm;
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
        /*
         * for 64 bit we always support 64 bit IDAWs with 4k page size only
         */
 
 /*
  * diag210 is used under VM to get information about a virtual device
  */
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
 int
 diag210(struct diag210 * addr)
 {
 
                "0:  ipm  %0\n"
                "    srl  %0,28\n"
                "1:\n"
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
                ".section __ex_table,\"a\"\n"
                "   .align 8\n"
                "   .quad 0b,1b\n"
                "0:  ipm  %0\n"
                "    srl  %0,28\n"
                "1:\n"
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
                ".section __ex_table,\"a\"\n"
                "   .align 8\n"
                "   .quad 0b,1b\n"
 
        sprintf(dbf_text,"hydrati%1x", hydra_thinints);
        QDIO_DBF_TEXT0(0,setup,dbf_text);
 
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
        /* Check for QEBSM support in general (bit 58). */
        is_passthrough = css_general_characteristics.qebsm;
 #endif
 
 do_sqbs(unsigned long sch, unsigned char state, int queue,
        unsigned int *start, unsigned int *count)
 {
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
        register unsigned long _ccq asm ("0") = *count;
        register unsigned long _sch asm ("1") = sch;
        unsigned long _queuestart = ((unsigned long)queue << 32) | *start;
 do_eqbs(unsigned long sch, unsigned char *state, int queue,
        unsigned int *start, unsigned int *count)
 {
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
        register unsigned long _ccq asm ("0") = *count;
        register unsigned long _sch asm ("1") = sch;
        unsigned long _queuestart = ((unsigned long)queue << 32) | *start;
 {
        int cc;
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
        asm volatile (
                "lhi    0,2     \n\t"
                "lr     1,%1    \n\t"
                : "d" (schid), "d" (mask1), "d" (mask2)
                : "cc", "0", "1", "2", "3"
                );
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
        asm volatile (
                "lghi   0,2     \n\t"
                "llgfr  1,%1    \n\t"
                : "d" (schid), "d" (mask1), "d" (mask2)
                : "cc", "0", "1", "2", "3"
                );
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
        return cc;
 }
 
 {
        int cc;
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
        asm volatile (
                "lhi    0,1     \n\t"
                "lr     1,%1    \n\t"
                : "d" (schid), "d" (mask)
                : "cc", "0", "1", "2", "memory"
                );
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
        asm volatile (
                "lghi   0,1     \n\t"
                "llgfr  1,%1    \n\t"
                : "d" (schid), "d" (mask)
                : "cc", "0", "1", "2", "memory"
                );
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
        
        return cc;
 }
        int cc;
        __u32 busy_bit;
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
        asm volatile (
                "lhi    0,0     \n\t"
                "lr     1,%2    \n\t"
                "i" (QDIO_SIGA_ERROR_ACCESS_EXCEPTION)
                : "cc", "0", "1", "2", "memory"
                );
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
        asm volatile (
                "llgfr  0,%5    \n\t"
                 "lgr    1,%2    \n\t"
                "i" (QDIO_SIGA_ERROR_ACCESS_EXCEPTION), "d" (fc)
                : "cc", "0", "1", "2", "memory"
                );
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
        
        (*bb) = busy_bit;
        return cc;
 
        unsigned long time;
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
        asm volatile (
                "lhi    1,3     \n\t"
                ".insn  rre,0xb2650000,2,0      \n\t"
                "lr     %0,3    \n\t"
                : "=d" (time) : : "cc", "1", "2", "3"
                );
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
        asm volatile (
                "lghi   1,3     \n\t"
                ".insn  rre,0xb2650000,2,0      \n\t"
                "lgr    %0,3    \n\t"
                : "=d" (time) : : "cc", "1", "2", "3"
                );
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
        
        return time;
 }
 
 #define MY_MODULE_STRING(x) #x
 
-#ifdef CONFIG_ARCH_S390X
+#ifdef CONFIG_64BIT
 #define QDIO_GET_ADDR(x) ((__u32)(unsigned long)x)
-#else /* CONFIG_ARCH_S390X */
+#else /* CONFIG_64BIT */
 #define QDIO_GET_ADDR(x) ((__u32)(long)x)
-#endif /* CONFIG_ARCH_S390X */
+#endif /* CONFIG_64BIT */
 
 struct qdio_q {
        volatile struct slsb slsb;
 
        int ccode;
 
        asm volatile
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
        ("      llgfr   0,%4            \n"
         "      slgr    1,1             \n"
         "      lgr     2,1             \n"
        int ccode;
 
        asm volatile
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
        ("      llgfr   0,%2            \n"
         "      lghi    1,1             \n"
         "      sll     1,24            \n"
        int ccode;
 
        asm volatile
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
        ("      lgr     6,%3            \n"
         "      llgfr   7,%2            \n"
         "      llgt    0,0(6)          \n"
        int ccode;
 
        asm volatile
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
        ("      llgfr   0,%2            \n"
         "      lgr     3,%4            \n"
         "      lgr     6,%3            \n"
 
 menu "S/390 network device drivers"
-       depends on NETDEVICES && ARCH_S390
+       depends on NETDEVICES && S390
 
 config LCS
        tristate "Lan Channel Station Interface"
 
         __u32      ct, sw, rm, dup;
         char       *ptr, *rptr;
         char       tbuf[82], tdup[82];
-#if (CONFIG_ARCH_S390X)
+#if (CONFIG_64BIT)
         char       addr[22];
 #else
         char       addr[12];
         dup = 0;
         for ( ct=0; ct < len; ct++, ptr++, rptr++ )  {
                 if (sw == 0) {
-#if (CONFIG_ARCH_S390X)
+#if (CONFIG_64BIT)
                         sprintf(addr, "%16.16lX",(unsigned long)rptr);
 #else
                         sprintf(addr, "%8.8X",(__u32)rptr);
                 if (sw == 8) {
                         strcat(bhex, "  ");
                 }
-#if (CONFIG_ARCH_S390X)
+#if (CONFIG_64BIT)
                 sprintf(tbuf,"%2.2lX", (unsigned long)*ptr);
 #else
                 sprintf(tbuf,"%2.2X", (__u32)*ptr);
 
                 */
                kill_task = 1;
 
-#ifndef __s390x__
+#ifndef CONFIG_64BIT
        asm volatile("ld 0,0(%0)\n"
                     "ld 2,8(%0)\n"
                     "ld 4,16(%0)\n"
 #endif
 
        if (MACHINE_HAS_IEEE) {
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
                fpt_save_area = &S390_lowcore.floating_pt_save_area;
                fpt_creg_save_area = &S390_lowcore.fpt_creg_save_area;
 #else
                 */
                s390_handle_damage("invalid control registers.");
        else
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
                asm volatile("lctlg 0,15,0(%0)"
                             : : "a" (&S390_lowcore.cregs_save_area));
 #else
         * can't write something sensible into that register.
         */
 
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
        /*
         * See if we can revalidate the TOD programmable register with its
         * old contents (should be zero) otherwise set it to zero.
                if (mci->b) {
                        /* Processing backup -> verify if we can survive this */
                        u64 z_mcic, o_mcic, t_mcic;
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
                        z_mcic = (1ULL<<63 | 1ULL<<59 | 1ULL<<29);
                        o_mcic = (1ULL<<43 | 1ULL<<42 | 1ULL<<41 | 1ULL<<40 |
                                  1ULL<<36 | 1ULL<<35 | 1ULL<<34 | 1ULL<<32 |
 
 {
        int cc, retv;
 
-#ifndef CONFIG_ARCH_S390X
+#ifndef CONFIG_64BIT
        __asm__ __volatile__ (  "lr\t0,%2\n"
                                "\tlr\t1,%3\n"
                                "\tstsi\t0(%4)\n"
 
 
 config ZFCP
        tristate "FCP host bus adapter driver for IBM eServer zSeries"
-       depends on ARCH_S390 && QDIO && SCSI
+       depends on S390 && QDIO && SCSI
        select SCSI_FC_ATTRS
        help
           If you want to access SCSI devices attached to your IBM eServer
 
 
 config IBM_PARTITION
        bool "IBM disk label and partition support"
-       depends on PARTITION_ADVANCED && ARCH_S390
+       depends on PARTITION_ADVANCED && S390
        help
          Say Y here if you would like to be able to read the hard disk
          partition table format used by IBM DASD disks operating under CMS.
 
        buffer = task_sig(task, buffer);
        buffer = task_cap(task, buffer);
        buffer = cpuset_task_status_allowed(task, buffer);
-#if defined(CONFIG_ARCH_S390)
+#if defined(CONFIG_S390)
        buffer = task_show_regs(task, buffer);
 #endif
        return buffer - orig;
 
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
-# ifdef CONFIG_ARCH_S390_31
+# ifndef CONFIG_64BIT
 #   define __ARCH_WANT_STAT64
 #   define __ARCH_WANT_SYS_TIME
 # endif
 
 #include <linux/config.h>
 #include <linux/smp.h>
 
-#if !defined(CONFIG_ARCH_S390)
+#if !defined(CONFIG_S390)
 
 #include <linux/linkage.h>
 #include <linux/cache.h>
 
 
 config AUDITSYSCALL
        bool "Enable system-call auditing support"
-       depends on AUDIT && (X86 || PPC || PPC64 || ARCH_S390 || IA64 || UML || SPARC64)
+       depends on AUDIT && (X86 || PPC || PPC64 || S390 || IA64 || UML || SPARC64)
        default y if SECURITY_SELINUX
        help
          Enable low-overhead system-call auditing infrastructure that
 
        int nblocks, i, disk;
        char *buf = NULL;
        unsigned short rotate = 0;
-#if !defined(CONFIG_ARCH_S390) && !defined(CONFIG_PPC_ISERIES)
+#if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
        char rotator[4] = { '|' , '/' , '-' , '\\' };
 #endif
 
                }
                sys_read(in_fd, buf, BLOCK_SIZE);
                sys_write(out_fd, buf, BLOCK_SIZE);
-#if !defined(CONFIG_ARCH_S390) && !defined(CONFIG_PPC_ISERIES)
+#if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
                if (!(i % 16)) {
                        printk("%c\b", rotator[rotate & 0x3]);
                        rotate++;
 
        long i;
        static char buf[1024];
        va_list args;
-#if defined(CONFIG_ARCH_S390)
+#if defined(CONFIG_S390)
         unsigned long caller = (unsigned long) __builtin_return_address(0);
 #endif
 
                printk(KERN_EMERG "Press Stop-A (L1-A) to return to the boot prom\n");
        }
 #endif
-#if defined(CONFIG_ARCH_S390)
+#if defined(CONFIG_S390)
         disabled_wait(caller);
 #endif
        local_irq_enable();
 
 extern int unaligned_enabled;
 #endif
 
-#ifdef CONFIG_ARCH_S390
+#ifdef CONFIG_S390
 #ifdef CONFIG_MATHEMU
 extern int sysctl_ieee_emulation_warnings;
 #endif
                .extra1         = &minolduid,
                .extra2         = &maxolduid,
        },
-#ifdef CONFIG_ARCH_S390
+#ifdef CONFIG_S390
 #ifdef CONFIG_MATHEMU
        {
                .ctl_name       = KERN_IEEE_EMULATION_WARNINGS,
                .mode           = 0644,
                .proc_handler   = &proc_dointvec,
        },
-#if defined(CONFIG_ARCH_S390)
+#if defined(CONFIG_S390)
        {
                .ctl_name       = KERN_SPIN_RETRY,
                .procname       = "spin_retry",
 
 config LOG_BUF_SHIFT
        int "Kernel log buffer size (16 => 64KB, 17 => 128KB)" if DEBUG_KERNEL
        range 12 21
-       default 17 if ARCH_S390
+       default 17 if S390
        default 16 if X86_NUMAQ || IA64
        default 15 if SMP
        default 14