Subversion Repositories Kolibri OS

Rev

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

Rev Author Line No. Line
431 serge 1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2
;;                                                              ;;
3
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
4
;; Distributed under terms of the GNU General Public License    ;;
5
;;                                                              ;;
6
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
164 serge 7
 
593 mikedld 8
$Revision: 662 $
9
 
10
 
465 serge 11
DRV_COMPAT   equ  5  ;minimal required drivers version
12
DRV_CURRENT  equ  5  ;current drivers model version
214 serge 13
 
227 serge 14
DRV_VERSION equ (DRV_COMPAT shl 16) or DRV_CURRENT
15
 
164 serge 16
align 4
17
proc attach_int_handler stdcall, irq:dword, handler:dword
18
 
19
	 mov ebx, [irq]        ;irq num
20
	 test ebx, ebx
21
	 jz .err
22
	 mov eax, [handler]
23
	 test eax, eax
24
	 jz .err
25
	 mov [irq_tab+ebx*4], eax
26
         stdcall enable_irq, [irq]
27
	 ret
28
.err:
29
	 xor eax, eax
30
	 ret
31
endp
32
 
33
align 4
34
proc  detach_int_handler
35
 
36
	   ret
37
endp
38
 
39
align 4
40
proc enable_irq stdcall, irq_line:dword
41
           mov ebx, [irq_line]
42
           mov edx, 0x21
43
           cmp ebx, 8
44
           jb @F
45
           mov edx, 0xA1
46
           sub ebx,8
47
@@:
48
           in al,dx
49
           btr eax, ebx
50
           out dx, al
51
           ret
52
endp
53
 
54
align 16
55
;; proc irq_serv
56
 
57
irq_serv:
58
 
59
.irq_1:
60
	   push eax
61
	   mov eax, 1
62
	   jmp .main
63
align 4
64
.irq_2:
65
	   push eax
66
	   mov eax, 2
67
	   jmp .main
68
align 4
69
.irq_3:
70
	   push eax
71
	   mov eax, 3
72
	   jmp .main
73
align 4
74
.irq_4:
75
	   push eax
76
	   mov eax, 4
77
	   jmp .main
78
align 4
79
.irq_5:
80
	   push eax
81
	   mov eax, 5
82
	   jmp .main
83
align 4
84
.irq_6:
85
	   push eax
86
	   mov eax, 6
87
	   jmp .main
88
align 4
89
.irq_7:
90
	   push eax
91
	   mov eax, 7
92
	   jmp .main
93
align 4
94
.irq_8:
95
	   push eax
96
	   mov eax, 8
97
	   jmp .main
98
align 4
99
.irq_9:
100
	   push eax
101
	   mov eax, 9
102
	   jmp .main
103
align 4
104
.irq_10:
105
	   push eax
106
	   mov eax, 10
107
	   jmp .main
108
align 4
109
.irq_11:
110
	   push eax
111
	   mov eax, 11
112
	   jmp .main
113
align 4
114
.irq_12:
115
	   push eax
116
	   mov eax, 12
117
	   jmp .main
118
align 4
119
.irq_13:
120
	   push eax
121
	   mov eax, 13
122
	   jmp .main
123
align 4
124
.irq_14:
125
	   push eax
126
	   mov eax, 14
127
	   jmp .main
128
align 4
129
.irq_15:
130
	   push eax
131
	   mov eax, 15
132
	   jmp .main
133
 
134
align 16
135
.main:
136
	   save_ring3_context
465 serge 137
           mov   bx, app_data  ;os_data
164 serge 138
	   mov	 ds, bx
139
	   mov	 es, bx
140
 
141
	   mov ebx, [irq_tab+eax*4]
142
	   test ebx, ebx
143
	   jz .exit
144
 
145
           call ebx
479 kastigar 146
           mov  [check_idle_semaphore],5
164 serge 147
 
148
.exit:
149
	   restore_ring3_context
150
 
151
           cmp eax, 8
152
	   mov al, 0x20
153
           jb @f
154
	   out 0xa0, al
155
@@:
156
           out 0x20, al
157
 
158
           pop eax
159
	   iret
160
 
161
align 4
162
proc get_notify stdcall, p_ev:dword
163
 
164
.wait:
465 serge 165
           mov ebx,[current_slot]
166
           test dword [ebx+APPDATA.event_mask],EVENT_NOTIFY
164 serge 167
	   jz @f
