← Back to branch summary

~martin-decky/helenos/rcu

« back to all changes in this revision

Viewing changes to kernel/arch/mips32/src/mips32.c

  • Committer: Martin Decky
  • Date: 2009-08-04 11:19:19 UTC
  • Revision ID: martin@uranus.dsrg.hide.ms.mff.cuni.cz-20090804111919-evyclddlr3v5lhmp
Initial import

Show diffs side-by-side

added added

removed removed

Lines of Context:
kernel/arch/mips32/src/mips32.c
 
1
/*
 
2
 * Copyright (c) 2003-2004 Jakub Jermar
 
3
 * All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 *
 
9
 * - Redistributions of source code must retain the above copyright
 
10
 *   notice, this list of conditions and the following disclaimer.
 
11
 * - Redistributions in binary form must reproduce the above copyright
 
12
 *   notice, this list of conditions and the following disclaimer in the
 
13
 *   documentation and/or other materials provided with the distribution.
 
14
 * - The name of the author may not be used to endorse or promote products
 
15
 *   derived from this software without specific prior written permission.
 
16
 *
 
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
27
 */
 
28
 
 
29
/** @addtogroup mips32
 
30
 * @{
 
31
 */
 
32
/** @file
 
33
 */
 
34
 
 
35
#include <arch.h>
 
36
#include <arch/cp0.h>
 
37
#include <arch/exception.h>
 
38
#include <mm/as.h>
 
39
#include <userspace.h>
 
40
#include <memstr.h>
 
41
#include <proc/thread.h>
 
42
#include <proc/uarg.h>
 
43
#include <print.h>
 
44
#include <console/console.h>
 
45
#include <syscall/syscall.h>
 
46
#include <sysinfo/sysinfo.h>
 
47
#include <arch/interrupt.h>
 
48
#include <console/chardev.h>
 
49
#include <arch/barrier.h>
 
50
#include <arch/debugger.h>
 
51
#include <genarch/fb/fb.h>
 
52
#include <genarch/fb/visuals.h>
 
53
#include <genarch/drivers/dsrln/dsrlnin.h>
 
54
#include <genarch/drivers/dsrln/dsrlnout.h>
 
55
#include <genarch/srln/srln.h>
 
56
#include <macros.h>
 
57
#include <config.h>
 
58
#include <string.h>
 
59
#include <arch/drivers/msim.h>
 
60
#include <arch/asm/regname.h>
 
61
 
 
62
/* Size of the code jumping to the exception handler code
 
63
 * - J+NOP
 
64
 */
 
65
#define EXCEPTION_JUMP_SIZE  8
 
66
 
 
67
#define TLB_EXC    ((char *) 0x80000000)
 
68
#define NORM_EXC   ((char *) 0x80000180)
 
69
#define CACHE_EXC  ((char *) 0x80000100)
 
70
 
 
71
 
 
72
/* Why the linker moves the variable 64K away in assembler
 
73
 * when not in .text section?
 
74
 */
 
75
 
 
76
/* Stack pointer saved when entering user mode */
 
77
uintptr_t supervisor_sp __attribute__ ((section (".text")));
 
78
 
 
79
size_t cpu_count = 0;
 
80
 
 
81
/** Performs mips32-specific initialization before main_bsp() is called. */
 
82
void arch_pre_main(void *entry __attribute__((unused)), bootinfo_t *bootinfo)
 
83
{
 
84
        /* Setup usermode */
 
85
        init.cnt = bootinfo->cnt;
 
86
        
 
87
        size_t i;
 
88
        for (i = 0; i < min3(bootinfo->cnt, TASKMAP_MAX_RECORDS, CONFIG_INIT_TASKS); i++) {
 
89
                init.tasks[i].addr = bootinfo->tasks[i].addr;
 
90
                init.tasks[i].size = bootinfo->tasks[i].size;
 
91
                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,
 
92
                    bootinfo->tasks[i].name);
 
93
        }
 
94
        
 
95
        for (i = 0; i < CPUMAP_MAX_RECORDS; i++) {
 
96
                if ((bootinfo->cpumap & (1 << i)) != 0)
 
97
                        cpu_count++;
 
98
        }
 
99
}
 
100
 
 
101
void arch_pre_mm_init(void)
 
102
{
 
103
        /* It is not assumed by default */
 
104
        interrupts_disable();
 
105
        
 
106
        /* Initialize dispatch table */
 
107
        exception_init();
 
108
 
 
109
        /* Copy the exception vectors to the right places */
 
110
        memcpy(TLB_EXC, (char *) tlb_refill_entry, EXCEPTION_JUMP_SIZE);
 
111
        smc_coherence_block(TLB_EXC, EXCEPTION_JUMP_SIZE);
 
112
        memcpy(NORM_EXC, (char *) exception_entry, EXCEPTION_JUMP_SIZE);
 
113
        smc_coherence_block(NORM_EXC, EXCEPTION_JUMP_SIZE);
 
114
        memcpy(CACHE_EXC, (char *) cache_error_entry, EXCEPTION_JUMP_SIZE);
 
115
        smc_coherence_block(CACHE_EXC, EXCEPTION_JUMP_SIZE);
 
116
        
 
117
        /*
 
118
         * Switch to BEV normal level so that exception vectors point to the
 
119
         * kernel. Clear the error level.
 
120
         */
 
121
        cp0_status_write(cp0_status_read() &
 
122
            ~(cp0_status_bev_bootstrap_bit | cp0_status_erl_error_bit));
 
123
        
 
124
        /*
 
125
         * Mask all interrupts
 
126
         */
 
127
        cp0_mask_all_int();
 
128
        
 
129
        debugger_init();
 
130
}
 
