Subversion Repositories Kolibri OS

Rev

Rev 1631 | Rev 1964 | 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
40
 
41
42
 
43
44
 
45
46
 
1434 serge 47
void  FASTCALL MutexLock(struct mutex*)__asm__("MutexLock");
48
void  FASTCALL MutexUnlock(struct mutex*)__asm__("MutexUnlock");
49
1029 serge 50
 
1872 serge 51
52
 
1029 serge 53
54
 
55
                            int z, int h)__asm__("SetMouseData");
56
57
 
1872 serge 58
59
 
60
 
1029 serge 61
u16_t STDCALL PciRead16(u32_t bus, u32_t devfn, u32_t reg)__asm__("PciRead16");
62
u32_t STDCALL PciRead32(u32_t bus, u32_t devfn, u32_t reg)__asm__("PciRead32");
63
64
 
65
u32_t STDCALL PciWrite16(u32_t bus, u32_t devfn, u32_t reg,u16_t val)__asm__("PciWrite16");
66
u32_t STDCALL PciWrite32(u32_t bus, u32_t devfn, u32_t reg,u32_t val)__asm__("PciWrite32");
67
68
 
69
        PciRead8(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg))
70
71
 
72
        PciRead16(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg))
73
74
 
75
        PciRead32(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg))
76
77
 
78
        PciWrite8(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg),(val))
79
80
 
81
        PciWrite16(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg),(val))
82
83
 
84
        PciWrite32(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg),(val))
85
86
 
87
 
88
89
 
90
int dbgprintf(const char* format, ...);
91
92
 
93
94
 
1616 serge 95
{
1029 serge 96
     evhandle_t evh;
1616 serge 97
1613 serge 98
 
99
     "call *__imp__CreateEvent"
100
     :"=A"(evh.raw)
1616 serge 101
     :"S" (ev), "c"(flags)
102
     :"memory");
103
     __asm__ __volatile__ ("":::"ebx","ecx", "esi", "edi");
1613 serge 104
105
 
1616 serge 106
};
107
1613 serge 108
 
1616 serge 109
{
110
     __asm__ __volatile__ (
111
     "call *__imp__RaiseEvent"
112
     ::"a"(evh.handle),"b"(evh.euid),"d"(flags),"S" (ev)
113
     :"memory");
114
     __asm__ __volatile__ ("":::"ebx","ecx", "esi", "edi");
115
116
 
117
118
 
119
{
120
     __asm__ __volatile__ (
121
     "call *__imp__WaitEvent"
122
     ::"a"(handle),"b"(euid));
123
     __asm__ __volatile__ ("":::"ecx","edx", "esi");
124
};
125
126
 
127
{
128
    u32_t  handle;
129
130
 
131
    "call *__imp__GetEvent"
132
    :"=a"(handle)
133
    :"D"(ev)
134
    :"memory");
135
    __asm__ __volatile__ ("":::"ebx","ecx","edx", "esi","edi");
136
     return handle;
1613 serge 137
};
138
139
 
1616 serge 140
 
1613 serge 141
{
142
  int retval;
1029 serge 143
144
 
145
      :"=a"(retval)
146
      :"a"(61), "b"(1));
147
  return retval;
148
}
149
150
 
1613 serge 151
{
1029 serge 152
  int retval;
153
154
 
155
      :"=a"(retval)
156
      :"a"(61), "b"(2));
157
  return retval;
158
}
159
160
 
1613 serge 161
{
1029 serge 162
  int retval;
163
164
 
165
      :"=a"(retval)
166
      :"a"(61), "b"(3));
167
  return retval;
168
}
169
170
 
1408 serge 171
{
1029 serge 172
     u32_t retval;
173
174
 
175
     "call *__imp__GetPgAddr \n\t"
176
     :"=eax" (retval)
177
     :"a" (mem) );
178
     return retval;
179
};
180
181
 
1408 serge 182
{
1029 serge 183
     size = (size+4095) & ~4095;
184
     __asm__ __volatile__ (
185
     "call *__imp__CommitPages"
186
     ::"a" (page), "b"(mem),"c"(size>>12)
187
     :"edx" );
188
     __asm__ __volatile__ ("":::"eax","ebx","ecx");
189
};
190
191
 
1408 serge 192
{
1029 serge 193
     size = (size+4095) & ~4095;
194
     __asm__ __volatile__ (
195
     "call *__imp__UnmapPages"
196
     ::"a" (mem), "c"(size>>12)
197
     :"edx");
198
     __asm__ __volatile__ ("":::"eax","ecx");
199
};
200
201
 
1408 serge 202
{
1029 serge 203
     if( !delay )
204
        delay++;
205
     delay*= 500;
1408 serge 206
1029 serge 207
 
208
        __asm__ __volatile__(
1408 serge 209
        "xorl %%eax, %%eax \n\t"
210
        "cpuid \n\t"
211
        :::"eax","ebx","ecx","edx");
212
     };
213
214
 
215
{
216
    if(!delay) delay++;
217
    delay*= 500;
218
219
 
220
    {
221
        __asm__ __volatile__(
222
        "xorl %%eax, %%eax \n\t"
223
        "cpuid"
224
        :::"eax","ebx","ecx","edx" );
225
    }
226
}
227
228
 
