← Back to branch summary

~ubuntu-branches/ubuntu/precise/seabios/precise-updates

« back to all changes in this revision

Viewing changes to .pc/0033-Introduce-memcpy_fl-a-memcpy-on-flat-pointers.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/0033-Introduce-memcpy_fl-a-memcpy-on-flat-pointers.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(void *d1, const void *s1, size_t len);
 
190
#if MODESEGMENT == 0
 
191
#define memcpy __builtin_memcpy
 
192
#endif
 
193
void iomemcpy(void *d, const void *s, u32 len);
 
194
void *memmove(void *d, const void *s, size_t len);
 
195
char *strtcpy(char *dest, const char *src, size_t len);
 
196
int get_keystroke(int msec);
 
197
 
 
198
// stacks.c
 
199
inline u32 stack_hop(u32 eax, u32 edx, void *func);
 
200
extern struct thread_info MainThread;
 
201
void thread_setup(void);
 
202
struct thread_info *getCurThread(void);
 
203
void yield(void);
 
204
void wait_irq(void);
 
205
void run_thread(void (*func)(void*), void *data);
 
206
void wait_threads(void);
 
207
struct mutex_s { u32 isLocked; };
 
208
void mutex_lock(struct mutex_s *mutex);
 
209
void mutex_unlock(struct mutex_s *mutex);
 
210
void start_preempt(void);
 
211
void finish_preempt(void);
 
212
int wait_preempt(void);
 
213
void check_preempt(void);
 
214
 
 
215
// output.c
 
216
void debug_serial_setup(void);
 
217
void panic(const char *fmt, ...)
 
218
    __attribute__ ((format (printf, 1, 2))) __noreturn;
 
219
void printf(const char *fmt, ...)
 
220
    __attribute__ ((format (printf, 1, 2)));
 
221
int snprintf(char *str, size_t size, const char *fmt, ...)
 
222
    __attribute__ ((format (printf, 3, 4)));
 
223
void __dprintf(const char *fmt, ...)
 
224
    __attribute__ ((format (printf, 1, 2)));
 
225
void __debug_enter(struct bregs *regs, const char *fname);
 
226
void __debug_isr(const char *fname);
 
227
void __debug_stub(struct bregs *regs, int lineno, const char *fname);
 
228
void __warn_invalid(struct bregs *regs, int lineno, const char *fname);
 
229
void __warn_unimplemented(struct bregs *regs, int lineno, const char *fname);
 
230
void __warn_internalerror(int lineno, const char *fname);
 
231
void __warn_noalloc(int lineno, const char *fname);
 
232
void __warn_timeout(int lineno, const char *fname);
 
233
void __set_invalid(struct bregs *regs, int lineno, const char *fname);
 
234
void __set_unimplemented(struct bregs *regs, int lineno, const char *fname);
 
235
void __set_code_invalid(struct bregs *regs, u32 linecode, const char *fname);
 
236
void __set_code_unimplemented(struct bregs *regs, u32 linecode
 
237
                              , const char *fname);
 
238
void hexdump(const void *d, int len);
 
239
 
 
240
#define dprintf(lvl, fmt, args...) do {                         \
 
241
        if (CONFIG_DEBUG_LEVEL && (lvl) <= CONFIG_DEBUG_LEVEL)  \
 
242
            __dprintf((fmt) , ##args );                         \
 
243
    } while (0)
 
244
#define debug_enter(regs, lvl) do {                     \
 
245
        if ((lvl) && (lvl) <= CONFIG_DEBUG_LEVEL)       \
 
246
            __debug_enter((regs), __func__);            \
 
247
    } while (0)
 
248
#define debug_isr(lvl) do {                             \
 
249
        if ((lvl) && (lvl) <= CONFIG_DEBUG_LEVEL)       \
 
250
            __debug_isr(__func__);                      \
 
251
    } while (0)
 
252
#define debug_stub(regs)                        \
 
253
    __debug_stub((regs), __LINE__, __func__)
 
254
#define warn_invalid(regs)                      \
 
