← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/seabios/oneiric

« back to all changes in this revision

Viewing changes to .pc/0038-Unify-optionrom-cbfs-qemu_cfg-rom-pulling-code.patch/src/util.h

  • Committer: Bazaar Package Importer
  • Author(s): Serge Hallyn
  • Date: 2010-10-22 11:04:31 UTC
  • Revision ID: james.westby@ubuntu.com-20101022110431-fnfj73ra6xkq623n
Tags: 0.6.0-0ubuntu2
Add all patches which were included in qemu-0.13.0-rc2 (per
commit on Jul 13, 2010).

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/0038-Unify-optionrom-cbfs-qemu_cfg-rom-pulling-code.patch/src/util.h
 
1
// Basic x86 asm functions and function defs.
 
2
//
 
3
// Copyright (C) 2008,2009  Kevin O'Connor <kevin@koconnor.net>
 
4
//
 
5
// This file may be distributed under the terms of the GNU LGPLv3 license.
 
6
#ifndef __UTIL_H
 
7
#define __UTIL_H
 
8
 
 
9
#include "types.h" // u32
 
10
 
 
11
static inline void irq_disable(void)
 
12
{
 
13
    asm volatile("cli": : :"memory");
 
14
}
 
15
 
 
16
static inline void irq_enable(void)
 
17
{
 
18
    asm volatile("sti": : :"memory");
 
19
}
 
20
 
 
21
static inline unsigned long irq_save(void)
 
22
{
 
23
    unsigned long flags;
 
24
    asm volatile("pushfl ; popl %0" : "=g" (flags): :"memory");
 
25
    irq_disable();
 
26
    return flags;
 
27
}
 
28
 
 
29
static inline void irq_restore(unsigned long flags)
 
30
{
 
31
    asm volatile("pushl %0 ; popfl" : : "g" (flags) : "memory", "cc");
 
32
}
 
33
 
 
34
static inline void cpu_relax(void)
 
35
{
 
36
    asm volatile("rep ; nop": : :"memory");
 
37
}
 
38
 
 
39
static inline void nop(void)
 
40
{
 
41
    asm volatile("nop");
 
42
}
 
43
 
 
44
static inline void hlt(void)
 
45
{
 
46
    asm volatile("hlt": : :"memory");
 
47
}
 
48
 
 
49
static inline void wbinvd(void)
 
50
{
 
51
    asm volatile("wbinvd": : :"memory");
 
52
}
 
53
 
 
54
#define CPUID_MSR (1 << 5)
 
55
#define CPUID_APIC (1 << 9)
 
56
#define CPUID_MTRR (1 << 12)
 
57
static inline void cpuid(u32 index, u32 *eax, u32 *ebx, u32 *ecx, u32 *edx)
 
58
{
 
59
    asm("cpuid"
 
60
        : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx)
 
61
        : "0" (index));
 
62
}
 
63
 
 
64
static inline u64 rdmsr(u32 index)
 
65
{
 
66
    u64 ret;
 
67
    asm ("rdmsr" : "=A"(ret) : "c"(index));
 
68
    return ret;
 
69
}
 
70
 
 
71
static inline void wrmsr(u32 index, u64 val)
 
72
{
 
73
    asm volatile ("wrmsr" : : "c"(index), "A"(val));
 
74
}
 
75
 
 
76
static inline u64 rdtscll(void)
 
77
{
 
78
    u64 val;
 
79
    asm volatile("rdtsc" : "=A" (val));
 
80
    return val;
 
81
}
 
82
 
 
83
static inline u32 __ffs(u32 word)
 
84
{
 
85
    asm("bsf %1,%0"
 
86
        : "=r" (word)
 
87
        : "rm" (word));
 
88
    return word;
 
89
}
 
90
static inline u32 __fls(u32 word)
 
91
{
 
92
    asm("bsr %1,%0"
 
93
        : "=r" (word)
 
94
        : "rm" (word));
 
95
    return word;
 
96
}
 
97
 
 
98
static inline u16 __htons_constant(u16 val) {
 
99
    return (val<<8) | (val>>8);
 
100
}
 
