WebSVN – HelenOS – Diff – /trunk/kernel/arch/ppc32/src/ppc32.c


/*
 * Copyright (c) 2005 Martin Decky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup ppc32
 * @{
 */
/** @file
 */
 
#include <config.h>
#include <arch.h>
#include <arch/boot/boot.h>
#include <genarch/drivers/via-cuda/cuda.h>
#include <genarch/kbrd/kbrd.h>
#include <arch/interrupt.h>
#include <genarch/fb/fb.h>
#include <genarch/fb/visuals.h>
#include <userspace.h>
#include <proc/uarg.h>
#include <console/console.h>
#include <ddi/irq.h>
#include <arch/drivers/pic.h>
#include <align.h>
#include <macros.h>
#include <string.h>
 
#define IRQ_COUNT  64
#define IRQ_CUDA   10
 
bootinfo_t bootinfo;
 
/** Performs ppc32-specific initialization before main_bsp() is called. */
void arch_pre_main(void)
{
    init.cnt = bootinfo.taskmap.count;
   
    uint32_t i;
   
    for (i = 0; i < min3(bootinfo.taskmap.count, TASKMAP_MAX_RECORDS, CONFIG_INIT_TASKS); i++) {
        init.tasks[i].addr = PA2KA(bootinfo.taskmap.tasks[i].addr);
        init.tasks[i].size = bootinfo.taskmap.tasks[i].size;
        str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,
            bootinfo.taskmap.tasks[i].name);
    }
}
 
void arch_pre_mm_init(void)
{
    /* Initialize dispatch table */
    interrupt_init();
 
    /* Start decrementer */
    start_decrementer();
}
 
void arch_post_mm_init(void)
{
    if (config.cpu_active == 1) {
 
#ifdef CONFIG_FB
        /* Initialize framebuffer */
        if (bootinfo.screen.addr) {
            unsigned int visual;
           
            switch (bootinfo.screen.bpp) {
            case 8:
                visual = VISUAL_INDIRECT_8;
                break;
            case 16:
                visual = VISUAL_RGB_5_5_5_BE;
                break;
            case 24:
                visual = VISUAL_BGR_8_8_8;
                break;
            case 32:
                visual = VISUAL_RGB_0_8_8_8;
                break;
            default:
                panic("Unsupported bits per pixel.");
            }
            fb_properties_t prop = {
                .addr = bootinfo.screen.addr,
                .offset = 0,
                .x = bootinfo.screen.width,
                .y = bootinfo.screen.height,
                .scan = bootinfo.screen.scanline,
                .visual = visual,
            };
            fb_init(&prop);
        }
#endif
       
        /* Initialize IRQ routing */
        irq_init(IRQ_COUNT, IRQ_COUNT);
       
        /* Merge all zones to 1 big zone */
        zone_merge_all();
    }
}
 
void arch_post_cpu_init(void)
{
}
 
void arch_pre_smp_init(void)
{
}
 
void arch_post_smp_init(void)
{
    if (bootinfo.macio.addr) {
        /* Initialize PIC */
        cir_t cir;
        void *cir_arg;
        pic_init(bootinfo.macio.addr, PAGE_SIZE, &cir, &cir_arg);
 
#ifdef CONFIG_MAC_KBD
        uintptr_t pa = bootinfo.macio.addr + 0x16000;
        uintptr_t aligned_addr = ALIGN_DOWN(pa, PAGE_SIZE);
        size_t offset = pa - aligned_addr;
        size_t size = 2 * PAGE_SIZE;
           
        cuda_t *cuda = (cuda_t *)
            (hw_map(aligned_addr, offset + size) + offset);
           
        /* Initialize I/O controller */
        cuda_instance_t *cuda_instance =
            cuda_init(cuda, IRQ_CUDA, cir, cir_arg);
        if (cuda_instance) {
            kbrd_instance_t *kbrd_instance = kbrd_init();
            if (kbrd_instance) {
                indev_t *sink = stdin_wire();
                indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
                cuda_wire(cuda_instance, kbrd);
                pic_enable_interrupt(IRQ_CUDA);
            }
        }
#endif
    }
}
 
void calibrate_delay_loop(void)
{
}
 
