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