229
{
230
    time /= 10;
231
    if(!time) time = 1;
232
233
 
1029 serge 234
     "call *__imp__Delay"
1408 serge 235
     ::"b" (time));
236
     __asm__ __volatile__ (
237
     "":::"ebx");
238
239
 
1029 serge 240
241
 
1408 serge 242
 
243
{
1029 serge 244
     u32_t retval;
245
246
 
247
     "call *__imp__PciApi \n\t"
1616 serge 248
     "movzxb %%al, %%eax"
249
     :"=a" (retval)
1029 serge 250
     :"a" (cmd)
251
     :"cc");
1630 serge 252
253
 
1029 serge 254
};
255
256
 
1408 serge 257
{
1029 serge 258
     void *retval;
259
260
 
261
     "call *__imp__CreateObject \n\t"
262
     :"=a" (retval)
263
     :"a" (size),"b"(pid)
264
     :"esi","edi", "memory");
265
     return retval;
266
}
267
268
 
1408 serge 269
{
1029 serge 270
     __asm__ __volatile__ (
271
     "call *__imp__DestroyObject \n\t"
1408 serge 272
     :
1029 serge 273
     :"a" (obj));
1408 serge 274
     __asm__ __volatile__ (
275
     ""
276
     :::"eax","ebx","ecx","edx","esi","edi","cc","memory");
277
}
1029 serge 278
279
 
1408 serge 280
{
1029 serge 281
    u32_t handle;
1408 serge 282
283
 
284
    (
285
     "pushl %%eax \n\t"
286
     "call *__imp__GetService"
287
     :"=eax" (handle)
288
     :"a" (name)
289
     :"ebx","ecx","edx","esi", "edi"
290
  );
291
  return handle;
292
};
293
294
 
295
{
296
     u32_t ifl;
1029 serge 297
     __asm__ __volatile__ (
298
     "pushf\n\t"
299
     "popl %0\n\t"
300
     "cli\n"
301
     : "=r" (ifl));
302
    return ifl;
303
}
304
305
 
1616 serge 306
{
1029 serge 307
     if (efl & (1<<9))
1616 serge 308
        __asm__ __volatile__ ("sti");
309
}
1029 serge 310
311
 
1613 serge 312
{
313
    u32_t val;
314
    asm volatile (
315
    "pushfl\n\t"
316
    "popl %0\n"
317
    : "=r" (val));
318
    return val;
319
}
320
321
 
1408 serge 322
{
1029 serge 323
     u32_t tmp;
324
     __asm__ __volatile__ (
325
     "cld \n\t"
326
     "rep stosb \n"
327
     :"=c"(tmp),"=D"(tmp)
328
     :"a"(0),"c"(len),"D"(dst));
329
     __asm__ __volatile__ ("":::"ecx","edi");
330
};
331
332
 
1408 serge 333
{
1029 serge 334
    __asm__ __volatile__
335
    ("outb  %1, %0\n" : : "dN"(port), "a"(val));
336
}
337
338
 
1408 serge 339
{
1029 serge 340
    __asm__ __volatile__
341
    ("outw  %1, %0\n" : : "dN"(port), "a"(val));
342
}
343
344
 
1408 serge 345
{
1029 serge 346
    __asm__ __volatile__
347
    ("outl  %1, %0\n" : : "dN"(port), "a"(val));
348
}
349
350
 
1408 serge 351
{
1029 serge 352
    u8_t tmp;
353
    __asm__ __volatile__
354
    ("inb %1, %0\n" : "=a"(tmp) : "dN"(port));
355
    return tmp;
356
};
357
358
 
1408 serge 359
{
1029 serge 360
    u16_t tmp;
361
    __asm__ __volatile__
362
    ("inw %1, %0\n" : "=a"(tmp) : "dN"(port));
363
    return tmp;
364
};
365
366
 
1408 serge 367
{
1029 serge 368
    u32_t tmp;
369
    __asm__ __volatile__
370
    ("inl %1, %0\n" : "=a"(tmp) : "dN"(port));
371
    return tmp;
372
};
373
374
 
1408 serge 375
{
1029 serge 376
     __asm__ __volatile__ (
377
     "call *__imp__Delay"
378
     ::"b" (time));
379
     __asm__ __volatile__ (
380
     "":::"ebx");
381
382
 
383
384
 
1613 serge 385
{
1029 serge 386
     __asm__ __volatile__ (
387
     "call *__imp__ChangeTask");
388
}
389
390
 
1613 serge 391
{
1408 serge 392
    __asm__ __volatile__
393
    (
394
        "call *__imp__SetScreen"
395
        :
396
        :"a" (width-1),"d"(height-1), "c"(pitch)
397
    );
398
    __asm__ __volatile__
399
    ("" :::"eax","ecx","edx");
400
}
401
402
 
403
404
 
405
{
406
    return (void __iomem*) MapIoMem(offset, size, 3);
407
}
408
409
 
410
{
411
    FreeKernelSpace(addr);
412
}
413
414
 
415
{
416
    __asm__ __volatile__(
417
    "call *__imp__SysMsgBoardStr"
418
    ::"S" (text));
419
};
420
421
 
422
>