Subversion Repositories Kolibri OS

Rev

Rev 3243 | Rev 3482 | 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
 
3391 Serge 176
{
177
    int retval;
178
    __asm__ __volatile__ (
179
    "call *__imp__WaitEventTimeout"
180
    :"=a"(retval)
181
    :"a"(evh.handle),"b"(evh.euid), "c"(timeout));
182
    __asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi");
183
    return retval;
184
};
185
186
 
2967 Serge 187
{
188
     __asm__ __volatile__ (
189
     "call *__imp__DestroyEvent"
190
     ::"a"(evh.handle),"b"(evh.euid));
191
     __asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi");
192
};
193
194
 
1616 serge 195
{
196
    u32_t  handle;
197
198
 
199
    "call *__imp__GetEvent"
200
    :"=a"(handle)
201
    :"D"(ev)
202
    :"memory");
203
    __asm__ __volatile__ ("":::"ebx","ecx","edx", "esi","edi");
204
     return handle;
1613 serge 205
};
206
207
 
1616 serge 208
 
1613 serge 209
{
210
  int retval;
1029 serge 211
212
 
213
      :"=a"(retval)
214
      :"a"(61), "b"(1));
215
  return retval;
216
}
217
218
 
1613 serge 219
{
1029 serge 220
  int retval;
221
222
 
223
      :"=a"(retval)
224
      :"a"(61), "b"(2));
225
  return retval;
226
}
227
228
 
1613 serge 229
{
1029 serge 230
  int retval;
231
232
 
233
      :"=a"(retval)
234
      :"a"(61), "b"(3));
235
  return retval;
236
}
237
238
 
1408 serge 239
{
1029 serge 240
     u32_t retval;
241
242
 
243
     "call *__imp__GetPgAddr \n\t"
244
     :"=a" (retval)
2967 Serge 245
     :"a" (mem) );
1029 serge 246
     return retval;
247
};
248
249
 
1408 serge 250
{
1029 serge 251
     size = (size+4095) & ~4095;
252
     __asm__ __volatile__ (
253
     "call *__imp__CommitPages"
254
     ::"a" (page), "b"(mem),"c"(size>>12)
255
     :"edx" );
256
     __asm__ __volatile__ ("":::"eax","ebx","ecx");
257
};
258
259
 
1408 serge 260
{
1029 serge 261
     size = (size+4095) & ~4095;
262
     __asm__ __volatile__ (
263
     "call *__imp__UnmapPages"
264
     ::"a" (mem), "c"(size>>12)
265
     :"edx");
266
     __asm__ __volatile__ ("":::"eax","ecx");
267
};
268
269
 
1408 serge 270
{
1029 serge 271
     if( !delay )
272
        delay++;
273
     delay*= 500;
1408 serge 274
1029 serge 275
 
276
        __asm__ __volatile__(
1408 serge 277
        "xorl %%eax, %%eax \n\t"
278
        "cpuid \n\t"
279
        :::"eax","ebx","ecx","edx");
280
     };
281
282
 
283
{
284
    if(!delay) delay++;
285
    delay*= 100;
2967 Serge 286
1408 serge 287
 
288
    {
289
        __asm__ __volatile__(
290
        "xorl %%eax, %%eax \n\t"
291
        "cpuid"
292
        :::"eax","ebx","ecx","edx" );
293
    }
294
}
295
296
 
1964 serge 297
{
298
    msecs /= 10;
299
    if(!msecs) msecs = 1;
300
301
 
302
     "call *__imp__Delay"
303
     ::"b" (msecs));
304
     __asm__ __volatile__ (
305
     "":::"ebx");
306
307
 
308
309
 
1408 serge 310
{
311
    time /= 10;
312
    if(!time) time = 1;
313
314
 
1029 serge 315
     "call *__imp__Delay"
1408 serge 316
     ::"b" (time));
317
     __asm__ __volatile__ (
318
     "":::"ebx");
319
320
 
1029 serge 321
322
 
1408 serge 323
{
1029 serge 324
     u32_t retval;
325
326
 
327
     "call *__imp__PciApi \n\t"
1616 serge 328
     "movzxb %%al, %%eax"
329
     :"=a" (retval)
1029 serge 330
     :"a" (cmd)
331
     :"cc");
1630 serge 332
333
 
1029 serge 334
};
335
336
 
1408 serge 337
{
1029 serge 338
     void *retval;
339
340
 
341
     "call *__imp__CreateObject \n\t"
342
     :"=a" (retval)
343
     :"a" (size),"b"(pid)
344
     :"esi","edi", "memory");
345
     return retval;
346
}
347
348
 
1408 serge 349
{
1029 serge 350
     __asm__ __volatile__ (
351
     "call *__imp__DestroyObject \n\t"
1408 serge 352
     :
1029 serge 353
     :"a" (obj));
1408 serge 354
     __asm__ __volatile__ (
355
     ""
356
     :::"eax","ebx","ecx","edx","esi","edi","cc","memory");
357
}
1029 serge 358
359
 