101
static inline u32 __htonl_constant(u32 val) {
 
102
    return (val<<24) | ((val&0xff00)<<8) | ((val&0xff0000)>>8) | (val>>24);
 
103
}
 
104
static inline u32 __htonl(u32 val) {
 
105
    asm("bswapl %0" : "+r"(val));
 
106
    return val;
 
107
}
 
108
#define htonl(x) (__builtin_constant_p((u32)(x)) ? __htonl_constant(x) : __htonl(x))
 
109
#define ntohl(x) htonl(x)
 
110
#define htons(x) __htons_constant(x)
 
111
#define ntohs(x) htons(x)
 
112
 
 
113
static inline u32 getesp(void) {
 
114
    u32 esp;
 
115
    asm("movl %%esp, %0" : "=rm"(esp));
 
116
    return esp;
 
117
}
 
118
 
 
119
static inline void writel(void *addr, u32 val) {
 
120
    *(volatile u32 *)addr = val;
 
121
}
 
122
static inline void writew(void *addr, u16 val) {
 
123
    *(volatile u16 *)addr = val;
 
124
}
 
125
static inline void writeb(void *addr, u8 val) {
 
126
    *(volatile u8 *)addr = val;
 
127
}
 
128
static inline u32 readl(const void *addr) {
 
129
    return *(volatile const u32 *)addr;
 
130
}
 
131
static inline u16 readw(const void *addr) {
 
132
    return *(volatile const u16 *)addr;
 
133
}
 
134
static inline u8 readb(const void *addr) {
 
135
    return *(volatile const u8 *)addr;
 
136
}
 
137
 
 
138
#define call16_simpint(nr, peax, pflags) do {                           \
 
139
        ASSERT16();                                                     \
 
140
        asm volatile(                                                   \
 
141
            "pushl %%ebp\n"                                             \
 
142
            "sti\n"                                                     \
 
143
            "stc\n"                                                     \
 
144
            "int %2\n"                                                  \
 
145
            "pushfl\n"                                                  \
 
146
            "popl %1\n"                                                 \
 
147
            "cli\n"                                                     \
 
148
            "cld\n"                                                     \
 
149
            "popl %%ebp"                                                \
 
150
            : "+a"(*peax), "=c"(*pflags)                                \
 
151
            : "i"(nr)                                                   \
 
152
            : "ebx", "edx", "esi", "edi", "cc", "memory");              \
 
153
    } while (0)
 
154
 
 
155
// GDT bit manipulation
 
156
#define GDT_BASE(v)  ((((u64)(v) & 0xff000000) << 32)           \
 
157
                      | (((u64)(v) & 0x00ffffff) << 16))
 
158
#define GDT_LIMIT(v) ((((u64)(v) & 0x000f0000) << 32)   \
 
159
                      | (((u64)(v) & 0x0000ffff) << 0))
 
160
#define GDT_CODE     (0x9bULL << 40) // Code segment - P,R,A bits also set
 
161
#define GDT_DATA     (0x93ULL << 40) // Data segment - W,A bits also set
 
162
#define GDT_B        (0x1ULL << 54)  // Big flag
 
163
#define GDT_G        (0x1ULL << 55)  // Granularity flag
 
164
 
 
165
struct descloc_s {
 
166
    u16 length;
 
167
    u32 addr;
 
168
} PACKED;
 
169
 
 
170
// util.c
 
171
struct bregs;
 
172
inline void call16(struct bregs *callregs);
 
173
inline void call16big(struct bregs *callregs);
 
174
inline void __call16_int(struct bregs *callregs, u16 offset);
 
175
#define call16_int(nr, callregs) do {                           \
 
176
        extern void irq_trampoline_ ##nr ();                    \
 
177
        __call16_int((callregs), (u32)&irq_trampoline_ ##nr );  \
 
178
    } while (0)
 
179
u8 checksum_far(u16 buf_seg, void *buf_far, u32 len);
 
180
u8 checksum(void *buf, u32 len);
 
181
size_t strlen(const char *s);
 
182
int memcmp(const void *s1, const void *s2, size_t n);
 
