Subversion Repositories Kolibri OS

Rev

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