255
    __warn_invalid((regs), __LINE__, __func__)
 
256
#define warn_unimplemented(regs)                        \
 
257
    __warn_unimplemented((regs), __LINE__, __func__)
 
258
#define warn_internalerror()                    \
 
259
    __warn_internalerror(__LINE__, __func__)
 
260
#define warn_noalloc()                          \
 
261
    __warn_noalloc(__LINE__, __func__)
 
262
#define warn_timeout()                          \
 
263
    __warn_timeout(__LINE__, __func__)
 
264
#define set_invalid(regs)                       \
 
265
    __set_invalid((regs), __LINE__, __func__)
 
266
#define set_code_invalid(regs, code)                                    \
 
267
    __set_code_invalid((regs), (code) | (__LINE__ << 8), __func__)
 
268
#define set_unimplemented(regs)                         \
 
269
    __set_unimplemented((regs), __LINE__, __func__)
 
270
#define set_code_unimplemented(regs, code)                              \
 
271
    __set_code_unimplemented((regs), (code) | (__LINE__ << 8), __func__)
 
272
 
 
273
// kbd.c
 
274
void kbd_setup(void);
 
275
void handle_15c2(struct bregs *regs);
 
276
void process_key(u8 key);
 
277
 
 
278
// mouse.c
 
279
void mouse_setup(void);
 
280
void process_mouse(u8 data);
 
281
 
 
282
// system.c
 
283
extern u32 RamSize;
 
284
extern u64 RamSizeOver4G;
 
285
void mathcp_setup(void);
 
286
 
 
287
// serial.c
 
288
void serial_setup(void);
 
289
void lpt_setup(void);
 
290
 
 
291
// clock.c
 
292
#define PIT_TICK_RATE 1193180   // Underlying HZ of PIT
 
293
#define PIT_TICK_INTERVAL 65536 // Default interval for 18.2Hz timer
 
294
static inline int check_tsc(u64 end) {
 
295
    return (s64)(rdtscll() - end) > 0;
 
296
}
 
297
void timer_setup(void);
 
298
void ndelay(u32 count);
 
299
void udelay(u32 count);
 
300
void mdelay(u32 count);
 
301
void nsleep(u32 count);
 
302
void usleep(u32 count);
 
303
void msleep(u32 count);
 
304
u64 calc_future_tsc(u32 msecs);
 
305
u64 calc_future_tsc_usec(u32 usecs);
 
306
u32 calc_future_timer_ticks(u32 count);
 
307
u32 calc_future_timer(u32 msecs);
 
308
int check_timer(u32 end);
 
309
void handle_1583(struct bregs *regs);
 
310
void handle_1586(struct bregs *regs);
 
311
void useRTC(void);
 
312
void releaseRTC(void);
 
313
 
 
314
// apm.c
 
315
void handle_1553(struct bregs *regs);
 
316
 
 
317
// pcibios.c
 
318
void handle_1ab1(struct bregs *regs);
 
319
void bios32_setup(void);
 
320
 
 
321
// shadow.c
 
322
void make_bios_writable(void);
 
323
void make_bios_readonly(void);
 
324
 
 
325
// pciinit.c
 
326
void pci_setup(void);
 
327
 
 
328
// smm.c
 
329
void smm_init(void);
 
330
 
 
331
// smp.c
 
332
extern u32 CountCPUs;
 
333
extern u32 MaxCountCPUs;
 
334
void wrmsr_smp(u32 index, u64 val);
 
335
void smp_probe(void);
 
336
void smp_probe_setup(void);
 
337
 
 
338
// coreboot.c
 
339
struct cbfs_file;
 
340
struct cbfs_file *cbfs_findprefix(const char *prefix, struct cbfs_file *last);
 
341
u32 cbfs_datasize(struct cbfs_file *file);
 
342
const char *cbfs_filename(struct cbfs_file *file);
 
343
int cbfs_copyfile(struct cbfs_file *file, void *dst, u32 maxlen);
 
344
int cbfs_copy_optionrom(void *dst, u32 maxlen, u32 vendev);
 
