early.c 6.9 KB

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