1408 serge 360
{
1029 serge 361
    u32_t handle;
1408 serge 362
363
 
364
    (
365
     "pushl %%eax \n\t"
366
     "call *__imp__GetService"
367
     :"=a" (handle)
2967 Serge 368
     :"a" (name)
1408 serge 369
     :"ebx","ecx","edx","esi", "edi"
370
  );
371
  return handle;
372
};
373
374
 
375
{
376
     u32_t ifl;
1029 serge 377
     __asm__ __volatile__ (
378
     "pushf\n\t"
379
     "popl %0\n\t"
380
     "cli\n"
381
     : "=r" (ifl));
382
    return ifl;
383
}
384
385
 
1616 serge 386
{
1029 serge 387
     if (efl & (1<<9))
1616 serge 388
        __asm__ __volatile__ ("sti");
389
}
1029 serge 390
391
 
1613 serge 392
{
393
    u32_t val;
394
    asm volatile (
395
    "pushfl\n\t"
396
    "popl %0\n"
397
    : "=r" (val));
398
    return val;
399
}
400
401
 
1408 serge 402
{
1029 serge 403
     u32_t tmp;
404
     __asm__ __volatile__ (
405
     "cld \n\t"
406
     "rep stosb \n"
407
     :"=c"(tmp),"=D"(tmp)
408
     :"a"(0),"c"(len),"D"(dst));
409
     __asm__ __volatile__ ("":::"ecx","edi");
410
};
411
412
 
1408 serge 413
{
1029 serge 414
    __asm__ __volatile__
415
    ("outb  %1, %0\n" : : "dN"(port), "a"(val));
416
}
417
418
 
1408 serge 419
{
1029 serge 420
    __asm__ __volatile__
421
    ("outw  %1, %0\n" : : "dN"(port), "a"(val));
422
}
423
424
 
1408 serge 425
{
1029 serge 426
    __asm__ __volatile__
427
    ("outl  %1, %0\n" : : "dN"(port), "a"(val));
428
}
429
430
 
1408 serge 431
{
1029 serge 432
    u8_t tmp;
433
    __asm__ __volatile__
434
    ("inb %1, %0\n" : "=a"(tmp) : "dN"(port));
435
    return tmp;
436
};
437
438
 
1408 serge 439
{
1029 serge 440
    u16_t tmp;
441
    __asm__ __volatile__
442
    ("inw %1, %0\n" : "=a"(tmp) : "dN"(port));
443
    return tmp;
444
};
445
446
 
1408 serge 447
{
1029 serge 448
    u32_t tmp;
449
    __asm__ __volatile__
450
    ("inl %1, %0\n" : "=a"(tmp) : "dN"(port));
451
    return tmp;
452
};
453
454
 
1408 serge 455
{
1029 serge 456
     __asm__ __volatile__ (
457
     "call *__imp__Delay"
458
     ::"b" (time));
459
     __asm__ __volatile__ (
460
     "":::"ebx");
461
462
 
463
464
 
1613 serge 465
{
1029 serge 466
     __asm__ __volatile__ (
467
     "call *__imp__ChangeTask");
468
}
469
470
 
1613 serge 471
{
1408 serge 472
    __asm__ __volatile__
473
    (
474
        "call *__imp__SetScreen"
475
        :
476
        :"a" (width-1),"d"(height-1), "c"(pitch)
477
    );
478
    __asm__ __volatile__
479
    ("" :::"eax","ecx","edx");
480
}
481
482
 
483
484
 
485
{
486
    return (void __iomem*) MapIoMem(offset, size, PG_SW|PG_NOCACHE);
2967 Serge 487
}
1408 serge 488
489
 
3391 Serge 490
{
491
    return (void __iomem*) MapIoMem(offset, size, PG_SW|PG_NOCACHE);
492
}
493
494
 
495
 
1408 serge 496
{
497
    FreeKernelSpace(addr);
498
}
499
500
 
501
{
502
    __asm__ __volatile__(
503
    "call *__imp__SysMsgBoardStr"
504
    ::"S" (text));
505
};
506
507
 
2161 serge 508
509
 
3031 serge 510
{
511
    void *mem;
512
513
 
514
    if(mem)
515
        memset(mem, 0, size);
516
517
 
518
};
519
520
 
521
{
522
    KernelFree(addr);
523
}
524
525
 
526
527
 
528
#define RWSEM_ACTIVE_BIAS               0x00000001
529
#define RWSEM_ACTIVE_MASK               0x0000ffff
530
#define RWSEM_WAITING_BIAS              (-0x00010000)
531
#define RWSEM_ACTIVE_READ_BIAS          RWSEM_ACTIVE_BIAS
532
#define RWSEM_ACTIVE_WRITE_BIAS         (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
533
534
 
535
 
3243 Serge 536
//{
537
//    sem->count = RWSEM_UNLOCKED_VALUE;
538
//    spin_lock_init(&sem->wait_lock);
539
//    INIT_LIST_HEAD(&sem->wait_list);
540
//}
541
3031 serge 542
 
1408 serge 543
>