465 serge 168
           and dword [ebx+APPDATA.event_mask], not EVENT_NOTIFY
164 serge 169
	   mov edi, [p_ev]
170
	   mov dword [edi], EV_INTR
465 serge 171
           mov eax, [ebx+APPDATA.event]
164 serge 172
	   mov dword [edi+4], eax
173
	   ret
174
@@:
175
	   call change_task
176
	   jmp .wait
177
endp
178
 
179
align 4
180
proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
181
	   xor eax, eax
182
	   xor ebx, ebx
183
	   mov ah, byte [bus]
184
           mov al, 6
185
	   mov bh, byte [devfn]
186
	   mov bl, byte [reg]
187
	   call pci_read_reg
188
	   ret
189
endp
190
 
191
align 4
557 serge 192
proc pci_read16 stdcall, bus:dword, devfn:dword, reg:dword
193
	   xor eax, eax
194
	   xor ebx, ebx
195
	   mov ah, byte [bus]
196
           mov al, 5
197
	   mov bh, byte [devfn]
198
	   mov bl, byte [reg]
199
	   call pci_read_reg
200
	   ret
201
endp
202
 
203
align 4
164 serge 204
proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
205
	   xor eax, eax
206
	   xor ebx, ebx
207
	   mov ah, byte [bus]
208
           mov al, 4
209
	   mov bh, byte [devfn]
210
	   mov bl, byte [reg]
211
	   call pci_read_reg
212
	   ret
213
endp
214
 
215
align 4
216
proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
217
	   xor eax, eax
218
	   xor ebx, ebx
219
	   mov ah, byte [bus]
220
           mov al, 8
221
	   mov bh, byte [devfn]
222
	   mov bl, byte [reg]
223
           mov ecx, [val]
224
           call pci_write_reg
225
	   ret
226
endp
227
 
557 serge 228
align 4
229
proc pci_write16 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
230
	   xor eax, eax
231
	   xor ebx, ebx
232
	   mov ah, byte [bus]
233
           mov al, 9
234
	   mov bh, byte [devfn]
235
	   mov bl, byte [reg]
236
           mov ecx, [val]
237
           call pci_write_reg
238
	   ret
239
endp
240
 
164 serge 241
handle     equ  IOCTL.handle
242
io_code    equ  IOCTL.io_code
243
input      equ  IOCTL.input
244
inp_size   equ  IOCTL.inp_size
245
output     equ  IOCTL.output
246
out_size   equ  IOCTL.out_size
247
 
248
 
249
align 4
250
proc srv_handler stdcall, ioctl:dword
251
           mov esi, [ioctl]
252
           test esi, esi
253
           jz .err
254
 
255
           mov edi, [esi+handle]
256
           cmp [edi+SRV.magic], ' SRV'
257
	   jne .fail
258
 
259
           cmp [edi+SRV.size], SRV_SIZE
260
	   jne .fail
261
 
262
           stdcall [edi+SRV.srv_proc], esi
263
           ret
264
.fail:
265
           xor eax, eax
266
           not eax
267
           mov [esi+output], eax
268
           mov [esi+out_size], 4
269
           ret
270
.err:
271
           xor eax, eax
272
           not eax
273
           ret
274
endp
275
 
377 serge 276
; param
277
;  ebx= io_control
278
;
279
; retval
280
;  eax= error code
281
 
164 serge 282
align 4
377 serge 283
srv_handlerEx:
465 serge 284
           cmp ebx, OS_BASE
285
           jae .fail
164 serge 286
 
377 serge 287
           mov eax, [ebx+handle]
288
           cmp [eax+SRV.magic], ' SRV'
164 serge 289
	   jne .fail
290
 
377 serge 291
           cmp [eax+SRV.size], SRV_SIZE
164 serge 292
	   jne .fail
293
 
377 serge 294
           stdcall [eax+SRV.srv_proc], ebx
164 serge 295
           ret
296
.fail:
377 serge 297
           or eax, -1
164 serge 298
           ret
299
 
300
restore  handle
301
restore  io_code
302
restore  input
303
restore  inp_size
304
restore  output
305
restore  out_size
306
 
307
align 4
308
proc get_service stdcall, sz_name:dword
188 serge 309
           mov eax, [sz_name]
310
           test eax, eax
311
           jnz @F
312
           ret
164 serge 313
@@:
278 serge 314
           mov edx, [srv.fd]