345
void cbfs_run_payload(struct cbfs_file *file);
 
346
 
 
347
void coreboot_copy_biostable(void);
 
348
void coreboot_setup(void);
 
349
 
 
350
// vgahooks.c
 
351
extern int VGAbdf;
 
352
void handle_155f(struct bregs *regs);
 
353
void vgahook_setup(const char *vendor, const char *part);
 
354
 
 
355
// optionroms.c
 
356
void call_bcv(u16 seg, u16 ip);
 
357
void optionrom_setup(void);
 
358
void vga_setup(void);
 
359
void s3_resume_vga_init(void);
 
360
extern u32 RomEnd;
 
361
 
 
362
// resume.c
 
363
void init_dma(void);
 
364
 
 
365
// pnpbios.c
 
366
#define PNP_SIGNATURE 0x506e5024 // $PnP
 
367
u16 get_pnp_offset(void);
 
368
void pnp_setup(void);
 
369
 
 
370
// pmm.c
 
371
extern struct zone_s ZoneLow, ZoneHigh, ZoneFSeg, ZoneTmpLow, ZoneTmpHigh;
 
372
void malloc_setup(void);
 
373
void malloc_finalize(void);
 
374
void *pmm_malloc(struct zone_s *zone, u32 handle, u32 size, u32 align);
 
375
int pmm_free(void *data);
 
376
void pmm_setup(void);
 
377
void pmm_finalize(void);
 
378
#define PMM_DEFAULT_HANDLE 0xFFFFFFFF
 
379
// Minimum alignment of malloc'd memory
 
380
#define MALLOC_MIN_ALIGN 16
 
381
// Helper functions for memory allocation.
 
382
static inline void *malloc_low(u32 size) {
 
383
    return pmm_malloc(&ZoneLow, PMM_DEFAULT_HANDLE, size, MALLOC_MIN_ALIGN);
 
384
}
 
385
static inline void *malloc_high(u32 size) {
 
386
    return pmm_malloc(&ZoneHigh, PMM_DEFAULT_HANDLE, size, MALLOC_MIN_ALIGN);
 
387
}
 
388
static inline void *malloc_fseg(u32 size) {
 
389
    return pmm_malloc(&ZoneFSeg, PMM_DEFAULT_HANDLE, size, MALLOC_MIN_ALIGN);
 
390
}
 
391
static inline void *malloc_tmphigh(u32 size) {
 
392
    return pmm_malloc(&ZoneTmpHigh, PMM_DEFAULT_HANDLE, size, MALLOC_MIN_ALIGN);
 
393
}
 
394
static inline void *malloc_tmp(u32 size) {
 
395
    void *ret = malloc_tmphigh(size);
 
396
    if (ret)
 
397
        return ret;
 
398
    return pmm_malloc(&ZoneTmpLow, PMM_DEFAULT_HANDLE, size, MALLOC_MIN_ALIGN);
 
399
}
 
400
static inline void *memalign_low(u32 align, u32 size) {
 
401
    return pmm_malloc(&ZoneLow, PMM_DEFAULT_HANDLE, size, align);
 
402
}
 
403
static inline void *memalign_high(u32 align, u32 size) {
 
404
    return pmm_malloc(&ZoneHigh, PMM_DEFAULT_HANDLE, size, align);
 
405
}
 
406
static inline void *memalign_tmphigh(u32 align, u32 size) {
 
407
    return pmm_malloc(&ZoneTmpHigh, PMM_DEFAULT_HANDLE, size, align);
 
408
}
 
409
static inline void free(void *data) {
 
410
    pmm_free(data);
 
411
}
 
412
 
 
413
// mtrr.c
 
414
void mtrr_setup(void);
 
415
 
 
416
// romlayout.S
 
417
void reset_vector(void) __noreturn;
 
418
 
 
419
// misc.c
 
420
extern u8 BiosChecksum;
 
421
 
 
422
// version (auto generated file out/version.c)
 
423
extern const char VERSION[];
 
424
 
 
425
#endif // util.h