Subversion Repositories HelenOS

Rev

Rev 393 | Rev 432 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 jermar 1 
/*
2 
 * Copyright (C) 2001-2004 Jakub Jermar
393 bondari 3 
 * Copyright (C) 2005 Sergey Bondari
1 jermar 4 
 * All rights reserved.
5 
 *
6 
 * Redistribution and use in source and binary forms, with or without
7 
 * modification, are permitted provided that the following conditions
8 
 * are met:
9 
 *
10 
 * - Redistributions of source code must retain the above copyright
11 
 *   notice, this list of conditions and the following disclaimer.
12 
 * - Redistributions in binary form must reproduce the above copyright
13 
 *   notice, this list of conditions and the following disclaimer in the
14 
 *   documentation and/or other materials provided with the distribution.
15 
 * - The name of the author may not be used to endorse or promote products
16 
 *   derived from this software without specific prior written permission.
17 
 *
18 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 
 */
29 
 
11 jermar 30 
#ifndef __ia32_ASM_H__
31 
#define __ia32_ASM_H__
1 jermar 32 
 
33 
#include <arch/types.h>
177 jermar 34 
#include <config.h>
1 jermar 35 
 
36 
extern __u32 interrupt_handler_size;
37 
 
38 
extern void paging_on(void);
39 
 
40 
extern void interrupt_handlers(void);
41 
 
42 
extern void enable_l_apic_in_msr(void);
43 
 
195 vana 44 
 
45 
void asm_delay_loop(__u32 t);
46 
void asm_fake_loop(__u32 t);
47 
 
48 
 
115 jermar 49 
/** Halt CPU
50 
 *
51 
 * Halt the current CPU until interrupt event.
52 
 */
348 jermar 53 
static inline void cpu_halt(void) { __asm__("hlt\n"); };
54 
static inline void cpu_sleep(void) { __asm__("hlt\n"); };
1 jermar 55 
 
115 jermar 56 
/** Read CR2
57 
 *
58 
 * Return value in CR2
59 
 *
60 
 * @return Value read.
61 
 */
348 jermar 62 
static inline __u32 read_cr2(void) { __u32 v; __asm__ volatile ("movl %%cr2,%0\n" : "=r" (v)); return v; }
27 jermar 63 
 
115 jermar 64 
/** Write CR3
65 
 *
66 
 * Write value to CR3.
67 
 *
68 
 * @param v Value to be written.
69 
 */
70 
static inline void write_cr3(__u32 v) { __asm__ volatile ("movl %0,%%cr3\n" : : "r" (v)); }
38 jermar 71 
 
115 jermar 72 
/** Read CR3
73 
 *
74 
 * Return value in CR3
75 
 *
76 
 * @return Value read.
77 
 */
348 jermar 78 
static inline __u32 read_cr3(void) { __u32 v; __asm__ volatile ("movl %%cr3,%0\n" : "=r" (v)); return v; }
115 jermar 79 
 
352 bondari 80 
/** Byte to port
81 
 *
82 
 * Output byte to port
83 
 *
84 
 * @param port Port to write to
85 
 * @param val Value to write
86 
 */
87 
static inline void outb(__u16 port, __u8 val) { __asm__ volatile ("outb %b0, %w1\n" : : "a" (val), "d" (port) ); }
88 
 
353 bondari 89 
/** Word to port
90 
 *
91 
 * Output word to port
92 
 *
93 
 * @param port Port to write to
94 
 * @param val Value to write
95 
 */
96 
static inline void outw(__u16 port, __u16 val) { __asm__ volatile ("outw %w0, %w1\n" : : "a" (val), "d" (port) ); }
352 bondari 97 
 
353 bondari 98 
/** Double word to port
99 
 *
100 
 * Output double word to port
101 
 *
102 
 * @param port Port to write to
103 
 * @param val Value to write
104 
 */
105 
static inline void outl(__u16 port, __u32 val) { __asm__ volatile ("outl %l0, %w1\n" : : "a" (val), "d" (port) ); }
106 
 
356 bondari 107 
/** Byte from port
108 
 *
109 
 * Get byte from port
110 
 *
111 
 * @param port Port to read from
112 
 * @return Value read
113 
 */