188 serge 315
@@:
278 serge 316
           cmp edx, srv.fd-SRV_FD_OFFSET
317
           je .not_load
318
 
319
           stdcall strncmp, edx, [sz_name], 16
188 serge 320
           test eax, eax
321
           je .ok
164 serge 322
 
278 serge 323
           mov edx, [edx+SRV.fd]
324
           jmp @B
164 serge 325
.not_load:
346 diamond 326
           pop ebp
327
           jmp load_driver
164 serge 328
.ok:
278 serge 329
           mov eax, edx
188 serge 330
           ret
164 serge 331
endp
332
 
333
align 4
278 serge 334
reg_service:
335
.sz_name equ esp+4
336
.handler equ esp+8
337
           mov eax, [.sz_name]
164 serge 338
	   test eax, eax
339
	   jz .fail
340
 
278 serge 341
           mov ebx, [.handler]
164 serge 342
	   test ebx, ebx
343
	   jz .fail
344
 
278 serge 345
           mov eax, SRV_SIZE
346
           call malloc           ;call alloc_service
164 serge 347
	   test eax, eax
348
	   jz .fail
349
 
350
	   mov edi, eax
278 serge 351
           mov esi, [.sz_name]
352
           mov ecx, 16/4
353
           rep movsd
164 serge 354
 
278 serge 355
           mov [eax+SRV.magic], ' SRV'
356
           mov [eax+SRV.size], SRV_SIZE
357
 
358
           mov ebx, srv.fd-SRV_FD_OFFSET
359
           mov edx, [ebx+SRV.fd]
360
           mov [eax+SRV.fd], edx
361
           mov [eax+SRV.bk], ebx
362
           mov [ebx+SRV.fd], eax
363
           mov [edx+SRV.bk], eax
364
 
365
           mov ecx, [.handler]
366
           mov [eax+SRV.srv_proc], ecx
281 serge 367
           ret 8
164 serge 368
.fail:
369
	   xor eax, eax
281 serge 370
           ret 8
164 serge 371
 
372
align 4
373
proc get_proc stdcall, exp:dword, sz_name:dword
374
 
375
           mov edx, [exp]
376
.next:
377
           mov eax, [edx]
378
           test eax, eax
379
           jz .end
380
 
381
           push edx
382
           stdcall strncmp, eax, [sz_name], 16
383
           pop edx
384
           test eax, eax
385
           jz .ok
386
 
387
           add edx,8
388
           jmp .next
389
.ok:
390
           mov eax, [edx+4]
391
.end:
392
           ret
393
endp
394
 
395
align 4
396
proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
397
 
398
@@:
399
	   stdcall strncmp, [pSym], [sz_sym], 8
400
	   test eax,eax
401
	   jz .ok
402
	   add [pSym], 18
403
	   dec [count]
404
	   jnz @b
405
	   xor eax, eax
406
	   ret
407
.ok:
408
	   mov ebx, [pSym]
409
	   mov eax, [ebx+8]
410
	   ret
411
endp
412
 
413
align 4
188 serge 414
proc get_curr_task
415
           mov eax,[CURRENT_TASK]
416
           shl eax, 8
417
           ret
418
endp
164 serge 419
 
188 serge 420
align 4
421
proc get_fileinfo stdcall, file_name:dword, info:dword
422
           locals
423
             cmd     dd ?
424
             offset  dd ?
425
                     dd ?
426
             count   dd ?
427
             buff    dd ?
428
                     db ?
429
             name    dd ?
430
           endl
164 serge 431
 
188 serge 432
           xor eax, eax
433
           mov ebx, [file_name]
434
           mov ecx, [info]
164 serge 435
 
188 serge 436
           mov [cmd], 5
437
           mov [offset], eax
438
           mov [offset+4], eax
439
           mov [count], eax
440
           mov [buff], ecx
441
           mov byte [buff+4], al
442
           mov [name], ebx
164 serge 443
 
188 serge 444
           mov eax, 70
445
           lea ebx, [cmd]
446
           int 0x40
447
           ret
448
endp
164 serge 449
 
188 serge 450
align 4
451
proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
452
                                     bytes:dword
453
           locals
454
             cmd     dd ?
455
             offset  dd ?
456
                     dd ?
457
             count   dd ?
458
             buff    dd ?
459
                     db ?
460
             name    dd ?
461
           endl
164 serge 462
 
188 serge 463
           xor eax, eax
464
           mov ebx, [file_name]