183
int strcmp(const char *s1, const char *s2);
 
184
inline void memset_far(u16 d_seg, void *d_far, u8 c, size_t len);
 
185
inline void memset16_far(u16 d_seg, void *d_far, u16 c, size_t len);
 
186
void *memset(void *s, int c, size_t n);
 
187
inline void memcpy_far(u16 d_seg, void *d_far
 
188
                       , u16 s_seg, const void *s_far, size_t len);
 
189
void memcpy_fl(void *d_fl, const void *s_fl, size_t len);
 
190
void *memcpy(void *d1, const void *s1, size_t len);
 
191
#if MODESEGMENT == 0
 
192
#define memcpy __builtin_memcpy
 
193
#endif
 
194
void iomemcpy(void *d, const void *s, u32 len);
 
195
void *memmove(void *d, const void *s, size_t len);
 
196
char *strtcpy(char *dest, const char *src, size_t len);
 
197
int get_keystroke(int msec);
 
198
 
 
199
// stacks.c
 
200
inline u32 stack_hop(u32 eax, u32 edx, void *func);
 
201
extern struct thread_info MainThread;
 
202
void thread_setup(void);
 
203
struct thread_info *getCurThread(void);
 
204
void yield(void);
 
205
void wait_irq(void);
 
206
void run_thread(void (*func)(void*), void *data);
 
207
void wait_threads(void);
 
208
struct mutex_s { u32 isLocked; };
 
209
void mutex_lock(struct mutex_s *mutex);
 
210
void mutex_unlock(struct mutex_s *mutex);
 
211
void start_preempt(void);
 
212
void finish_preempt(void);
 
213
int wait_preempt(void);
 
214
void check_preempt(void);
 
215
 
 
216
// output.c
 
217
void debug_serial_setup(void);
 
218
void panic(const char *fmt, ...)
 
219
    __attribute__ ((format (printf, 1, 2))) __noreturn;
 
220
void printf(const char *fmt, ...)
 
221
    __attribute__ ((format (printf, 1, 2)));
 
222
int snprintf(char *str, size_t size, const char *fmt, ...)
 
223
    __attribute__ ((format (printf, 3, 4)));
 
224
void __dprintf(const char *fmt, ...)
 
225
    __attribute__ ((format (printf, 1, 2)));
 
226
void __debug_enter(struct bregs *regs, const char *fname);
 
227
void __debug_isr(const char *fname);
 
228
void __debug_stub(struct bregs *regs, int lineno, const char *fname);
 
229
void __warn_invalid(struct bregs *regs, int lineno, const char *fname);
 
230
void __warn_unimplemented(struct bregs *regs, int lineno, const char *fname);
 
231
void __warn_internalerror(int lineno, const char *fname);
 
232
void __warn_noalloc(int lineno, const char *fname);
 
233
void __warn_timeout(int lineno, const char *fname);
 
234
void __set_invalid(struct bregs *regs, int lineno, const char *fname);
 
235
void __set_unimplemented(struct bregs *regs, int lineno, const char *fname);
 
236
void __set_code_invalid(struct bregs *regs, u32 linecode, const char *fname);
 
237
void __set_code_unimplemented(struct bregs *regs, u32 linecode
 
238
                              , const char *fname);
 
239
void hexdump(const void *d, int len);
 
240
 
 
241
#define dprintf(lvl, fmt, args...) do {                         \
 
242
        if (CONFIG_DEBUG_LEVEL && (lvl) <= CONFIG_DEBUG_LEVEL)  \
 
243
            __dprintf((fmt) , ##args );                         \
 
244
    } while (0)
 
245
#define debug_enter(regs, lvl) do {                     \
 
246
        if ((lvl) && (lvl) <= CONFIG_DEBUG_LEVEL)       \
 
247
            __debug_enter((regs), __func__);            \
 
248
    } while (0)
 
249
#define debug_isr(lvl) do {                             \
 
250
        if ((lvl) && (lvl) <= CONFIG_DEBUG_LEVEL)       \
 
251
            __debug_isr(__func__);                      \
 
252
    } while (0)
 
253
#define debug_stub(regs)                        \
 