114 
static inline __u8 inb(__u16 port) { __u8 val; __asm__ volatile ("inb %w1, %b0 \n" : "=a" (val) : "d" (port) ); return val; }
115 
 
116 
/** Word from port
117 
 *
118 
 * Get word from port
119 
 *
120 
 * @param port Port to read from
121 
 * @return Value read
122 
 */
123 
static inline __u16 inw(__u16 port) { __u16 val; __asm__ volatile ("inw %w1, %w0 \n" : "=a" (val) : "d" (port) ); return val; }
124 
 
125 
/** Double word from port
126 
 *
127 
 * Get double word from port
128 
 *
129 
 * @param port Port to read from
130 
 * @return Value read
131 
 */
132 
static inline __u32 inl(__u16 port) { __u32 val; __asm__ volatile ("inl %w1, %l0 \n" : "=a" (val) : "d" (port) ); return val; }
133 
 
413 jermar 134 
/** Enable interrupts.
115 jermar 135 
 *
136 
 * Enable interrupts and return previous
137 
 * value of EFLAGS.
413 jermar 138 
 *
139 
 * @return Old interrupt priority level.
115 jermar 140 
 */
413 jermar 141 
static inline ipl_t interrupts_enable(void) {
142 
    ipl_t v;
115 jermar 143 
    __asm__ volatile (
358 bondari 144 
        "pushf\n\t"
145 
        "popl %0\n\t"
115 jermar 146 
        "sti\n"
147 
        : "=r" (v)
148 
    );
149 
    return v;
150 
}
151 
 
413 jermar 152 
/** Disable interrupts.
115 jermar 153 
 *
154 
 * Disable interrupts and return previous
155 
 * value of EFLAGS.
413 jermar 156 
 *
157 
 * @return Old interrupt priority level.
115 jermar 158 
 */
413 jermar 159 
static inline ipl_t interrupts_disable(void) {
160 
    ipl_t v;
115 jermar 161 
    __asm__ volatile (
358 bondari 162 
        "pushf\n\t"
163 
        "popl %0\n\t"
115 jermar 164 
        "cli\n"
165 
        : "=r" (v)
166 
    );
167 
    return v;
168 
}
169 
 
413 jermar 170 
/** Restore interrupt priority level.
115 jermar 171 
 *
172 
 * Restore EFLAGS.
413 jermar 173 
 *
174 
 * @param ipl Saved interrupt priority level.
115 jermar 175 
 */
413 jermar 176 
static inline void interrupts_restore(ipl_t ipl) {
115 jermar 177 
    __asm__ volatile (
358 bondari 178 
        "pushl %0\n\t"
115 jermar 179 
        "popf\n"
413 jermar 180 
        : : "r" (ipl)
115 jermar 181 
    );
182 
}
183 
 
413 jermar 184 
/** Return interrupt priority level.
115 jermar 185 
 *
413 jermar 186 
 * @return EFLAFS.
115 jermar 187 
 */
413 jermar 188 
static inline ipl_t interrupts_read(void) {
189 
    ipl_t v;
115 jermar 190 
    __asm__ volatile (
358 bondari 191 
        "pushf\n\t"
115 jermar 192 
        "popl %0\n"
193 
        : "=r" (v)
194 
    );
195 
    return v;
196 
}
197 
 
173 jermar 198 
/** Return base address of current stack
199 
 *
200 
 * Return the base address of the current stack.
201 
 * The stack is assumed to be STACK_SIZE bytes long.
180 jermar 202 
 * The stack must start on page boundary.
173 jermar 203 
 */
204 
static inline __address get_stack_base(void)
205 
{
206 
    __address v;
207 
 
208 
    __asm__ volatile ("andl %%esp, %0\n" : "=r" (v) : "0" (~(STACK_SIZE-1)));
209 
 
210 
    return v;
211 
}
212 
 
348 jermar 213 
static inline __u64 rdtsc(void)
214 
{
215 
    __u64 v;
216 
 
217 
    __asm__ volatile("rdtsc\n" : "=A" (v));
218 
 
219 
    return v;
220 
}
221 
 
1 jermar 222 
#endif