465
           mov ecx, [off]
466
           mov edx, [bytes]
467
           mov esi, [buffer]
164 serge 468
 
188 serge 469
           mov [cmd], eax
470
           mov [offset], ecx
471
           mov [offset+4], eax
472
           mov [count], edx
473
           mov [buff], esi
474
           mov byte [buff+4], al
475
           mov [name], ebx
476
 
429 serge 477
           pushad
478
           push eax
479
           lea eax, [cmd]
480
           call file_system_lfn
481
           pop eax
482
           popad
188 serge 483
           ret
484
endp
485
 
363 serge 486
; description
487
;  allocate kernel memory and loads the specified file
488
;
489
; param
490
;  file_name= full path to file
491
;
492
; retval
493
;  eax= file image in kernel memory
494
;  ebx= size of file
495
;
496
; warging
497
;  You mast call kernel_free() to delete each file
498
;  loaded by the load_file() function
499
 
188 serge 500
align 4
501
proc load_file stdcall, file_name:dword
502
           locals
503
             attr       dd ?
504
             flags      dd ?
505
             cr_time    dd ?
506
             cr_date    dd ?
507
             acc_time   dd ?
508
             acc_date   dd ?
509
             mod_time   dd ?
510
             mod_date   dd ?
511
             file_size  dd ?
512
 
513
             file       dd ?
211 serge 514
             file2      dd ?
188 serge 515
           endl
516
 
662 serge 517
           push ebx
518
           push esi
519
           push edi
520
 
188 serge 521
           lea eax, [attr]
522
           stdcall get_fileinfo, [file_name], eax
164 serge 523
           test eax, eax
188 serge 524
           jnz .fail
164 serge 525
 
206 serge 526
           mov eax, [file_size]
237 serge 527
           cmp eax, 1024*1024*16
528
           ja .fail
206 serge 529
 
188 serge 530
           stdcall kernel_alloc, [file_size]
531
           mov [file], eax
164 serge 532
 
188 serge 533
           stdcall read_file, [file_name], eax, dword 0, [file_size]
534
           cmp ebx, [file_size]
535
           jne .cleanup
211 serge 536
 
188 serge 537
           mov eax, [file]
211 serge 538
           cmp dword [eax], 0x4B43504B
539
           jne .exit
237 serge 540
           mov ebx, [eax+4]
541
           mov [file_size], ebx
542
           stdcall kernel_alloc, ebx
211 serge 543
 
544
           test eax, eax
545
           jz .cleanup
546
 
547
           mov [file2], eax
548
           stdcall unpack, [file], eax
549
           stdcall kernel_free, [file]
550
           mov eax, [file2]
237 serge 551
           mov ebx, [file_size]
211 serge 552
.exit:
269 serge 553
           push eax
554
           lea edi, [eax+ebx]     ;cleanup remain space
357 serge 555
           mov ecx, 4096          ;from file end
556
           and ebx, 4095
521 diamond 557
           jz  @f
269 serge 558
           sub ecx, ebx
559
           xor eax, eax
560
           cld
561
           rep stosb
521 diamond 562
@@:
357 serge 563
           mov ebx, [file_size]
269 serge 564
           pop eax
662 serge 565
           pop edi
566
           pop esi
567
           pop ebx
188 serge 568
           ret
569
.cleanup:
570
           stdcall kernel_free, [file]
571
.fail:
572
           xor eax, eax
237 serge 573
           xor ebx, ebx
662 serge 574
           pop edi
575
           pop esi
576
           pop ebx
188 serge 577
           ret
578
endp
164 serge 579
 
188 serge 580
align 4
581
proc get_proc_ex stdcall, proc_name:dword, imports:dword
582
 
583
.look_up:
584
           mov edx, [imports]
198 serge 585
           test edx, edx
586
           jz .end
188 serge 587
           mov edx, [edx]
588
           test edx, edx
589
           jz .end
590
.next:
591
           mov eax, [edx]
164 serge 592
           test eax, eax
188 serge 593
           jz .next_table
164 serge 594
 
188 serge 595
           push edx
596
           stdcall strncmp, eax, [proc_name], 16
597
           pop edx
598
           test eax, eax
599
           jz .ok
164 serge 600
 
188 serge 601
           add edx,8
602
           jmp .next
603
.next_table:
604
           add [imports], 4
605
           jmp .look_up
606
.ok:
607
           mov eax, [edx+4]
608
           ret
