Subversion Repositories Kolibri OS

Rev

Rev 700 | Rev 732 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

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