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