WebSVN – HelenOS – Diff – /branches/arm/kernel/arch/arm32/src/mm/page.c


/*
 * Copyright (c) 2007 Pavel Jancik, Michal Kebrt
 * 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 arm32mm
 * @{
 */
/** @file
 */
 
#include <arch/mm/page.h>
#include <genarch/mm/page_pt.h>
#include <mm/page.h>
#include <align.h>
#include <config.h>
#include <arch/exception.h>
#include <typedefs.h>
#include <arch/types.h>
#include <interrupt.h>
#include <arch/mm/frame.h>
 
 
/**
 * Initializes kernel adress space page tables, sets abourts exceptions vectors
 */
void page_arch_init(void)
{
    uintptr_t cur;
    int flags;
 
    page_mapping_operations = &pt_mapping_operations;
 
    flags = PAGE_CACHEABLE;
 
    // PA2KA(identity) mapping for all frames until last_frame
    for (cur = 0; cur < last_frame; cur += FRAME_SIZE) {
        page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
    }
   
    // create mapping for exception table at high offset
    #ifdef HIGH_EXCEPTION_VECTORS
        /* Note: this mapping cann't be done by hw_map because fixed
            exception vector is stored at fixed virtual address
            reserve frame for exception table
        */
        void* virtaddr = frame_alloc(ONE_FRAME, FRAME_KA);
        page_mapping_insert(AS_KERNEL, EXC_BASE_ADDRESS, KA2PA(virtaddr), flags);
    #else
        #error "Only high eception vector supported now"
    #endif
 
    as_switch(NULL, AS_KERNEL);
 
    boot_page_table_free();
}
 
/**
 * Map device into kernel space.
 *
 * This function adds mapping of physical address that is read/write only
 *  from kernel and not bufferable.
 *
 * @param physaddr Physical addres where device is connected
 * @param size Length of area where device is present
 * @return Virtual address where device will be accessable
 */
uintptr_t hw_map(uintptr_t physaddr, size_t size)
{
    if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH)) {
        panic("Unable to map physical memory %p (%d bytes)", physaddr, size)
    }
 
    uintptr_t virtaddr = PA2KA(last_frame);
    pfn_t i;
    for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++) {
        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i),
            PAGE_NOT_CACHEABLE | PAGE_READ | PAGE_WRITE | PAGE_KERNEL);
    }
 
    last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
    return virtaddr;
}
 
 
/** @}
 */
 
 

Subversion Repositories HelenOS

(root)/branches/arm/kernel/arch/arm32/src/mm/page.c – Rev 2361 → 2362

Rev 2361		Rev 2362
1	/*	1	/*
2	* Copyright (c) 2007 Pavel Jancik, Michal Kebrt	2	* Copyright (c) 2007 Pavel Jancik, Michal Kebrt
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 arm32mm	29	/** @addtogroup arm32mm
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include <arch/mm/page.h>	35	#include <arch/mm/page.h>
36	#include <genarch/mm/page_pt.h>	36	#include <genarch/mm/page_pt.h>
37	#include <mm/page.h>	37	#include <mm/page.h>
38	#include <align.h>	38	#include <align.h>
39	#include <config.h>	39	#include <config.h>
40	#include <arch/exception.h>	40	#include <arch/exception.h>
41	#include <typedefs.h>	41	#include <typedefs.h>
42	#include <arch/types.h>	42	#include <arch/types.h>
43	#include <interrupt.h>	43	#include <interrupt.h>
44	#include <arch/mm/frame.h>	44	#include <arch/mm/frame.h>
45		45
46		46
47	/**	47	/**
48	* Initializes kernel adress space page tables, sets abourts exceptions vectors	48	* Initializes kernel adress space page tables, sets abourts exceptions vectors
49	*/	49	*/
50	void page_arch_init(void)	50	void page_arch_init(void)
51	{	51	{
52	uintptr_t cur;	52	uintptr_t cur;
53	int flags;	53	int flags;
54		54
55	page_mapping_operations = &pt_mapping_operations;	55	page_mapping_operations = &pt_mapping_operations;
56		56
57	flags = PAGE_CACHEABLE;	57	flags = PAGE_CACHEABLE;
58		58
59	// PA2KA(identity) mapping for all frames until last_frame	59	// PA2KA(identity) mapping for all frames until last_frame
60	for (cur = 0; cur < last_frame; cur += FRAME_SIZE) {	60	for (cur = 0; cur < last_frame; cur += FRAME_SIZE) {
61	page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);	61	page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
62	}	62	}
63		63
64	// create mapping for exception table at high offset	64	// create mapping for exception table at high offset
65	#ifdef HIGH_EXCEPTION_VECTORS	65	#ifdef HIGH_EXCEPTION_VECTORS
66	/* Note: this mapping cann't be done by hw_map because fixed	66	/* Note: this mapping cann't be done by hw_map because fixed
67	exception vector is stored at fixed virtual address	67	exception vector is stored at fixed virtual address
68	reserve frame for exception table	68	reserve frame for exception table
69	*/	69	*/
70	void* virtaddr = frame_alloc(ONE_FRAME, FRAME_KA);	70	void* virtaddr = frame_alloc(ONE_FRAME, FRAME_KA);
71	page_mapping_insert(AS_KERNEL, EXC_BASE_ADDRESS, KA2PA(virtaddr), flags);	71	page_mapping_insert(AS_KERNEL, EXC_BASE_ADDRESS, KA2PA(virtaddr), flags);
72	#else	72	#else
73	#error "Only high eception vector supported now"	73	#error "Only high eception vector supported now"
74	#endif	74	#endif
75		75
76	as_switch(NULL, AS_KERNEL);	76	as_switch(NULL, AS_KERNEL);
77		77
78	boot_page_table_free();	78	boot_page_table_free();
79	}	79	}
80		80
81	/**	81	/**
82	* Map device into kernel space.	82	* Map device into kernel space.
83	*	83	*
84	* This function adds mapping of physical address that is read/write only	84	* This function adds mapping of physical address that is read/write only
85	* from kernel and not bufferable.	85	* from kernel and not bufferable.
86	*	86	*
87	* \param physaddr Physical addres where device is connected	87	* @param physaddr Physical addres where device is connected
88	* \param size Length of area where device is present	88	* @param size Length of area where device is present
89	* \return Virtual address where device will be accessable	89	* @return Virtual address where device will be accessable
90	*/	90	*/
91	uintptr_t hw_map(uintptr_t physaddr, size_t size)	91	uintptr_t hw_map(uintptr_t physaddr, size_t size)
92	{	92	{
93	if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH)) {	93	if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH)) {
94	panic("Unable to map physical memory %p (%d bytes)", physaddr, size)	94	panic("Unable to map physical memory %p (%d bytes)", physaddr, size)
95	}	95	}
96		96
97	uintptr_t virtaddr = PA2KA(last_frame);	97	uintptr_t virtaddr = PA2KA(last_frame);
98	pfn_t i;	98	pfn_t i;
99	for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++) {	99	for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++) {
100	page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i),	100	page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i),
101	PAGE_NOT_CACHEABLE \| PAGE_READ \| PAGE_WRITE \| PAGE_KERNEL);	101	PAGE_NOT_CACHEABLE \| PAGE_READ \| PAGE_WRITE \| PAGE_KERNEL);
102	}	102	}
103		103
104	last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);	104	last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
105	return virtaddr;	105	return virtaddr;
106	}	106	}
107		107
108		108
109	/** @}	109	/** @}
110	*/	110	*/
111		111
112		112