131
 
 
132
void arch_post_mm_init(void)
 
133
{
 
134
        interrupt_init();
 
135
        
 
136
#ifdef CONFIG_FB
 
137
        /* GXemul framebuffer */
 
138
        fb_properties_t gxemul_prop = {
 
139
                .addr = 0x12000000,
 
140
                .offset = 0,
 
141
                .x = 640,
 
142
                .y = 480,
 
143
                .scan = 1920,
 
144
                .visual = VISUAL_RGB_8_8_8,
 
145
        };
 
146
        fb_init(&gxemul_prop);
 
147
#else
 
148
#ifdef CONFIG_MIPS_PRN
 
149
        dsrlnout_init((ioport8_t *) MSIM_KBD_ADDRESS);
 
150
#endif /* CONFIG_MIPS_PRN */
 
151
#endif /* CONFIG_FB */
 
152
}
 
153
 
 
154
void arch_post_cpu_init(void)
 
155
{
 
156
}
 
157
 
 
158
void arch_pre_smp_init(void)
 
159
{
 
160
}
 
161
 
 
162
void arch_post_smp_init(void)
 
163
{
 
164
#ifdef CONFIG_MIPS_KBD
 
165
        /*
 
166
         * Initialize the msim/GXemul keyboard port. Then initialize the serial line
 
167
         * module and connect it to the msim/GXemul keyboard. Enable keyboard interrupts.
 
168
         */
 
169
        dsrlnin_instance_t *dsrlnin_instance
 
170
            = dsrlnin_init((dsrlnin_t *) MSIM_KBD_ADDRESS, MSIM_KBD_IRQ);
 
171
        if (dsrlnin_instance) {
 
172
                srln_instance_t *srln_instance = srln_init();
 
173
                if (srln_instance) {
 
174
                        indev_t *sink = stdin_wire();
 
175
                        indev_t *srln = srln_wire(srln_instance, sink);
 
176
                        dsrlnin_wire(dsrlnin_instance, srln);
 
177
                        cp0_unmask_int(MSIM_KBD_IRQ);
 
178
                }
 
179
        }
 
180
        
 
181
        /*
 
182
         * This is the necessary evil until the userspace driver is entirely
 
183
         * self-sufficient.
 
184
         */
 
185
        sysinfo_set_item_val("kbd", NULL, true);
 
186
        sysinfo_set_item_val("kbd.inr", NULL, MSIM_KBD_IRQ);
 
187
        sysinfo_set_item_val("kbd.address.virtual", NULL, MSIM_KBD_ADDRESS);
 
188
#endif
 
189
}
 
190
 
 
191
void calibrate_delay_loop(void)
 
192
{
 
193
}
 
194
 
 
195
void userspace(uspace_arg_t *kernel_uarg)
 
196
{
 
197
        /* EXL = 1, UM = 1, IE = 1 */
 
198
        cp0_status_write(cp0_status_read() | (cp0_status_exl_exception_bit |
 
199
            cp0_status_um_bit | cp0_status_ie_enabled_bit));
 
200
        cp0_epc_write((uintptr_t) kernel_uarg->uspace_entry);
 
201
        userspace_asm(((uintptr_t) kernel_uarg->uspace_stack + PAGE_SIZE), 
 
202
            (uintptr_t) kernel_uarg->uspace_uarg,
 
203
            (uintptr_t) kernel_uarg->uspace_entry);
 
204
        
 
205
        while (1);
 
206
}
 
207
 
 
208
/** Perform mips32 specific tasks needed before the new task is run. */
 
209
void before_task_runs_arch(void)
 
210
{
 
211
}
 
212
 
 
213
/** Perform mips32 specific tasks needed before the new thread is scheduled. */
 
214
void before_thread_runs_arch(void)
 
215
{
 
216
        supervisor_sp = (uintptr_t) &THREAD->kstack[THREAD_STACK_SIZE -
 
217
            SP_DELTA];
 
218
}
 
219
 
 
220
void after_thread_ran_arch(void)
 
221
{
 
222
}
 
223
 
 
224
/** Set thread-local-storage pointer
 
225
 *
 
226
 * We have it currently in K1, it is
 
227
 * possible to have it separately in the future.
 
228
 */
 
229
unative_t sys_tls_set(unative_t addr)
 
230
{
 
231
        return 0;
 
232
}
 
233
 
 
234
void arch_reboot(void)
 
235
{
 
236
        ___halt();
 
237
        while (1);
 
238
}
 
239
 
 
240
/** Construct function pointer
 
241
 *
 
242
 * @param fptr   function pointer structure
 
243
 * @param addr   function address
 
244
 * @param caller calling function address
 
245
 *
 
246
 * @return address of the function pointer
 
247
 *
 
248
 */
 
249
void *arch_construct_function(fncptr_t *fptr, void *addr, void *caller)
 
250
{
 
251
        return addr;
 
252
}
 
253
 
 
254
void arch_grab_console(void)
 
255
{
 
256
#ifdef CONFIG_FB
 
257
        fb_redraw();
 
258
#endif
 
259
}
 
260
 
 
261
/** Return console to userspace
 
262
 *
 
263
 */
 
264
void arch_release_console(void)
 
265
{
 
266
}
 
267
 
 
268
/** @}
 
269
 */