release/src-rt-6.x/linux/linux-2.6/arch/s390/kernel/early.c

   1 /*
   2  *  arch/s390/kernel/early.c
   3  *
   4  *    Copyright IBM Corp. 2007
   5  *    Author(s): Hongjie Yang <hongjie@us.ibm.com>,
   6  *               Heiko Carstens <heiko.carstens@de.ibm.com>
   7  */
   8
   9 #include <linux/init.h>
  10 #include <linux/errno.h>
  11 #include <linux/string.h>
  12 #include <linux/ctype.h>
  13 #include <linux/lockdep.h>
  14 #include <linux/module.h>
  15 #include <linux/pfn.h>
  16 #include <linux/uaccess.h>
  17 #include <asm/ipl.h>
  18 #include <asm/lowcore.h>
  19 #include <asm/processor.h>
  20 #include <asm/sections.h>
  21 #include <asm/setup.h>
  22 #include <asm/cpcmd.h>
  23 #include <asm/sclp.h>
  24
  25 /*
  26  * Create a Kernel NSS if the SAVESYS= parameter is defined
  27  */
  28 #define DEFSYS_CMD_SIZE         96
  29 #define SAVESYS_CMD_SIZE        32
  30
  31 char kernel_nss_name[NSS_NAME_SIZE + 1];
  32
  33 #ifdef CONFIG_SHARED_KERNEL
  34 static noinline __init void create_kernel_nss(void)
  35 {
  36         unsigned int i, stext_pfn, eshared_pfn, end_pfn, min_size;
  37 #ifdef CONFIG_BLK_DEV_INITRD
  38         unsigned int sinitrd_pfn, einitrd_pfn;
  39 #endif
  40         int response;
  41         char *savesys_ptr;
  42         char upper_command_line[COMMAND_LINE_SIZE];
  43         char defsys_cmd[DEFSYS_CMD_SIZE];
  44         char savesys_cmd[SAVESYS_CMD_SIZE];
  45
  46         /* Do nothing if we are not running under VM */
  47         if (!MACHINE_IS_VM)
  48                 return;
  49
  50         /* Convert COMMAND_LINE to upper case */
  51         for (i = 0; i < strlen(COMMAND_LINE); i++)
  52                 upper_command_line[i] = toupper(COMMAND_LINE[i]);
  53
  54         savesys_ptr = strstr(upper_command_line, "SAVESYS=");
  55
  56         if (!savesys_ptr)
  57                 return;
  58
  59         savesys_ptr += 8;    /* Point to the beginning of the NSS name */
  60         for (i = 0; i < NSS_NAME_SIZE; i++) {
  61                 if (savesys_ptr[i] == ' ' || savesys_ptr[i] == '\0')
  62                         break;
  63                 kernel_nss_name[i] = savesys_ptr[i];
  64         }
  65
  66         stext_pfn = PFN_DOWN(__pa(&_stext));
  67         eshared_pfn = PFN_DOWN(__pa(&_eshared));
  68         end_pfn = PFN_UP(__pa(&_end));
  69         min_size = end_pfn << 2;
  70
  71         sprintf(defsys_cmd, "DEFSYS %s 00000-%.5X EW %.5X-%.5X SR %.5X-%.5X",
  72                 kernel_nss_name, stext_pfn - 1, stext_pfn, eshared_pfn - 1,
  73                 eshared_pfn, end_pfn);
  74
  75 #ifdef CONFIG_BLK_DEV_INITRD
  76         if (INITRD_START && INITRD_SIZE) {
  77                 sinitrd_pfn = PFN_DOWN(__pa(INITRD_START));
  78                 einitrd_pfn = PFN_UP(__pa(INITRD_START + INITRD_SIZE));
  79                 min_size = einitrd_pfn << 2;
  80                 sprintf(defsys_cmd, "%s EW %.5X-%.5X", defsys_cmd,
  81                 sinitrd_pfn, einitrd_pfn);
  82         }
  83 #endif
  84
  85         sprintf(defsys_cmd, "%s EW MINSIZE=%.7iK", defsys_cmd, min_size);
  86         sprintf(savesys_cmd, "SAVESYS %s \n IPL %s",
  87                 kernel_nss_name, kernel_nss_name);
  88
  89         __cpcmd(defsys_cmd, NULL, 0, &response);
  90
  91         if (response != 0)
  92                 return;
  93
  94         __cpcmd(savesys_cmd, NULL, 0, &response);
  95
  96         if (response != strlen(savesys_cmd))
  97                 return;
  98
  99         ipl_flags = IPL_NSS_VALID;
 100 }
 101
 102 #else /* CONFIG_SHARED_KERNEL */
 103
 104 static inline void create_kernel_nss(void) { }
 105
 106 #endif /* CONFIG_SHARED_KERNEL */
 107
 108 /*
 109  * Clear bss memory
 110  */
 111 static noinline __init void clear_bss_section(void)
 112 {
 113         memset(__bss_start, 0, __bss_stop - __bss_start);
 114 }
 115
 116 /*
 117  * Initialize storage key for kernel pages
 118  */
 119 static noinline __init void init_kernel_storage_key(void)
 120 {
 121         unsigned long end_pfn, init_pfn;
 122
 123         end_pfn = PFN_UP(__pa(&_end));
 124
 125         for (init_pfn = 0 ; init_pfn < end_pfn; init_pfn++)
 126                 page_set_storage_key(init_pfn << PAGE_SHIFT, PAGE_DEFAULT_KEY);
 127 }
 128
 129 static noinline __init void detect_machine_type(void)
 130 {
 131         struct cpuinfo_S390 *cpuinfo = &S390_lowcore.cpu_data;
 132
 133         get_cpu_id(&S390_lowcore.cpu_data.cpu_id);
 134
 135         /* Running under z/VM ? */
 136         if (cpuinfo->cpu_id.version == 0xff)
 137                 machine_flags |= 1;
 138
 139         /* Running on a P/390 ? */
 140         if (cpuinfo->cpu_id.machine == 0x7490)
 141                 machine_flags |= 4;
 142 }
 143
 144 #ifdef CONFIG_64BIT
 145 static noinline __init int memory_fast_detect(void)
 146 {
 147         unsigned long val0 = 0;
 148         unsigned long val1 = 0xc;
 149         int ret = -ENOSYS;
 150
 151         if (ipl_flags & IPL_NSS_VALID)
 152                 return -ENOSYS;
 153
 154         asm volatile(
 155                 "       diag    %1,%2,0x260\n"
 156                 "0:     lhi     %0,0\n"
 157                 "1:\n"
 158                 EX_TABLE(0b,1b)
 159                 : "+d" (ret), "+d" (val0), "+d" (val1) : : "cc");
 160
 161         if (ret || val0 != val1)
 162                 return -ENOSYS;
 163
 164         memory_chunk[0].size = val0 + 1;
 165         return 0;
 166 }
 167 #else
 168 static inline int memory_fast_detect(void)
 169 {
 170         return -ENOSYS;
 171 }
 172 #endif
 173
 174 #define ADDR2G  (1UL << 31)
 175
 176 static noinline __init unsigned long sclp_memory_detect(void)
 177 {
 178         struct sclp_readinfo_sccb *sccb;
 179         unsigned long long memsize;
 180
 181         sccb = &s390_readinfo_sccb;
 182
 183         if (sccb->header.response_code != 0x10)
 184                 return 0;
 185
 186         if (sccb->rnsize)
 187                 memsize = sccb->rnsize << 20;
 188         else
 189                 memsize = sccb->rnsize2 << 20;
 190         if (sccb->rnmax)
 191                 memsize *= sccb->rnmax;
 192         else
 193                 memsize *= sccb->rnmax2;
 194 #ifndef CONFIG_64BIT
 195         /*
 196          * Can't deal with more than 2G in 31 bit addressing mode, so
 197          * limit the value in order to avoid strange side effects.
 198          */
 199         if (memsize > ADDR2G)
 200                 memsize = ADDR2G;
 201 #endif
 202         return (unsigned long) memsize;
 203 }
 204
 205 static inline __init unsigned long __tprot(unsigned long addr)
 206 {
 207         int cc = -1;
 208
 209         asm volatile(
 210                 "       tprot   0(%1),0\n"
 211                 "0:     ipm     %0\n"
 212                 "       srl     %0,28\n"
 213                 "1:\n"
 214                 EX_TABLE(0b,1b)
 215                 : "+d" (cc) : "a" (addr) : "cc");
 216         return (unsigned long)cc;
 217 }
 218
 219 /* Checking memory in 128KB increments. */
 220 #define CHUNK_INCR      (1UL << 17)
 221
 222 static noinline __init void find_memory_chunks(unsigned long memsize)
 223 {
 224         unsigned long addr = 0, old_addr = 0;
 225         unsigned long old_cc = CHUNK_READ_WRITE;
 226         unsigned long cc;
 227         int chunk = 0;
 228
 229         while (chunk < MEMORY_CHUNKS) {
 230                 cc = __tprot(addr);
 231                 while (cc == old_cc) {
 232                         addr += CHUNK_INCR;
 233                         cc = __tprot(addr);
 234 #ifndef CONFIG_64BIT
 235                         if (addr == ADDR2G)
 236                                 break;
 237 #endif
 238                 }
 239
 240                 if (old_addr != addr &&
 241                     (old_cc == CHUNK_READ_WRITE || old_cc == CHUNK_READ_ONLY)) {
 242                         memory_chunk[chunk].addr = old_addr;
 243                         memory_chunk[chunk].size = addr - old_addr;
 244                         memory_chunk[chunk].type = old_cc;
 245                         chunk++;
 246                 }
 247
 248                 old_addr = addr;
 249                 old_cc = cc;
 250
 251 #ifndef CONFIG_64BIT
 252                 if (addr == ADDR2G)
 253                         break;
 254 #endif
 255                 /*
 256                  * Finish memory detection at the first hole
 257                  * if storage size is unknown.
 258                  */
 259                 if (cc == -1UL && !memsize)
 260                         break;
 261                 if (memsize && addr >= memsize)
 262                         break;
 263         }
 264 }
 265
 266 static __init void early_pgm_check_handler(void)
 267 {
 268         unsigned long addr;
 269         const struct exception_table_entry *fixup;
 270
 271         addr = S390_lowcore.program_old_psw.addr;
 272         fixup = search_exception_tables(addr & PSW_ADDR_INSN);
 273         if (!fixup)
 274                 disabled_wait(0);
 275         S390_lowcore.program_old_psw.addr = fixup->fixup | PSW_ADDR_AMODE;
 276 }
 277
 278 static noinline __init void setup_lowcore_early(void)
 279 {
 280         psw_t psw;
 281
 282         psw.mask = PSW_BASE_BITS | PSW_DEFAULT_KEY;
 283         psw.addr = PSW_ADDR_AMODE | (unsigned long) s390_base_ext_handler;
 284         S390_lowcore.external_new_psw = psw;
 285         psw.addr = PSW_ADDR_AMODE | (unsigned long) s390_base_pgm_handler;
 286         S390_lowcore.program_new_psw = psw;
 287         s390_base_pgm_handler_fn = early_pgm_check_handler;
 288 }
 289
 290 /*
 291  * Save ipl parameters, clear bss memory, initialize storage keys
 292  * and create a kernel NSS at startup if the SAVESYS= parm is defined
 293  */
 294 void __init startup_init(void)
 295 {
 296         unsigned long memsize;
 297
 298         ipl_save_parameters();
 299         clear_bss_section();
 300         init_kernel_storage_key();
 301         lockdep_init();
 302         lockdep_off();
 303         detect_machine_type();
 304         create_kernel_nss();
 305         sort_main_extable();
 306         setup_lowcore_early();
 307         sclp_readinfo_early();
 308         memsize = sclp_memory_detect();
 309         if (memory_fast_detect() < 0)
 310                 find_memory_chunks(memsize);
 311         lockdep_on();
 312 }