254
    __debug_stub((regs), __LINE__, __func__)
 
255
#define warn_invalid(regs)                      \
 
256
    __warn_invalid((regs), __LINE__, __func__)
 
257
#define warn_unimplemented(regs)                        \
 
258
    __warn_unimplemented((regs), __LINE__, __func__)
 
259
#define warn_internalerror()                    \
 
260
    __warn_internalerror(__LINE__, __func__)
 
261
#define warn_noalloc()                          \
 
262
    __warn_noalloc(__LINE__, __func__)
 
263
#define warn_timeout()                          \
 
264
    __warn_timeout(__LINE__, __func__)
 
265
#define set_invalid(regs)                       \
 
266
    __set_invalid((regs), __LINE__, __func__)
 
267
#define set_code_invalid(regs, code)                                    \
 
268
    __set_code_invalid((regs), (code) | (__LINE__ << 8), __func__)
 
269
#define set_unimplemented(regs)                         \
 
270
    __set_unimplemented((regs), __LINE__, __func__)
 
271
#define set_code_unimplemented(regs, code)                              \
 
272
    __set_code_unimplemented((regs), (code) | (__LINE__ << 8), __func__)
 
273
 
 
274
// kbd.c
 
275
void kbd_setup(void);
 
276
void handle_15c2(struct bregs *regs);
 
277
void process_key(u8 key);
 
278
 
 
279
// mouse.c
 
280
void mouse_setup(void);
 
281
void process_mouse(u8 data);
 
282
 
 
283
// system.c
 
284
extern u32 RamSize;
 
285
extern u64 RamSizeOver4G;
 
286
void mathcp_setup(void);
 
287
 
 
288
// serial.c
 
289
void serial_setup(void);
 
290
void lpt_setup(void);
 
291
 
 
292
// clock.c
 
293
#define PIT_TICK_RATE 1193180   // Underlying HZ of PIT
 
294
#define PIT_TICK_INTERVAL 65536 // Default interval for 18.2Hz timer
 
295
static inline int check_tsc(u64 end) {
 
296
    return (s64)(rdtscll() - end) > 0;
 
297
}
 
298
void timer_setup(void);
 
299
void ndelay(u32 count);
 
300
void udelay(u32 count);
 
301
void mdelay(u32 count);
 
302
void nsleep(u32 count);
 
303
void usleep(u32 count);
 
304
void msleep(u32 count);
 
305
u64 calc_future_tsc(u32 msecs);
 
306
u64 calc_future_tsc_usec(u32 usecs);
 
307
u32 calc_future_timer_ticks(u32 count);
 
308
u32 calc_future_timer(u32 msecs);
 
309
int check_timer(u32 end);
 
310
void handle_1583(struct bregs *regs);
 
311
void handle_1586(struct bregs *regs);
 
312
void useRTC(void);
 
313
void releaseRTC(void);
 
314
 
 
315
// apm.c
 
316
void handle_1553(struct bregs *regs);
 
317
 
 
318
// pcibios.c
 
319
void handle_1ab1(struct bregs *regs);
 
320
void bios32_setup(void);
 
321
 
 
322
// shadow.c
 
323
void make_bios_writable(void);
 
324
void make_bios_readonly(void);
 
325
 
 
326
// pciinit.c
 
327
void pci_setup(void);
 
328
 
 
329
// smm.c
 
330
void smm_init(void);
 
331
 
 
332
// smp.c
 
333
extern u32 CountCPUs;
 
334
extern u32 MaxCountCPUs;
 
335
void wrmsr_smp(u32 index, u64 val);
 
336
void smp_probe(void);
 
337
void smp_probe_setup(void);
 
338
 
 
339
// coreboot.c
 
340
struct cbfs_file;
 
341
struct cbfs_file *cbfs_findprefix(const char *prefix, struct cbfs_file *last);
 
342
u32 cbfs_datasize(struct cbfs_file *file);
 
343
const char *cbfs_filename(struct cbfs_file *file);
 
344
int cbfs_copyfile(struct cbfs_file *file, void *dst, u32 maxlen);
 
