URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [arch/] [s390/] [kernel/] [early.c] - Blame information for rev 63

Details | Compare with Previous | View Log


/*
 *  arch/s390/kernel/early.c
 *
 *    Copyright IBM Corp. 2007
 *    Author(s): Hongjie Yang <hongjie@us.ibm.com>,
 *               Heiko Carstens <heiko.carstens@de.ibm.com>
 */
 
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/lockdep.h>
#include <linux/module.h>
#include <linux/pfn.h>
#include <linux/uaccess.h>
#include <asm/ipl.h>
#include <asm/lowcore.h>
#include <asm/processor.h>
#include <asm/sections.h>
#include <asm/setup.h>
#include <asm/cpcmd.h>
#include <asm/sclp.h>
 
/*
 * Create a Kernel NSS if the SAVESYS= parameter is defined
 */
#define DEFSYS_CMD_SIZE         96
#define SAVESYS_CMD_SIZE        32
 
char kernel_nss_name[NSS_NAME_SIZE + 1];
 
#ifdef CONFIG_SHARED_KERNEL
static noinline __init void create_kernel_nss(void)
{
        unsigned int i, stext_pfn, eshared_pfn, end_pfn, min_size;
#ifdef CONFIG_BLK_DEV_INITRD
        unsigned int sinitrd_pfn, einitrd_pfn;
#endif
        int response;
        char *savesys_ptr;
        char upper_command_line[COMMAND_LINE_SIZE];
        char defsys_cmd[DEFSYS_CMD_SIZE];
        char savesys_cmd[SAVESYS_CMD_SIZE];
 
        /* Do nothing if we are not running under VM */
        if (!MACHINE_IS_VM)
                return;
 
        /* Convert COMMAND_LINE to upper case */
        for (i = 0; i < strlen(COMMAND_LINE); i++)
                upper_command_line[i] = toupper(COMMAND_LINE[i]);
 
        savesys_ptr = strstr(upper_command_line, "SAVESYS=");
 
        if (!savesys_ptr)
                return;
 
        savesys_ptr += 8;    /* Point to the beginning of the NSS name */
        for (i = 0; i < NSS_NAME_SIZE; i++) {
                if (savesys_ptr[i] == ' ' || savesys_ptr[i] == '\0')
                        break;
                kernel_nss_name[i] = savesys_ptr[i];
        }
 
        stext_pfn = PFN_DOWN(__pa(&_stext));
        eshared_pfn = PFN_DOWN(__pa(&_eshared));
        end_pfn = PFN_UP(__pa(&_end));
        min_size = end_pfn << 2;
 
        sprintf(defsys_cmd, "DEFSYS %s 00000-%.5X EW %.5X-%.5X SR %.5X-%.5X",
                kernel_nss_name, stext_pfn - 1, stext_pfn, eshared_pfn - 1,
                eshared_pfn, end_pfn);
 
#ifdef CONFIG_BLK_DEV_INITRD
        if (INITRD_START && INITRD_SIZE) {
                sinitrd_pfn = PFN_DOWN(__pa(INITRD_START));
                einitrd_pfn = PFN_UP(__pa(INITRD_START + INITRD_SIZE));
                min_size = einitrd_pfn << 2;
                sprintf(defsys_cmd, "%s EW %.5X-%.5X", defsys_cmd,
                sinitrd_pfn, einitrd_pfn);
        }
#endif
 
        sprintf(defsys_cmd, "%s EW MINSIZE=%.7iK", defsys_cmd, min_size);
        sprintf(savesys_cmd, "SAVESYS %s \n IPL %s",
                kernel_nss_name, kernel_nss_name);
 
        __cpcmd(defsys_cmd, NULL, 0, &response);
 
        if (response != 0)
                return;
 
        __cpcmd(savesys_cmd, NULL, 0, &response);
 
        if (response != strlen(savesys_cmd))
                return;
 
        ipl_flags = IPL_NSS_VALID;
}
 
#else /* CONFIG_SHARED_KERNEL */
 
static inline void create_kernel_nss(void) { }
 
#endif /* CONFIG_SHARED_KERNEL */
 
/*
 * Clear bss memory
 */
static noinline __init void clear_bss_section(void)
{
        memset(__bss_start, 0, __bss_stop - __bss_start);
}
 
/*
 * Initialize storage key for kernel pages
 */
static noinline __init void init_kernel_storage_key(void)
{
        unsigned long end_pfn, init_pfn;
 
        end_pfn = PFN_UP(__pa(&_end));
 
        for (init_pfn = 0 ; init_pfn < end_pfn; init_pfn++)
                page_set_storage_key(init_pfn << PAGE_SHIFT, PAGE_DEFAULT_KEY);
}
 