609
.end:
610
           xor eax, eax
611
           ret
612
endp
164 serge 613
 
188 serge 614
align 4
615
proc fix_coff_symbols stdcall, sec:dword, symbols:dword,\
616
                      sym_count:dword, strings:dword, imports:dword
617
           locals
618
             retval dd ?
619
           endl
164 serge 620
 
188 serge 621
           mov edi, [symbols]
622
           mov [retval], 1
623
.fix:
624
           movzx ebx, [edi+CSYM.SectionNumber]
625
           test ebx, ebx
626
           jnz .internal
627
           mov eax, dword [edi+CSYM.Name]
628
           test eax, eax
629
           jnz @F
164 serge 630
 
188 serge 631
           mov edi, [edi+4]
632
           add edi, [strings]
633
@@:
634
           push edi
635
           stdcall get_proc_ex, edi,[imports]
636
           pop edi
164 serge 637
 
188 serge 638
           xor ebx, ebx
639
           test eax, eax
640
           jnz @F
164 serge 641
 
188 serge 642
           mov esi, msg_unresolved
643
           call sys_msg_board_str
644
           mov esi, edi
645
           call sys_msg_board_str
646
           mov esi, msg_CR
647
           call sys_msg_board_str
164 serge 648
 
188 serge 649
           mov [retval],0
650
@@:
651
           mov edi, [symbols]
652
           mov [edi+CSYM.Value], eax
653
           jmp .next
654
.internal:
541 serge 655
           cmp bx, -1
656
           je .next
657
           cmp bx, -2
658
           je .next
659
 
188 serge 660
           dec ebx
661
           shl ebx, 3
662
           lea ebx, [ebx+ebx*4]
663
           add ebx, [sec]
664
 
665
           mov eax, [ebx+CFS.VirtualAddress]
666
           add [edi+CSYM.Value], eax
667
.next:
668
           add edi, CSYM_SIZE
669
           mov [symbols], edi
670
           dec [sym_count]
671
           jnz .fix
672
           mov eax, [retval]
673
           ret
164 serge 674
endp
675
 
676
align 4
188 serge 677
proc fix_coff_relocs stdcall, coff:dword, sec:dword, sym:dword
164 serge 678
	   locals
188 serge 679
             n_sec     dd ?
164 serge 680
	   endl
681
 
188 serge 682
           mov eax, [coff]
683
           movzx ebx, [eax+CFH.nSections]
684
           mov [n_sec], ebx
685
.fix_sec:
686
           mov esi, [sec]
164 serge 687
	   mov edi, [esi+CFS.PtrReloc]
188 serge 688
           add edi, [coff]
164 serge 689
 
188 serge 690
           movzx ecx, [esi+CFS.NumReloc]
691
           test ecx, ecx
692
           jz .next
693
.next_reloc:
164 serge 694
	   mov ebx, [edi+CRELOC.SymIndex]
695
	   add ebx,ebx
696
	   lea ebx,[ebx+ebx*8]
188 serge 697
           add ebx, [sym]
164 serge 698
 
188 serge 699
           mov edx, [ebx+CSYM.Value]
164 serge 700
 
188 serge 701
           cmp [edi+CRELOC.Type], 6
702
           je .dir_32
164 serge 703
 
188 serge 704
           cmp [edi+CRELOC.Type], 20
705
           jne .next_reloc
706
.rel_32:
164 serge 707
	   mov eax, [edi+CRELOC.VirtualAddress]
188 serge 708
           add eax, [esi+CFS.VirtualAddress]
709
           sub edx, eax
710
           sub edx, 4
711
           jmp .fix
712
.dir_32:
713
	   mov eax, [edi+CRELOC.VirtualAddress]
714
           add eax, [esi+CFS.VirtualAddress]
715
.fix:
716
           add [eax], edx
717
           add edi, 10
718
           dec ecx
719
           jnz .next_reloc
720
.next:
206 serge 721
           add [sec], COFF_SECTION_SIZE
188 serge 722
           dec [n_sec]
723
           jnz .fix_sec
164 serge 724
.exit:
725
	   ret
726
endp
727
 
188 serge 728
align 4
346 diamond 729
proc load_driver stdcall, driver_name:dword
188 serge 730
           locals
731
             coff      dd ?
732
             sym       dd ?
733
             strings   dd ?
734
             img_size  dd ?
735
             img_base  dd ?
736
             start     dd ?
737
 
