Rev 4538 | Rev 5272 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1029 | serge | 1 | |
1630 | serge | 2 | |
3 | |||
1408 | serge | 4 | #define __SYSCALL_H__ |
5 | |||
6 | |||
5270 | serge | 7 | typedef u32 count_t; |
8 | |||
9 | |||
1029 | serge | 10 | |
11 | |||
1434 | serge | 12 | #define FASTCALL __attribute__ ((fastcall)) __attribute__ ((dllimport)) |
13 | |||
1029 | serge | 14 | |
1434 | serge | 15 | |
16 | |||
1029 | serge | 17 | |
18 | |||
19 | #define PciApi __PciApi |
||
20 | #define CreateObject __CreateObject |
||
21 | #define DestroyObject __DestroyObject |
||
22 | |||
23 | |||
1872 | serge | 24 | |
25 | |||
1029 | serge | 26 | |
27 | |||
28 | |||
29 | void STDCALL FreeKernelSpace(void *mem)__asm__("FreeKernelSpace"); |
||
1408 | serge | 30 | addr_t STDCALL MapIoMem(addr_t base, size_t size, u32 flags)__asm__("MapIoMem"); |
5270 | serge | 31 | void* STDCALL KernelAlloc(size_t size)__asm__("KernelAlloc"); |
1029 | serge | 32 | void* STDCALL KernelFree(void *mem)__asm__("KernelFree"); |
33 | void* STDCALL UserAlloc(size_t size)__asm__("UserAlloc"); |
||
34 | int STDCALL UserFree(void *mem)__asm__("UserFree"); |
||
35 | |||
36 | |||
1613 | serge | 37 | |
1408 | serge | 38 | |
5270 | serge | 39 | |
1408 | serge | 40 | |
1613 | serge | 41 | addr_t STDCALL AllocPages(count_t count)__asm__("AllocPages"); |
1029 | serge | 42 | void IMPORT __attribute__((regparm(1))) |
2967 | Serge | 43 | FreePage(addr_t page)__asm__("FreePage"); |
44 | void STDCALL MapPage(void *vaddr, addr_t paddr, u32 flags)__asm__("MapPage"); |
||
5270 | serge | 45 | |
1029 | serge | 46 | |
2967 | Serge | 47 | |
5270 | serge | 48 | |
1029 | serge | 49 | |
5270 | serge | 50 | |
1029 | serge | 51 | |
5270 | serge | 52 | |
1029 | serge | 53 | |
1434 | serge | 54 | void FASTCALL MutexLock(struct mutex*)__asm__("MutexLock"); |
55 | void FASTCALL MutexUnlock(struct mutex*)__asm__("MutexUnlock"); |
||
56 | |||
1029 | serge | 57 | |
1872 | serge | 58 | u32 IMPORT GetPid(void)__asm__("GetPid"); |
5270 | serge | 59 | |
1872 | serge | 60 | |
4125 | Serge | 61 | void *fn, void *data)asm("TimerHS"); |
62 | |||
2967 | Serge | 63 | |
4125 | Serge | 64 | |
65 | |||
3482 | Serge | 66 | |
67 | |||
1029 | serge | 68 | |
69 | |||
70 | int z, int h)__asm__("SetMouseData"); |
||
71 | |||
72 | |||
5270 | serge | 73 | |
1872 | serge | 74 | |
75 | |||
5270 | serge | 76 | u16 STDCALL PciRead16(u32 bus, u32 devfn, u32 reg)__asm__("PciRead16"); |
77 | u32 STDCALL PciRead32(u32 bus, u32 devfn, u32 reg)__asm__("PciRead32"); |
||
78 | |||
1029 | serge | 79 | |
5270 | serge | 80 | u32 STDCALL PciWrite16(u32 bus, u32 devfn, u32 reg,u16 val)__asm__("PciWrite16"); |
81 | u32 STDCALL PciWrite32(u32 bus, u32 devfn, u32 reg,u32 val)__asm__("PciWrite32"); |
||
82 | |||
1029 | serge | 83 | |
84 | PciRead8(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg)) |
||
85 | |||
86 | |||
87 | PciRead16(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg)) |
||
88 | |||
89 | |||
90 | PciRead32(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg)) |
||
91 | |||
92 | |||
93 | PciWrite8(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg),(val)) |
||
94 | |||
95 | |||
96 | PciWrite16(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg),(val)) |
||
97 | |||
98 | |||
99 | PciWrite32(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg),(val)) |
||
100 | |||
101 | |||
3031 | serge | 102 | u8 *val) |
103 | { |
||
104 | *val = PciRead8(dev->busnr, dev->devfn, where); |
||
105 | return 1; |
||
106 | } |
||
107 | |||
108 | |||
109 | u16 *val) |
||
110 | { |
||
111 | *val = PciRead16(dev->busnr, dev->devfn, where); |
||
112 | return 1; |
||
113 | } |
||
114 | |||
115 | |||
116 | u32 *val) |
||
117 | { |
||
118 | *val = PciRead32(dev->busnr, dev->devfn, where); |
||
119 | return 1; |
||
120 | } |
||
121 | |||
122 | |||
123 | u8 val) |
||
124 | { |
||
125 | PciWrite8(dev->busnr, dev->devfn, where, val); |
||
126 | return 1; |
||
127 | } |
||
128 | |||
129 | |||
130 | u16 val) |
||
131 | { |
||
132 | PciWrite16(dev->busnr, dev->devfn, where, val); |
||
133 | return 1; |
||
134 | } |
||
135 | |||
136 | |||
137 | u32 val) |
||
138 | { |
||
139 | PciWrite32(dev->busnr, dev->devfn, where, val); |
||
140 | return 1; |
||
141 | } |
||
142 | |||
143 | |||
1029 | serge | 144 | |
145 | |||
146 | int dbgprintf(const char* format, ...); |
||
147 | |||
148 | |||
149 | |||
150 | |||
4110 | Serge | 151 | { |
152 | int pid; |
||
153 | __asm__ __volatile__ ( |
||
154 | "call *__imp__CreateThread" |
||
155 | :"=a"(pid) |
||
156 | :"b"(1),"c"(entry),"d"(0) |
||
157 | :"memory"); |
||
158 | __asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi"); |
||
159 | return pid; |
||
160 | }; |
||
161 | |||
162 | |||
163 | |||
5270 | serge | 164 | { |
1029 | serge | 165 | evhandle_t evh; |
1616 | serge | 166 | |
1613 | serge | 167 | |
168 | "call *__imp__CreateEvent" |
||
169 | :"=A"(evh.raw) |
||
1616 | serge | 170 | :"S" (ev), "c"(flags) |
171 | :"memory"); |
||
172 | __asm__ __volatile__ ("":::"ebx","ecx","edx","esi", "edi"); |
||
2005 | serge | 173 | |
1613 | serge | 174 | |
1616 | serge | 175 | }; |
176 | |||
1613 | serge | 177 | |
5270 | serge | 178 | { |
1616 | serge | 179 | __asm__ __volatile__ ( |
180 | "call *__imp__RaiseEvent" |
||
181 | ::"a"(evh.handle),"b"(evh.euid),"d"(flags),"S" (ev) |
||
182 | :"memory"); |
||
183 | __asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi"); |
||
2005 | serge | 184 | |
1616 | serge | 185 | |
186 | |||
187 | |||
2005 | serge | 188 | { |
1616 | serge | 189 | __asm__ __volatile__ ( |
190 | "call *__imp__WaitEvent" |
||
191 | ::"a"(evh.handle),"b"(evh.euid)); |
||
2005 | serge | 192 | __asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi"); |
193 | }; |
||
1616 | serge | 194 | |
195 | |||
3391 | Serge | 196 | { |
197 | int retval; |
||
198 | __asm__ __volatile__ ( |
||
199 | "call *__imp__WaitEventTimeout" |
||
200 | :"=a"(retval) |
||
201 | :"a"(evh.handle),"b"(evh.euid), "c"(timeout)); |
||
202 | __asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi"); |
||
203 | return retval; |
||
204 | }; |
||
205 | |||
206 | |||
2967 | Serge | 207 | { |
208 | __asm__ __volatile__ ( |
||
209 | "call *__imp__DestroyEvent" |
||
210 | ::"a"(evh.handle),"b"(evh.euid)); |
||
211 | __asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi"); |
||
212 | }; |
||
213 | |||
214 | |||
5270 | serge | 215 | { |
1616 | serge | 216 | u32 handle; |
5270 | serge | 217 | |
1616 | serge | 218 | |
219 | "call *__imp__GetEvent" |
||
220 | :"=a"(handle) |
||
221 | :"D"(ev) |
||
222 | :"memory"); |
||
223 | __asm__ __volatile__ ("":::"ebx","ecx","edx", "esi","edi"); |
||
224 | return handle; |
||
1613 | serge | 225 | }; |
226 | |||
227 | |||
1616 | serge | 228 | |
1613 | serge | 229 | { |
230 | int retval; |
||
1029 | serge | 231 | |
232 | |||
233 | :"=a"(retval) |
||
234 | :"a"(61), "b"(1)); |
||
235 | return retval; |
||
236 | } |
||
237 | |||
238 | |||
1613 | serge | 239 | { |
1029 | serge | 240 | int retval; |
241 | |||
242 | |||
243 | :"=a"(retval) |
||
244 | :"a"(61), "b"(2)); |
||
245 | return retval; |
||
246 | } |
||
247 | |||
248 | |||
1613 | serge | 249 | { |
1029 | serge | 250 | int retval; |
251 | |||
252 | |||
253 | :"=a"(retval) |
||
254 | :"a"(61), "b"(3)); |
||
255 | return retval; |
||
256 | } |
||
257 | |||
258 | |||
5270 | serge | 259 | { |
1029 | serge | 260 | u32 retval; |
5270 | serge | 261 | |
1029 | serge | 262 | |
263 | "call *__imp__GetPgAddr \n\t" |
||
264 | :"=a" (retval) |
||
2967 | Serge | 265 | :"a" (mem) ); |
1029 | serge | 266 | return retval; |
267 | }; |
||
268 | |||
269 | |||
5270 | serge | 270 | { |
1029 | serge | 271 | size = (size+4095) & ~4095; |
272 | __asm__ __volatile__ ( |
||
273 | "call *__imp__CommitPages" |
||
274 | ::"a" (page), "b"(mem),"c"(size>>12) |
||
275 | :"edx" ); |
||
276 | __asm__ __volatile__ ("":::"eax","ebx","ecx"); |
||
277 | }; |
||
278 | |||
279 | |||
1408 | serge | 280 | { |
1029 | serge | 281 | size = (size+4095) & ~4095; |
282 | __asm__ __volatile__ ( |
||
283 | "call *__imp__UnmapPages" |
||
284 | ::"a" (mem), "c"(size>>12) |
||
285 | :"edx"); |
||
286 | __asm__ __volatile__ ("":::"eax","ecx"); |
||
287 | }; |
||
288 | |||
289 | |||
5270 | serge | 290 | { |
1029 | serge | 291 | if( !delay ) |
292 | delay++; |
||
293 | delay*= 500; |
||
1408 | serge | 294 | |
1029 | serge | 295 | |
296 | __asm__ __volatile__( |
||
1408 | serge | 297 | "xorl %%eax, %%eax \n\t" |
298 | "cpuid \n\t" |
||
299 | :::"eax","ebx","ecx","edx"); |
||
300 | }; |
||
301 | |||
302 | |||
5270 | serge | 303 | { |
1408 | serge | 304 | if(!delay) delay++; |
305 | delay*= 100; |
||
2967 | Serge | 306 | |
1408 | serge | 307 | |
308 | { |
||
309 | __asm__ __volatile__( |
||
310 | "xorl %%eax, %%eax \n\t" |
||
311 | "cpuid" |
||
312 | :::"eax","ebx","ecx","edx" ); |
||
313 | } |
||
314 | } |
||
315 | |||
316 | |||
5270 | serge | 317 | { |
1964 | serge | 318 | msecs /= 10; |
319 | if(!msecs) msecs = 1; |
||
320 | |||
321 | |||
322 | "call *__imp__Delay" |
||
323 | ::"b" (msecs)); |
||
324 | __asm__ __volatile__ ( |
||
325 | "":::"ebx"); |
||
326 | |||
327 | |||
328 | |||
329 | |||
5270 | serge | 330 | { |
1408 | serge | 331 | time /= 10; |
332 | if(!time) time = 1; |
||
333 | |||
334 | |||
1029 | serge | 335 | "call *__imp__Delay" |
1408 | serge | 336 | ::"b" (time)); |
337 | __asm__ __volatile__ ( |
||
338 | "":::"ebx"); |
||
339 | |||
340 | |||
1029 | serge | 341 | |
342 | |||
5270 | serge | 343 | { |
1029 | serge | 344 | u32 retval; |
5270 | serge | 345 | |
1029 | serge | 346 | |
347 | "call *__imp__PciApi \n\t" |
||
1616 | serge | 348 | "movzxb %%al, %%eax" |
349 | :"=a" (retval) |
||
1029 | serge | 350 | :"a" (cmd) |
351 | :"cc"); |
||
1630 | serge | 352 | |
353 | |||
1029 | serge | 354 | }; |
355 | |||
356 | |||
5270 | serge | 357 | { |
1029 | serge | 358 | void *retval; |
359 | |||
360 | |||
361 | "call *__imp__CreateObject \n\t" |
||
362 | :"=a" (retval) |
||
363 | :"a" (size),"b"(pid) |
||
364 | :"esi","edi", "memory"); |
||
365 | return retval; |
||
366 | } |
||
367 | |||
368 | |||
1408 | serge | 369 | { |
1029 | serge | 370 | __asm__ __volatile__ ( |
371 | "call *__imp__DestroyObject \n\t" |
||
1408 | serge | 372 | : |
1029 | serge | 373 | :"a" (obj)); |
1408 | serge | 374 | __asm__ __volatile__ ( |
375 | "" |
||
376 | :::"eax","ebx","ecx","edx","esi","edi","cc","memory"); |
||
377 | } |
||
1029 | serge | 378 | |
379 | |||
5270 | serge | 380 | { |
1029 | serge | 381 | u32 handle; |
5270 | serge | 382 | |
1408 | serge | 383 | |
384 | ( |
||
385 | "pushl %%eax \n\t" |
||
386 | "call *__imp__GetService" |
||
387 | :"=a" (handle) |
||
2967 | Serge | 388 | :"a" (name) |
1408 | serge | 389 | :"ebx","ecx","edx","esi", "edi" |
390 | ); |
||
391 | return handle; |
||
392 | }; |
||
393 | |||
394 | |||
5270 | serge | 395 | { |
1408 | serge | 396 | u32 ifl; |
5270 | serge | 397 | __asm__ __volatile__ ( |
1029 | serge | 398 | "pushf\n\t" |
399 | "popl %0\n\t" |
||
400 | "cli\n" |
||
401 | : "=r" (ifl)); |
||
402 | return ifl; |
||
403 | } |
||
404 | |||
405 | |||
5270 | serge | 406 | { |
1029 | serge | 407 | if (efl & (1<<9)) |
1616 | serge | 408 | __asm__ __volatile__ ("sti"); |
409 | } |
||
1029 | serge | 410 | |
411 | |||
5270 | serge | 412 | { |
1613 | serge | 413 | u32 val; |
5270 | serge | 414 | asm volatile ( |
1613 | serge | 415 | "pushfl\n\t" |
416 | "popl %0\n" |
||
417 | : "=r" (val)); |
||
418 | return val; |
||
419 | } |
||
420 | |||
421 | |||
1408 | serge | 422 | { |
1029 | serge | 423 | u32 tmp; |
5270 | serge | 424 | __asm__ __volatile__ ( |
1029 | serge | 425 | "cld \n\t" |
426 | "rep stosb \n" |
||
427 | :"=c"(tmp),"=D"(tmp) |
||
428 | :"a"(0),"c"(len),"D"(dst)); |
||
429 | __asm__ __volatile__ ("":::"ecx","edi"); |
||
430 | }; |
||
431 | |||
432 | |||
5270 | serge | 433 | { |
1029 | serge | 434 | __asm__ __volatile__ |
435 | ("outb %1, %0\n" : : "dN"(port), "a"(val)); |
||
436 | } |
||
437 | |||
438 | |||
5270 | serge | 439 | { |
1029 | serge | 440 | __asm__ __volatile__ |
441 | ("outw %1, %0\n" : : "dN"(port), "a"(val)); |
||
442 | } |
||
443 | |||
444 | |||
5270 | serge | 445 | { |
1029 | serge | 446 | __asm__ __volatile__ |
447 | ("outl %1, %0\n" : : "dN"(port), "a"(val)); |
||
448 | } |
||
449 | |||
450 | |||
5270 | serge | 451 | { |
1029 | serge | 452 | u8 tmp; |
5270 | serge | 453 | __asm__ __volatile__ |
1029 | serge | 454 | ("inb %1, %0\n" : "=a"(tmp) : "dN"(port)); |
455 | return tmp; |
||
456 | }; |
||
457 | |||
458 | |||
5270 | serge | 459 | { |
1029 | serge | 460 | u16 tmp; |
5270 | serge | 461 | __asm__ __volatile__ |
1029 | serge | 462 | ("inw %1, %0\n" : "=a"(tmp) : "dN"(port)); |
463 | return tmp; |
||
464 | }; |
||
465 | |||
466 | |||
5270 | serge | 467 | { |
1029 | serge | 468 | u32 tmp; |
5270 | serge | 469 | __asm__ __volatile__ |
1029 | serge | 470 | ("inl %1, %0\n" : "=a"(tmp) : "dN"(port)); |
471 | return tmp; |
||
472 | }; |
||
473 | |||
474 | |||
1408 | serge | 475 | { |
1029 | serge | 476 | __asm__ __volatile__ ( |
477 | "call *__imp__Delay" |
||
478 | ::"b" (time)); |
||
479 | __asm__ __volatile__ ( |
||
480 | "":::"ebx"); |
||
481 | |||
482 | |||
483 | |||
484 | |||
1613 | serge | 485 | { |
1029 | serge | 486 | __asm__ __volatile__ ( |
487 | "call *__imp__ChangeTask"); |
||
488 | } |
||
489 | |||
490 | |||
1613 | serge | 491 | { |
1408 | serge | 492 | __asm__ __volatile__ |
493 | ( |
||
494 | "call *__imp__SetScreen" |
||
495 | : |
||
496 | :"a" (width-1),"d"(height-1), "c"(pitch) |
||
497 | ); |
||
498 | __asm__ __volatile__ |
||
499 | ("" :::"eax","ecx","edx"); |
||
500 | } |
||
501 | |||
502 | |||
503 | |||
504 | |||
5270 | serge | 505 | { |
1408 | serge | 506 | return (void __iomem*) MapIoMem(offset, size, PG_SW|PG_NOCACHE|0x100); |
4538 | Serge | 507 | } |
1408 | serge | 508 | |
509 | |||
5270 | serge | 510 | { |
3391 | Serge | 511 | return (void __iomem*) MapIoMem(offset, size, PG_SW|0x100); |
4538 | Serge | 512 | } |
3391 | Serge | 513 | |
514 | |||
515 | |||
1408 | serge | 516 | { |
517 | FreeKernelSpace(addr); |
||
518 | } |
||
519 | |||
520 | |||
521 | { |
||
522 | __asm__ __volatile__( |
||
523 | "call *__imp__SysMsgBoardStr" |
||
524 | ::"S" (text)); |
||
525 | }; |
||
526 | |||
527 | |||
3031 | serge | 528 | { |
529 | void *mem; |
||
530 | |||
531 | |||
532 | if(mem) |
||
533 | memset(mem, 0, size); |
||
534 | |||
535 | |||
536 | }; |
||
537 | |||
538 | |||
539 | { |
||
540 | KernelFree(addr); |
||
541 | } |
||
542 | |||
543 | |||
544 | |||
545 | |||
546 | #define RWSEM_ACTIVE_BIAS 0x00000001 |
||
547 | #define RWSEM_ACTIVE_MASK 0x0000ffff |
||
548 | #define RWSEM_WAITING_BIAS (-0x00010000) |
||
549 | #define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS |
||
550 | #define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS) |
||
551 | |||
552 | |||
553 | |||
3243 | Serge | 554 | //{ |
555 | // sem->count = RWSEM_UNLOCKED_VALUE; |
||
556 | // spin_lock_init(&sem->wait_lock); |
||
557 | // INIT_LIST_HEAD(&sem->wait_list); |
||
558 | //} |
||
559 | |||
3031 | serge | 560 | |
1408 | serge | 561 | ><9)) |