void userspace(uspace_arg_t *kernel_uarg)
{
    userspace_asm((uintptr_t) kernel_uarg->uspace_uarg,
        (uintptr_t) kernel_uarg->uspace_stack +
        THREAD_STACK_SIZE - SP_DELTA,
        (uintptr_t) kernel_uarg->uspace_entry);
   
    /* Unreachable */
    while (true);
}
 
/** Acquire console back for kernel
 *
 */
void arch_grab_console(void)
{
#ifdef CONFIG_FB
    fb_redraw();
#endif
}
 
/** Return console to userspace
 *
 */
void arch_release_console(void)
{
}
 
/** Construct function pointer
 *
 * @param fptr   function pointer structure
 * @param addr   function address
 * @param caller calling function address
 *
 * @return address of the function pointer
 *
 */
void *arch_construct_function(fncptr_t *fptr, void *addr, void *caller)
{
    return addr;
}
 
void arch_reboot(void)
{
    // TODO
    while (1);
}
 
/** @}
 */
 

Rev 4676	Rev 4685
1	/*	1	/*
2	* Copyright (c) 2005 Martin Decky	2	* Copyright (c) 2005 Martin Decky
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	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	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.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	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	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	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	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	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	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.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup ppc32	29	/** @addtogroup ppc32
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include <config.h>	35	#include <config.h>
36	#include <arch.h>	36	#include <arch.h>
37	#include <arch/boot/boot.h>	37	#include <arch/boot/boot.h>
38	#include <genarch/drivers/via-cuda/cuda.h>	38	#include <genarch/drivers/via-cuda/cuda.h>
39	#include <genarch/kbrd/kbrd.h>	39	#include <genarch/kbrd/kbrd.h>
40	#include <arch/interrupt.h>	40	#include <arch/interrupt.h>
41	#include <genarch/fb/fb.h>	41	#include <genarch/fb/fb.h>
42	#include <genarch/fb/visuals.h>	42	#include <genarch/fb/visuals.h>
43	#include <userspace.h>	43	#include <userspace.h>
44	#include <proc/uarg.h>	44	#include <proc/uarg.h>
45	#include <console/console.h>	45	#include <console/console.h>
46	#include <ddi/irq.h>	46	#include <ddi/irq.h>
47	#include <arch/drivers/pic.h>	47	#include <arch/drivers/pic.h>
48	#include <align.h>	48	#include <align.h>
49	#include <macros.h>	49	#include <macros.h>
50	#include <string.h>	50	#include <string.h>
51		51
52	#define IRQ_COUNT 64	52	#define IRQ_COUNT 64
53	#define IRQ_CUDA 10	53	#define IRQ_CUDA 10
54		54
55	bootinfo_t bootinfo;	55	bootinfo_t bootinfo;
56		56
57	/** Performs ppc32-specific initialization before main_bsp() is called. */	57	/** Performs ppc32-specific initialization before main_bsp() is called. */
58	void arch_pre_main(void)	58	void arch_pre_main(void)
59	{	59	{
60	init.cnt = bootinfo.taskmap.count;	60	init.cnt = bootinfo.taskmap.count;
61		61
62	uint32_t i;	62	uint32_t i;
63		63
64	for (i = 0; i < min3(bootinfo.taskmap.count, TASKMAP_MAX_RECORDS, CONFIG_INIT_TASKS); i++) {	64	for (i = 0; i < min3(bootinfo.taskmap.count, TASKMAP_MAX_RECORDS, CONFIG_INIT_TASKS); i++) {
65	init.tasks[i].addr = PA2KA(bootinfo.taskmap.tasks[i].addr);	65	init.tasks[i].addr = PA2KA(bootinfo.taskmap.tasks[i].addr);
66	init.tasks[i].size = bootinfo.taskmap.tasks[i].size;	66	init.tasks[i].size = bootinfo.taskmap.tasks[i].size;
67	str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,	67	str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,
68	bootinfo.taskmap.tasks[i].name);	68	bootinfo.taskmap.tasks[i].name);
69	}	69	}
70	}	70	}
71		71
72	void arch_pre_mm_init(void)	72	void arch_pre_mm_init(void)
73	{	73	{
74	/* Initialize dispatch table */	74	/* Initialize dispatch table */
75	interrupt_init();	75	interrupt_init();
76		76
77	/* Start decrementer */	77	/* Start decrementer */
78	start_decrementer();	78	start_decrementer();
79	}	79	}
80		80
81	void arch_post_mm_init(void)	81	void arch_post_mm_init(void)
82	{	82	{
83	if (config.cpu_active == 1) {	83	if (config.cpu_active == 1) {
84		84
85	#ifdef CONFIG_FB	85	#ifdef CONFIG_FB
86	/* Initialize framebuffer */	86	/* Initialize framebuffer */
87	if (bootinfo.screen.addr) {	87	if (bootinfo.screen.addr) {
88	unsigned int visual;	88	unsigned int visual;
89		89
90	switch (bootinfo.screen.bpp) {	90	switch (bootinfo.screen.bpp) {
91	case 8:	91	case 8:
92	visual = VISUAL_INDIRECT_8;	92	visual = VISUAL_INDIRECT_8;
93	break;	93	break;
94	case 16:	94	case 16:
95	visual = VISUAL_BGR_5_5_5;	95	visual = VISUAL_RGB_5_5_5_BE;
96	break;	96	break;
97	case 24:	97	case 24:
98	visual = VISUAL_BGR_8_8_8;	98	visual = VISUAL_BGR_8_8_8;
99	break;	99	break;
100	case 32:	100	case 32:
101	visual = VISUAL_RGB_0_8_8_8;	101	visual = VISUAL_RGB_0_8_8_8;
102	break;	102	break;
103	default:	103	default:
104	panic("Unsupported bits per pixel.");	104	panic("Unsupported bits per pixel.");
105	}	105	}
106	fb_properties_t prop = {	106	fb_properties_t prop = {
107	.addr = bootinfo.screen.addr,	107	.addr = bootinfo.screen.addr,
108	.offset = 0,	108	.offset = 0,
109	.x = bootinfo.screen.width,	109	.x = bootinfo.screen.width,
110	.y = bootinfo.screen.height,	110	.y = bootinfo.screen.height,
111	.scan = bootinfo.screen.scanline,	111	.scan = bootinfo.screen.scanline,
112	.visual = visual,	112	.visual = visual,
113	};	113	};
114	fb_init(&prop);	114	fb_init(&prop);
115	}	115	}
116	#endif	116	#endif
117		117
118	/* Initialize IRQ routing */	118	/* Initialize IRQ routing */
119	irq_init(IRQ_COUNT, IRQ_COUNT);	119	irq_init(IRQ_COUNT, IRQ_COUNT);
120		120
121	/* Merge all zones to 1 big zone */	121	/* Merge all zones to 1 big zone */
122	zone_merge_all();	122	zone_merge_all();
123	}	123	}
124	}	124	}
125		125
126	void arch_post_cpu_init(void)	126	void arch_post_cpu_init(void)
127	{	127	{
128	}	128	}
129		129
130	void arch_pre_smp_init(void)	130	void arch_pre_smp_init(void)
131	{	131	{
132	}	132	}
133		133
134	void arch_post_smp_init(void)	134	void arch_post_smp_init(void)
135	{	135	{
136	if (bootinfo.macio.addr) {	136	if (bootinfo.macio.addr) {
137	/* Initialize PIC */	137	/* Initialize PIC */
138	cir_t cir;	138	cir_t cir;
139	void *cir_arg;	139	void *cir_arg;
140	pic_init(bootinfo.macio.addr, PAGE_SIZE, &cir, &cir_arg);	140	pic_init(bootinfo.macio.addr, PAGE_SIZE, &cir, &cir_arg);
141		141
142	#ifdef CONFIG_MAC_KBD	142	#ifdef CONFIG_MAC_KBD
143	uintptr_t pa = bootinfo.macio.addr + 0x16000;	143	uintptr_t pa = bootinfo.macio.addr + 0x16000;
144	uintptr_t aligned_addr = ALIGN_DOWN(pa, PAGE_SIZE);	144	uintptr_t aligned_addr = ALIGN_DOWN(pa, PAGE_SIZE);
145	size_t offset = pa - aligned_addr;	145	size_t offset = pa - aligned_addr;
146	size_t size = 2 * PAGE_SIZE;	146	size_t size = 2 * PAGE_SIZE;
147		147
148	cuda_t cuda = (cuda_t )	148	cuda_t cuda = (cuda_t )
149	(hw_map(aligned_addr, offset + size) + offset);	149	(hw_map(aligned_addr, offset + size) + offset);
150		150
151	/* Initialize I/O controller */	151	/* Initialize I/O controller */
152	cuda_instance_t *cuda_instance =	152	cuda_instance_t *cuda_instance =
153	cuda_init(cuda, IRQ_CUDA, cir, cir_arg);	153	cuda_init(cuda, IRQ_CUDA, cir, cir_arg);
154	if (cuda_instance) {	154	if (cuda_instance) {
155	kbrd_instance_t *kbrd_instance = kbrd_init();	155	kbrd_instance_t *kbrd_instance = kbrd_init();
156	if (kbrd_instance) {	156	if (kbrd_instance) {
157	indev_t *sink = stdin_wire();	157	indev_t *sink = stdin_wire();
158	indev_t *kbrd = kbrd_wire(kbrd_instance, sink);	158	indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
159	cuda_wire(cuda_instance, kbrd);	159	cuda_wire(cuda_instance, kbrd);
160	pic_enable_interrupt(IRQ_CUDA);	160	pic_enable_interrupt(IRQ_CUDA);
161	}	161	}
162	}	162	}
163	#endif	163	#endif
164	}	164	}
165	}	165	}
166		166
167	void calibrate_delay_loop(void)	167	void calibrate_delay_loop(void)
168	{	168	{
169	}	169	}
170		170
171	void userspace(uspace_arg_t *kernel_uarg)	171	void userspace(uspace_arg_t *kernel_uarg)
172	{	172	{
173	userspace_asm((uintptr_t) kernel_uarg->uspace_uarg,	173	userspace_asm((uintptr_t) kernel_uarg->uspace_uarg,
174	(uintptr_t) kernel_uarg->uspace_stack +	174	(uintptr_t) kernel_uarg->uspace_stack +
175	THREAD_STACK_SIZE - SP_DELTA,	175	THREAD_STACK_SIZE - SP_DELTA,
176	(uintptr_t) kernel_uarg->uspace_entry);	176	(uintptr_t) kernel_uarg->uspace_entry);
177		177
178	/* Unreachable */	178	/* Unreachable */
179	while (true);	179	while (true);
180	}	180	}
181		181
182	/** Acquire console back for kernel	182	/** Acquire console back for kernel
183	*	183	*
184	*/	184	*/
185	void arch_grab_console(void)	185	void arch_grab_console(void)
186	{	186	{
187	#ifdef CONFIG_FB	187	#ifdef CONFIG_FB
188	fb_redraw();	188	fb_redraw();
189	#endif	189	#endif
190	}	190	}
191		191
192	/** Return console to userspace	192	/** Return console to userspace
193	*	193	*
194	*/	194	*/
195	void arch_release_console(void)	195	void arch_release_console(void)
196	{	196	{
197	}	197	}
198		198
199	/** Construct function pointer	199	/** Construct function pointer
200	*	200	*
201	* @param fptr function pointer structure	201	* @param fptr function pointer structure
202	* @param addr function address	202	* @param addr function address
203	* @param caller calling function address	203	* @param caller calling function address
204	*	204	*
205	* @return address of the function pointer	205	* @return address of the function pointer
206	*	206	*
207	*/	207	*/
208	void arch_construct_function(fncptr_t fptr, void addr, void caller)	208	void arch_construct_function(fncptr_t fptr, void addr, void caller)
209	{	209	{
210	return addr;	210	return addr;
211	}	211	}
212		212
213	void arch_reboot(void)	213	void arch_reboot(void)
214	{	214	{
215	// TODO	215	// TODO
216	while (1);	216	while (1);
217	}	217	}
218		218
219	/** @}	219	/** @}
220	*/	220	*/
221		221

Subversion Repositories HelenOS

(root)/trunk/kernel/arch/ppc32/src/ppc32.c – Rev 4676 → 4685