static noinline __init void detect_machine_type(void)
{
        struct cpuinfo_S390 *cpuinfo = &S390_lowcore.cpu_data;
 
        get_cpu_id(&S390_lowcore.cpu_data.cpu_id);
 
        /* Running under z/VM ? */
        if (cpuinfo->cpu_id.version == 0xff)
                machine_flags |= 1;
 
        /* Running on a P/390 ? */
        if (cpuinfo->cpu_id.machine == 0x7490)
                machine_flags |= 4;
}
 
#ifdef CONFIG_64BIT
static noinline __init int memory_fast_detect(void)
{
        unsigned long val0 = 0;
        unsigned long val1 = 0xc;
        int ret = -ENOSYS;
 
        if (ipl_flags & IPL_NSS_VALID)
                return -ENOSYS;
 
        asm volatile(
                "       diag    %1,%2,0x260\n"
                "0:     lhi     %0,0\n"
                "1:\n"
                EX_TABLE(0b,1b)
                : "+d" (ret), "+d" (val0), "+d" (val1) : : "cc");
 
        if (ret || val0 != val1)
                return -ENOSYS;
 
        memory_chunk[0].size = val0 + 1;
        return 0;
}
#else
static inline int memory_fast_detect(void)
{
        return -ENOSYS;
}
#endif
 
static inline __init unsigned long __tprot(unsigned long addr)
{
        int cc = -1;
 
        asm volatile(
                "       tprot   0(%1),0\n"
                "0:     ipm     %0\n"
                "       srl     %0,28\n"
                "1:\n"
                EX_TABLE(0b,1b)
                : "+d" (cc) : "a" (addr) : "cc");
        return (unsigned long)cc;
}
 
/* Checking memory in 128KB increments. */
#define CHUNK_INCR      (1UL << 17)
#define ADDR2G          (1UL << 31)
 
static noinline __init void find_memory_chunks(unsigned long memsize)
{
        unsigned long addr = 0, old_addr = 0;
        unsigned long old_cc = CHUNK_READ_WRITE;
        unsigned long cc;
        int chunk = 0;
 
        while (chunk < MEMORY_CHUNKS) {
                cc = __tprot(addr);
                while (cc == old_cc) {
                        addr += CHUNK_INCR;
                        if (memsize && addr >= memsize)
                                break;
#ifndef CONFIG_64BIT
                        if (addr == ADDR2G)
                                break;
#endif
                        cc = __tprot(addr);
                }
 
                if (old_addr != addr &&
                    (old_cc == CHUNK_READ_WRITE || old_cc == CHUNK_READ_ONLY)) {
                        memory_chunk[chunk].addr = old_addr;
                        memory_chunk[chunk].size = addr - old_addr;
                        memory_chunk[chunk].type = old_cc;
                        chunk++;
                }
 
                old_addr = addr;
                old_cc = cc;
 
#ifndef CONFIG_64BIT
                if (addr == ADDR2G)
                        break;
#endif
                /*
                 * Finish memory detection at the first hole
                 * if storage size is unknown.
                 */
                if (cc == -1UL && !memsize)
                        break;
                if (memsize && addr >= memsize)
                        break;
        }
}
 
static __init void early_pgm_check_handler(void)
{
        unsigned long addr;
        const struct exception_table_entry *fixup;
 
        addr = S390_lowcore.program_old_psw.addr;
        fixup = search_exception_tables(addr & PSW_ADDR_INSN);
        if (!fixup)
                disabled_wait(0);
        S390_lowcore.program_old_psw.addr = fixup->fixup | PSW_ADDR_AMODE;
}
 
static noinline __init void setup_lowcore_early(void)
{
        psw_t psw;
 
        psw.mask = PSW_BASE_BITS | PSW_DEFAULT_KEY;
        psw.addr = PSW_ADDR_AMODE | (unsigned long) s390_base_ext_handler;
        S390_lowcore.external_new_psw = psw;
        psw.addr = PSW_ADDR_AMODE | (unsigned long) s390_base_pgm_handler;
        S390_lowcore.program_new_psw = psw;
        s390_base_pgm_handler_fn = early_pgm_check_handler;
}
 
/*
 * Save ipl parameters, clear bss memory, initialize storage keys
 * and create a kernel NSS at startup if the SAVESYS= parm is defined
 */
void __init startup_init(void)
{
        unsigned long long memsize;
 
        ipl_save_parameters();
        clear_bss_section();
        init_kernel_storage_key();
        lockdep_init();
        lockdep_off();
        detect_machine_type();
        create_kernel_nss();
        sort_main_extable();
        setup_lowcore_early();
        sclp_readinfo_early();
        sclp_facilities_detect();
        memsize = sclp_memory_detect();
#ifndef CONFIG_64BIT
        /*
         * Can't deal with more than 2G in 31 bit addressing mode, so
         * limit the value in order to avoid strange side effects.
         */
        if (memsize > ADDR2G)
                memsize = ADDR2G;
#endif
        if (memory_fast_detect() < 0)
                find_memory_chunks((unsigned long) memsize);
        lockdep_on();
}

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [arch/] [s390/] [kernel/] [early.c] - Blame information for rev 63