738
             exports   dd ?   ;fake exports table
739
                       dd ?
525 diamond 740
             file_name rb 13+16+4+1      ; '/sys/drivers/.obj'
188 serge 741
           endl
742
 
465 serge 743
           lea     edx, [file_name]
525 diamond 744
           mov     dword [edx], '/sys'
745
           mov     dword [edx+4], '/dri'
746
           mov     dword [edx+8], 'vers'
747
           mov     byte [edx+12], '/'
465 serge 748
           mov     esi, [driver_name]
525 diamond 749
           lea     edi, [edx+13]
465 serge 750
           mov     ecx, 16
346 diamond 751
@@:
465 serge 752
           lodsb
753
           test    al, al
754
           jz      @f
755
           stosb
756
           loop    @b
346 diamond 757
@@:
465 serge 758
           mov     dword [edi], '.obj'
759
           mov     byte [edi+4], 0
346 diamond 760
           stdcall load_file, edx
214 serge 761
 
188 serge 762
           test eax, eax
227 serge 763
           jz .exit
188 serge 764
 
765
           mov [coff], eax
766
 
767
           movzx ecx, [eax+CFH.nSections]
768
           xor ebx, ebx
769
 
770
           lea edx, [eax+20]
771
@@:
772
           add ebx, [edx+CFS.SizeOfRawData]
773
           add ebx, 15
774
           and ebx, not 15
206 serge 775
           add edx, COFF_SECTION_SIZE
188 serge 776
           dec ecx
777
           jnz @B
778
           mov [img_size], ebx
779
 
780
           stdcall kernel_alloc, ebx
781
           test eax, eax
782
           jz .fail
783
           mov [img_base], eax
784
 
785
           mov edi, eax
786
           xor eax, eax
787
           mov ecx, [img_size]
788
           add ecx, 4095
789
           and ecx, not 4095
790
           shr ecx, 2
791
           cld
792
           rep stosd
793
 
794
           mov edx, [coff]
795
           movzx ebx, [edx+CFH.nSections]
796
           mov edi, [img_base]
797
           lea eax, [edx+20]
798
@@:
799
           mov [eax+CFS.VirtualAddress], edi
800
           mov esi, [eax+CFS.PtrRawData]
801
           test esi, esi
802
           jnz .copy
803
           add edi, [eax+CFS.SizeOfRawData]
804
           jmp .next
805
.copy:
806
           add esi, edx
807
           mov ecx, [eax+CFS.SizeOfRawData]
808
           cld
809
           rep movsb
810
.next:
811
           add edi, 15
812
           and edi, not 15
206 serge 813
           add eax, COFF_SECTION_SIZE
188 serge 814
           dec ebx
815
           jnz @B
816
 
817
           mov ebx, [edx+CFH.pSymTable]
818
           add ebx, edx
819
           mov [sym], ebx
820
           mov ecx, [edx+CFH.nSymbols]
821
           add ecx,ecx
822
           lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
823
           add ecx, [sym]
824
           mov [strings], ecx
825
 
826
           lea ebx, [exports]
827
           mov dword [ebx], kernel_export
828
           mov dword [ebx+4], 0
829
           lea eax, [edx+20]
830
 
831
           stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
832
                                     [strings], ebx
833
           test eax, eax
227 serge 834
           jz .link_fail
188 serge 835
 
836
           mov ebx, [coff]
837
           add ebx, 20
838
           stdcall fix_coff_relocs, [coff], ebx, [sym]
839
 
840
           mov ebx, [coff]
227 serge 841
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szVersion
842
           test eax, eax
843
           jz .link_fail
844
 
845
           mov eax, [eax]
846
           shr eax, 16
847
           cmp eax, DRV_COMPAT
848
           jb .ver_fail
849
 
850
           cmp eax, DRV_CURRENT
851
           ja .ver_fail
852
 
853
           mov ebx, [coff]
188 serge 854
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szSTART
855
           mov [start], eax
856
 
857
           stdcall kernel_free, [coff]
858
 
859
           mov ebx, [start]
214 serge 860
           stdcall ebx, DRV_ENTRY
188 serge 861
           test eax, eax
862
           jnz .ok
863
 
864
           stdcall kernel_free, [img_base]
865
           xor eax, eax
866
           ret
867
.ok:
868
           mov ebx, [img_base]
869
           mov [eax+SRV.base], ebx
214 serge 870
           mov ecx, [start]
871
           mov [eax+SRV.entry], ecx