345
int cbfs_copy_optionrom(void *dst, u32 maxlen, u32 vendev);
 
346
void cbfs_run_payload(struct cbfs_file *file);
 
347
 
 
348
void coreboot_copy_biostable(void);
 
349
void coreboot_setup(void);
 
350
 
 
351
// vgahooks.c
 
352
extern int VGAbdf;
 
353
void handle_155f(struct bregs *regs);
 
354
void vgahook_setup(const char *vendor, const char *part);
 
355
 
 
356
// optionroms.c
 
357
void call_bcv(u16 seg, u16 ip);
 
358
void optionrom_setup(void);
 
359
void vga_setup(void);
 
360
void s3_resume_vga_init(void);
 
361
extern u32 RomEnd;
 
362
 
 
363
// resume.c
 
364
void init_dma(void);
 
365
 
 
366
// pnpbios.c
 
367
#define PNP_SIGNATURE 0x506e5024 // $PnP
 
368
u16 get_pnp_offset(void);
 
369
void pnp_setup(void);
 
370
 
 
371
// pmm.c
 
372
extern struct zone_s ZoneLow, ZoneHigh, ZoneFSeg, ZoneTmpLow, ZoneTmpHigh;
 
373
void malloc_setup(void);
 
374
void malloc_finalize(void);
 
375
void *pmm_malloc(struct zone_s *zone, u32 handle, u32 size, u32 align);
 
376
int pmm_free(void *data);
 
377
void pmm_setup(void);
 
378
void pmm_finalize(void);
 
379
#define PMM_DEFAULT_HANDLE 0xFFFFFFFF
 
380
// Minimum alignment of malloc'd memory
 
381
#define MALLOC_MIN_ALIGN 16
 
382
// Helper functions for memory allocation.
 
383
static inline void *malloc_low(u32 size) {
 
384
    return pmm_malloc(&ZoneLow, PMM_DEFAULT_HANDLE, size, MALLOC_MIN_ALIGN);
 
385
}
 
386
static inline void *malloc_high(u32 size) {
 
387
    return pmm_malloc(&ZoneHigh, PMM_DEFAULT_HANDLE, size, MALLOC_MIN_ALIGN);
 
388
}
 
389
static inline void *malloc_fseg(u32 size) {
 
390
    return pmm_malloc(&ZoneFSeg, PMM_DEFAULT_HANDLE, size, MALLOC_MIN_ALIGN);
 
391
}
 
392
static inline void *malloc_tmphigh(u32 size) {
 
393
    return pmm_malloc(&ZoneTmpHigh, PMM_DEFAULT_HANDLE, size, MALLOC_MIN_ALIGN);
 
394
}
 
395
static inline void *malloc_tmp(u32 size) {
 
396
    void *ret = malloc_tmphigh(size);
 
397
    if (ret)
 
398
        return ret;
 
399
    return pmm_malloc(&ZoneTmpLow, PMM_DEFAULT_HANDLE, size, MALLOC_MIN_ALIGN);
 
400
}
 
401
static inline void *memalign_low(u32 align, u32 size) {
 
402
    return pmm_malloc(&ZoneLow, PMM_DEFAULT_HANDLE, size, align);
 
403
}
 
404
static inline void *memalign_high(u32 align, u32 size) {
 
405
    return pmm_malloc(&ZoneHigh, PMM_DEFAULT_HANDLE, size, align);
 
406
}
 
407
static inline void *memalign_tmphigh(u32 align, u32 size) {
 
408
    return pmm_malloc(&ZoneTmpHigh, PMM_DEFAULT_HANDLE, size, align);
 
409
}
 
410
static inline void free(void *data) {
 
411
    pmm_free(data);
 
412
}
 
413
 
 
414
// mtrr.c
 
415
void mtrr_setup(void);
 
416
 
 
417
// romlayout.S
 
418
void reset_vector(void) __noreturn;
 
419
 
 
420
// misc.c
 
421
extern u8 BiosChecksum;
 
422
 
 
423
// version (auto generated file out/version.c)
 
424
extern const char VERSION[];
 
425
 
 
426
#endif // util.h