Line No.	Rev	Author	Line
1	63	marcus.erl	`/*`
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			`static inline __init unsigned long __tprot(unsigned long addr)`
175			`{`
176			`int cc = -1;`
177
178			`asm volatile(`
179			`" tprot 0(%1),0\n"`
180			`"0: ipm %0\n"`
181			`" srl %0,28\n"`
182			`"1:\n"`
183			`EX_TABLE(0b,1b)`
184			`: "+d" (cc) : "a" (addr) : "cc");`
185			`return (unsigned long)cc;`
186			`}`
187
188			`/* Checking memory in 128KB increments. */`
189			`#define CHUNK_INCR (1UL << 17)`
190			`#define ADDR2G (1UL << 31)`
191
192			`static noinline __init void find_memory_chunks(unsigned long memsize)`
193			`{`
194			`unsigned long addr = 0, old_addr = 0;`
195			`unsigned long old_cc = CHUNK_READ_WRITE;`
196			`unsigned long cc;`
197			`int chunk = 0;`
198
199			`while (chunk < MEMORY_CHUNKS) {`
200			`cc = __tprot(addr);`
201			`while (cc == old_cc) {`
202			`addr += CHUNK_INCR;`
203			`if (memsize && addr >= memsize)`
204			`break;`
205			`#ifndef CONFIG_64BIT`
206			`if (addr == ADDR2G)`
207			`break;`
208			`#endif`
209			`cc = __tprot(addr);`
210			`}`
211
212			`if (old_addr != addr &&`
213			`(old_cc == CHUNK_READ_WRITE \|\| old_cc == CHUNK_READ_ONLY)) {`
214			`memory_chunk[chunk].addr = old_addr;`
215			`memory_chunk[chunk].size = addr - old_addr;`
216			`memory_chunk[chunk].type = old_cc;`
217			`chunk++;`
218			`}`
219
220			`old_addr = addr;`
221			`old_cc = cc;`
222
223			`#ifndef CONFIG_64BIT`
224			`if (addr == ADDR2G)`
225			`break;`
226			`#endif`
227			`/*`
228			`* Finish memory detection at the first hole`
229			`* if storage size is unknown.`
230			`*/`
231			`if (cc == -1UL && !memsize)`
232			`break;`
233			`if (memsize && addr >= memsize)`
234			`break;`
235			`}`
236			`}`
237
238			`static __init void early_pgm_check_handler(void)`
239			`{`
240			`unsigned long addr;`
241			`const struct exception_table_entry *fixup;`
242
243			`addr = S390_lowcore.program_old_psw.addr;`
244			`fixup = search_exception_tables(addr & PSW_ADDR_INSN);`
245			`if (!fixup)`
246			`disabled_wait(0);`
247			`S390_lowcore.program_old_psw.addr = fixup->fixup \| PSW_ADDR_AMODE;`
248			`}`
249
250			`static noinline __init void setup_lowcore_early(void)`
251			`{`
252			`psw_t psw;`
253
254			`psw.mask = PSW_BASE_BITS \| PSW_DEFAULT_KEY;`
255			`psw.addr = PSW_ADDR_AMODE \| (unsigned long) s390_base_ext_handler;`
256			`S390_lowcore.external_new_psw = psw;`
257			`psw.addr = PSW_ADDR_AMODE \| (unsigned long) s390_base_pgm_handler;`
258			`S390_lowcore.program_new_psw = psw;`
259			`s390_base_pgm_handler_fn = early_pgm_check_handler;`
260			`}`
261
262			`/*`
263			`* Save ipl parameters, clear bss memory, initialize storage keys`
264			`* and create a kernel NSS at startup if the SAVESYS= parm is defined`
265			`*/`
266			`void __init startup_init(void)`
267			`{`
268			`unsigned long long memsize;`
269
270			`ipl_save_parameters();`
271			`clear_bss_section();`
272			`init_kernel_storage_key();`
273			`lockdep_init();`
274			`lockdep_off();`
275			`detect_machine_type();`
276			`create_kernel_nss();`
277			`sort_main_extable();`
278			`setup_lowcore_early();`
279			`sclp_readinfo_early();`
280			`sclp_facilities_detect();`
281			`memsize = sclp_memory_detect();`
282			`#ifndef CONFIG_64BIT`
283			`/*`
284			`* Can't deal with more than 2G in 31 bit addressing mode, so`
285			`* limit the value in order to avoid strange side effects.`
286			`*/`
287			`if (memsize > ADDR2G)`
288			`memsize = ADDR2G;`
289			`#endif`
290			`if (memory_fast_detect() < 0)`
291			`find_memory_chunks((unsigned long) memsize);`
292			`lockdep_on();`
293			`}`