188 serge 872
           ret
227 serge 873
 
874
.ver_fail:
875
           mov esi, msg_CR
876
           call sys_msg_board_str
346 diamond 877
           mov esi, [driver_name]
227 serge 878
           call sys_msg_board_str
879
           mov esi, msg_CR
880
           call sys_msg_board_str
881
           mov esi, msg_version
882
           call sys_msg_board_str
883
           mov esi, msg_www
884
           call sys_msg_board_str
885
           jmp .cleanup
886
 
887
.link_fail:
888
           mov esi, msg_module
889
           call sys_msg_board_str
346 diamond 890
           mov esi, [driver_name]
227 serge 891
           call sys_msg_board_str
892
           mov esi, msg_CR
893
           call sys_msg_board_str
894
.cleanup:
895
           stdcall kernel_free,[img_base]
188 serge 896
.fail:
227 serge 897
           stdcall kernel_free, [coff]
898
.exit:
188 serge 899
           xor eax, eax
900
           ret
164 serge 901
endp
902
 
198 serge 903
align 4
904
proc load_library stdcall, file_name:dword
905
           locals
906
             coff      dd ?
907
             sym       dd ?
908
             strings   dd ?
909
             img_size  dd ?
910
             img_base  dd ?
911
             exports   dd ?
912
           endl
913
 
914
           cli
915
 
916
           stdcall load_file, [file_name]
917
           test eax, eax
918
           jz .fail
919
 
920
           mov [coff], eax
921
           movzx ecx, [eax+CFH.nSections]
922
           xor ebx, ebx
923
 
924
           lea edx, [eax+20]
925
@@:
926
           add ebx, [edx+CFS.SizeOfRawData]
927
           add ebx, 15
928
           and ebx, not 15
206 serge 929
           add edx, COFF_SECTION_SIZE
198 serge 930
           dec ecx
931
           jnz @B
932
           mov [img_size], ebx
933
 
934
           call init_heap
935
           stdcall user_alloc, [img_size]
936
 
937
           test eax, eax
938
           jz .fail
939
           mov [img_base], eax
940
 
941
           mov edx, [coff]
942
           movzx ebx, [edx+CFH.nSections]
943
           mov edi, [img_base]
944
           lea eax, [edx+20]
945
@@:
946
           mov [eax+CFS.VirtualAddress], edi
947
           mov esi, [eax+CFS.PtrRawData]
948
           test esi, esi
949
           jnz .copy
950
           add edi, [eax+CFS.SizeOfRawData]
951
           jmp .next
952
.copy:
953
           add esi, edx
465 serge 954
    ;       add edi, new_app_base
198 serge 955
           mov ecx, [eax+CFS.SizeOfRawData]
956
           cld
957
           rep movsb
958
.next:
465 serge 959
           add edi, 15 ;-new_app_base
960
           and edi, -16
206 serge 961
           add eax, COFF_SECTION_SIZE
198 serge 962
           dec ebx
963
           jnz @B
964
 
965
           mov ebx, [edx+CFH.pSymTable]
966
           add ebx, edx
967
           mov [sym], ebx
968
           mov ecx, [edx+CFH.nSymbols]
969
           add ecx,ecx
970
           lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
971
           add ecx, [sym]
972
           mov [strings], ecx
973
 
974
           lea eax, [edx+20]
975
 
976
           stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
977
                                     [strings], dword 0
978
           test eax, eax
979
           jnz @F
980
 
981
@@:
982
           mov edx, [coff]
983
           movzx ebx, [edx+CFH.nSections]
984
           mov edi, new_app_base
985
           lea eax, [edx+20]
986
@@:
987
           add [eax+CFS.VirtualAddress], edi  ;patch user space offset
206 serge 988
           add eax, COFF_SECTION_SIZE
198 serge 989
           dec ebx
990
           jnz @B
991
 
992
           add edx, 20
993
           stdcall fix_coff_relocs, [coff], edx, [sym]
994
 
995
           mov ebx, [coff]
996
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szEXPORTS
997
           mov [exports], eax
998
 
999
           stdcall kernel_free, [coff]
1000
           mov eax, [exports]
1001
           ret
1002
.fail:
1003
           xor eax, eax
1004
           ret
1005
endp
1006
 
214 serge 1007
align 4
1008
proc stop_all_services
278 serge 1009
 
1010
           mov edx, [srv.fd]
