Subversion Repositories Kolibri OS

Rev

Rev 1613 | Rev 1630 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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