214 serge 1011
.next:
278 serge 1012
           cmp edx,  srv.fd-SRV_FD_OFFSET
1013
           je .done
1014
           cmp [edx+SRV.magic], ' SRV'
227 serge 1015
           jne .next
278 serge 1016
           cmp [edx+SRV.size], SRV_SIZE
227 serge 1017
           jne .next
278 serge 1018
           mov ebx, [edx+SRV.entry]
1019
           mov edx, [edx+SRV.fd]
1020
           push edx
214 serge 1021
           stdcall ebx, dword -1
278 serge 1022
           pop edx
214 serge 1023
           jmp .next
278 serge 1024
.done:
1025
           ret
214 serge 1026
endp
198 serge 1027
 
281 serge 1028
; param
291 serge 1029
;  eax= size
1030
;  ebx= pid
214 serge 1031
 
281 serge 1032
align 4
1033
create_kernel_object:
1034
 
1035
           push ebx
1036
           call malloc
1037
           pop ebx
1038
           test eax, eax
1039
           jz .fail
1040
 
465 serge 1041
           mov ecx,[current_slot]
1042
           add ecx, APP_OBJ_OFFSET
281 serge 1043
 
345 serge 1044
           pushfd
1045
           cli
281 serge 1046
           mov edx, [ecx+APPOBJ.fd]
1047
           mov [eax+APPOBJ.fd], edx
1048
           mov [eax+APPOBJ.bk], ecx
1049
           mov [eax+APPOBJ.pid], ebx
1050
 
1051
           mov [ecx+APPOBJ.fd], eax
1052
           mov [edx+APPOBJ.bk], eax
345 serge 1053
           popfd
281 serge 1054
.fail:
1055
           ret
1056
 
1057
; param
1058
;  eax= object
1059
 
1060
align 4
1061
destroy_kernel_object:
1062
 
345 serge 1063
           pushfd
1064
           cli
281 serge 1065
           mov ebx, [eax+APPOBJ.fd]
1066
           mov ecx, [eax+APPOBJ.bk]
1067
           mov [ebx+APPOBJ.bk], ecx
1068
           mov [ecx+APPOBJ.fd], ebx
345 serge 1069
           popfd
281 serge 1070
 
1071
           xor edx, edx        ;clear common header
1072
           mov [eax], edx
1073
           mov [eax+4], edx
1074
           mov [eax+8], edx
1075
           mov [eax+12], edx
1076
           mov [eax+16], edx
1077
 
1078
           call free           ;release object memory
1079
           ret
1080
 
1081
 
164 serge 1082
 
465 serge 1083
if 0
164 serge 1084
 
465 serge 1085
irq:
188 serge 1086
 
465 serge 1087
.irq0:
1088
           pusfd
1089
           pushad
1090
           push IRQ_0
1091
           jmp .master
1092
.irq_1:
1093
           pusfd
1094
           pushad
1095
           push IRQ_1
1096
           jmp .master
1097
 
1098
.master:
1099
           mov ax, app_data
1100
           mov ds, eax
1101
           mov es, eax
1102
           mov ebx, [esp+4]  ;IRQ_xx
1103
           mov eax, [irq_handlers+ebx+4]
1104
           call intr_handler
1105
           mov ecx, [esp+4]
1106
           cmp [irq_actids+ecx*4], 0
1107
           je @F
1108
           in al, 0x21
1109
           bts eax, ecx
1110
           out 0x21, al
1111
           mov al, 0x20
1112
           out 0x20, al
1113
           jmp .restart
1114
 
1115
.slave:
1116
           mov ax, app_data
1117
           mov ds, eax
1118
           mov es, eax
1119
           mov ebx, [esp+4]  ;IRQ_xx
1120
           mov eax, [irq_handlers+ebx+4]
1121
           call intr_handler
1122
           mov ecx, [esp+4]
1123
           sub ecx, 8
1124
           cmp [irq_actids+ecx*4], 0
1125
           je @F
1126
           in al, 0xA1
1127
           bts eax, ecx
1128
           out 0xA1, al
1129
           mov al, 0x20
1130
           out 0xA0, al
1131
           out 0x20, al
1132
.restart:
1133
           mov ebx, [next_slot]
1134
           test ebx, ebx
1135
           jz @F
1136
           mov [next_task],0
1137
           mov esi, [prev_slot]
1138
           call do_change_task
1139
           add esp, 4
1140
           iretd
1141
 
1142
end if
1143