WebSVN – Kolibri OS – Diff – /kernel/trunk/core/dll.inc


$Revision: 479 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
DRV_COMPAT   equ  5  ;minimal required drivers version
DRV_CURRENT  equ  5  ;current drivers model version
 
DRV_VERSION equ (DRV_COMPAT shl 16) or DRV_CURRENT
 
align 4
proc attach_int_handler stdcall, irq:dword, handler:dword
 
	 mov ebx, [irq]        ;irq num
	 test ebx, ebx
	 jz .err
	 mov eax, [handler]
	 test eax, eax
	 jz .err
	 mov [irq_tab+ebx*4], eax
         stdcall enable_irq, [irq]
	 ret
.err:
	 xor eax, eax
	 ret
endp
 
align 4
proc  detach_int_handler
 
	   ret
endp
 
align 4
proc enable_irq stdcall, irq_line:dword
           mov ebx, [irq_line]
           mov edx, 0x21
           cmp ebx, 8
           jb @F
           mov edx, 0xA1
           sub ebx,8
@@:
           in al,dx
           btr eax, ebx
           out dx, al
           ret
endp
 
align 16
;; proc irq_serv
 
irq_serv:
 
.irq_1:
	   push eax
	   mov eax, 1
	   jmp .main
align 4
.irq_2:
	   push eax
	   mov eax, 2
	   jmp .main
align 4
.irq_3:
	   push eax
	   mov eax, 3
	   jmp .main
align 4
.irq_4:
	   push eax
	   mov eax, 4
	   jmp .main
align 4
.irq_5:
	   push eax
	   mov eax, 5
	   jmp .main
align 4
.irq_6:
	   push eax
	   mov eax, 6
	   jmp .main
align 4
.irq_7:
	   push eax
	   mov eax, 7
	   jmp .main
align 4
.irq_8:
	   push eax
	   mov eax, 8
	   jmp .main
align 4
.irq_9:
	   push eax
	   mov eax, 9
	   jmp .main
align 4
.irq_10:
	   push eax
	   mov eax, 10
	   jmp .main
align 4
.irq_11:
	   push eax
	   mov eax, 11
	   jmp .main
align 4
.irq_12:
	   push eax
	   mov eax, 12
	   jmp .main
align 4
.irq_13:
	   push eax
	   mov eax, 13
	   jmp .main
align 4
.irq_14:
	   push eax
	   mov eax, 14
	   jmp .main
align 4
.irq_15:
	   push eax
	   mov eax, 15
	   jmp .main
 
align 16
.main:
	   save_ring3_context
           mov   bx, app_data  ;os_data
	   mov	 ds, bx
	   mov	 es, bx
 
	   mov ebx, [irq_tab+eax*4]
	   test ebx, ebx
	   jz .exit
 
           call ebx
           mov  [check_idle_semaphore],5
 
.exit:
	   restore_ring3_context
 
           cmp eax, 8
	   mov al, 0x20
           jb @f
	   out 0xa0, al
@@:
           out 0x20, al
 
           pop eax
	   iret
 
align 4
proc get_notify stdcall, p_ev:dword
 
.wait:
           mov ebx,[current_slot]
           test dword [ebx+APPDATA.event_mask],EVENT_NOTIFY
	   jz @f
           and dword [ebx+APPDATA.event_mask], not EVENT_NOTIFY
	   mov edi, [p_ev]
	   mov dword [edi], EV_INTR
           mov eax, [ebx+APPDATA.event]
	   mov dword [edi+4], eax
	   ret
@@:
	   call change_task
	   jmp .wait
endp
 
align 4
proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
           mov al, 6
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
	   call pci_read_reg
	   ret
endp
 
align 4
proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
           mov al, 4
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
	   call pci_read_reg
	   ret
endp
 
align 4
proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
	   xor eax, eax
	   xor ebx, ebx
	   mov ah, byte [bus]
           mov al, 8
	   mov bh, byte [devfn]
	   mov bl, byte [reg]
           mov ecx, [val]
           call pci_write_reg
	   ret
endp
 
handle     equ  IOCTL.handle
io_code    equ  IOCTL.io_code
input      equ  IOCTL.input
inp_size   equ  IOCTL.inp_size
output     equ  IOCTL.output
out_size   equ  IOCTL.out_size
 
 
align 4
proc srv_handler stdcall, ioctl:dword
           mov esi, [ioctl]
           test esi, esi
           jz .err
 
           mov edi, [esi+handle]
           cmp [edi+SRV.magic], ' SRV'
	   jne .fail
 
           cmp [edi+SRV.size], SRV_SIZE
	   jne .fail
 
           stdcall [edi+SRV.srv_proc], esi
           ret
.fail:
           xor eax, eax
           not eax
           mov [esi+output], eax
           mov [esi+out_size], 4
           ret
.err:
           xor eax, eax
           not eax
           ret
endp
 
; param
;  ebx= io_control
;
; retval
;  eax= error code
 
align 4
srv_handlerEx:
           cmp ebx, OS_BASE
           jae .fail
 
           mov eax, [ebx+handle]
           cmp [eax+SRV.magic], ' SRV'
	   jne .fail
 
           cmp [eax+SRV.size], SRV_SIZE
	   jne .fail
 
           stdcall [eax+SRV.srv_proc], ebx
           ret
.fail:
           or eax, -1
           ret
 
restore  handle
restore  io_code
restore  input
restore  inp_size
restore  output
restore  out_size
 
align 4
proc get_service stdcall, sz_name:dword
           mov eax, [sz_name]
           test eax, eax
           jnz @F
           ret
@@:
           mov edx, [srv.fd]
@@:
           cmp edx, srv.fd-SRV_FD_OFFSET
           je .not_load
 
           stdcall strncmp, edx, [sz_name], 16
           test eax, eax
           je .ok
 
           mov edx, [edx+SRV.fd]
           jmp @B
.not_load:
           pop ebp
           jmp load_driver
.ok:
           mov eax, edx
           ret
endp
 
align 4
reg_service:
.sz_name equ esp+4
.handler equ esp+8
           mov eax, [.sz_name]
	   test eax, eax
	   jz .fail
 
           mov ebx, [.handler]
	   test ebx, ebx
	   jz .fail
 
           mov eax, SRV_SIZE
           call malloc           ;call alloc_service
	   test eax, eax
	   jz .fail
 
	   mov edi, eax
           mov esi, [.sz_name]
           mov ecx, 16/4
           rep movsd
 
           mov [eax+SRV.magic], ' SRV'
           mov [eax+SRV.size], SRV_SIZE
 
           mov ebx, srv.fd-SRV_FD_OFFSET
           mov edx, [ebx+SRV.fd]
           mov [eax+SRV.fd], edx
           mov [eax+SRV.bk], ebx
           mov [ebx+SRV.fd], eax
           mov [edx+SRV.bk], eax
 
           mov ecx, [.handler]
           mov [eax+SRV.srv_proc], ecx
           ret 8
.fail:
	   xor eax, eax
           ret 8
 
align 4
proc get_proc stdcall, exp:dword, sz_name:dword
 
           mov edx, [exp]
.next:
           mov eax, [edx]
           test eax, eax
           jz .end
 
           push edx
           stdcall strncmp, eax, [sz_name], 16
           pop edx
           test eax, eax
           jz .ok
 
           add edx,8
           jmp .next
.ok:
           mov eax, [edx+4]
.end:
           ret
endp
 
align 4
proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
 
@@:
	   stdcall strncmp, [pSym], [sz_sym], 8
	   test eax,eax
	   jz .ok
	   add [pSym], 18
	   dec [count]
	   jnz @b
	   xor eax, eax
	   ret
.ok:
	   mov ebx, [pSym]
	   mov eax, [ebx+8]
	   ret
endp
 
align 4
proc get_curr_task
           mov eax,[CURRENT_TASK]
           shl eax, 8
           ret
endp
 
align 4
proc get_fileinfo stdcall, file_name:dword, info:dword
           locals
             cmd     dd ?
             offset  dd ?
                     dd ?
             count   dd ?
             buff    dd ?
                     db ?
             name    dd ?
           endl
 
           xor eax, eax
           mov ebx, [file_name]
    ;       sub ebx, new_app_base
           mov ecx, [info]
    ;       sub ecx, new_app_base
 
           mov [cmd], 5
           mov [offset], eax
           mov [offset+4], eax
           mov [count], eax
           mov [buff], ecx
           mov byte [buff+4], al
           mov [name], ebx
 
           mov eax, 70
           lea ebx, [cmd]
     ;      sub ebx, new_app_base
           int 0x40
           ret
endp
 
align 4
proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
                                     bytes:dword
           locals
             cmd     dd ?
             offset  dd ?
                     dd ?
             count   dd ?
             buff    dd ?
                     db ?
             name    dd ?
           endl
 
           xor eax, eax
           mov ebx, [file_name]
           mov ecx, [off]
           mov edx, [bytes]
           mov esi, [buffer]
 
           mov [cmd], eax
           mov [offset], ecx
           mov [offset+4], eax
           mov [count], edx
           mov [buff], esi
           mov byte [buff+4], al
           mov [name], ebx
 
           pushad
           push eax
           lea eax, [cmd]
           call file_system_lfn
           pop eax
           popad
           ret
endp
 
; description
;  allocate kernel memory and loads the specified file
;
; param
;  file_name= full path to file
;
; retval
;  eax= file image in kernel memory
;  ebx= size of file
;
; warging
;  You mast call kernel_free() to delete each file
;  loaded by the load_file() function
 
align 4
proc load_file stdcall, file_name:dword
           locals
             attr       dd ?
             flags      dd ?
             cr_time    dd ?
             cr_date    dd ?
             acc_time   dd ?
             acc_date   dd ?
             mod_time   dd ?
             mod_date   dd ?
             file_size  dd ?
 
             file       dd ?
             file2      dd ?
           endl
 
           lea eax, [attr]
           stdcall get_fileinfo, [file_name], eax
           test eax, eax
           jnz .fail
 
           mov eax, [file_size]
           cmp eax, 1024*1024*16
           ja .fail
 
           stdcall kernel_alloc, [file_size]
           mov [file], eax
 
           stdcall read_file, [file_name], eax, dword 0, [file_size]
           cmp ebx, [file_size]
           jne .cleanup
 
           mov eax, [file]
           cmp dword [eax], 0x4B43504B
           jne .exit
           mov ebx, [eax+4]
           mov [file_size], ebx
           stdcall kernel_alloc, ebx
 
           test eax, eax
           jz .cleanup
 
           mov [file2], eax
           stdcall unpack, [file], eax
           stdcall kernel_free, [file]
           mov eax, [file2]
           mov ebx, [file_size]
.exit:
           push eax
           lea edi, [eax+ebx]     ;cleanup remain space
           mov ecx, 4096          ;from file end
           and ebx, 4095
           sub ecx, ebx
           xor eax, eax
           cld
           rep stosb
           mov ebx, [file_size]
           pop eax
           ret
.cleanup:
           stdcall kernel_free, [file]
.fail:
           xor eax, eax
           xor ebx, ebx
           ret
endp
 
align 4
proc get_proc_ex stdcall, proc_name:dword, imports:dword
 
.look_up:
           mov edx, [imports]
           test edx, edx
           jz .end
           mov edx, [edx]
           test edx, edx
           jz .end
.next:
           mov eax, [edx]
           test eax, eax
           jz .next_table
 
           push edx
           stdcall strncmp, eax, [proc_name], 16
           pop edx
           test eax, eax
           jz .ok
 
           add edx,8
           jmp .next
.next_table:
           add [imports], 4
           jmp .look_up
.ok:
           mov eax, [edx+4]
           ret
.end:
           xor eax, eax
           ret
endp
 
align 4
proc fix_coff_symbols stdcall, sec:dword, symbols:dword,\
                      sym_count:dword, strings:dword, imports:dword
           locals
             retval dd ?
           endl
 
           mov edi, [symbols]
           mov [retval], 1
.fix:
           movzx ebx, [edi+CSYM.SectionNumber]
           test ebx, ebx
           jnz .internal
           mov eax, dword [edi+CSYM.Name]
           test eax, eax
           jnz @F
 
           mov edi, [edi+4]
           add edi, [strings]
@@:
           push edi
           stdcall get_proc_ex, edi,[imports]
           pop edi
 
           xor ebx, ebx
           test eax, eax
           jnz @F
 
           mov esi, msg_unresolved
           call sys_msg_board_str
           mov esi, edi
           call sys_msg_board_str
           mov esi, msg_CR
           call sys_msg_board_str
 
           mov [retval],0
@@:
           mov edi, [symbols]
           mov [edi+CSYM.Value], eax
           jmp .next
.internal:
           dec ebx
           shl ebx, 3
           lea ebx, [ebx+ebx*4]
           add ebx, [sec]
 
           mov eax, [ebx+CFS.VirtualAddress]
           add [edi+CSYM.Value], eax
.next:
           add edi, CSYM_SIZE
           mov [symbols], edi
           dec [sym_count]
           jnz .fix
           mov eax, [retval]
           ret
endp
 
align 4
proc fix_coff_relocs stdcall, coff:dword, sec:dword, sym:dword
	   locals
             n_sec     dd ?
	   endl
 
           mov eax, [coff]
           movzx ebx, [eax+CFH.nSections]
           mov [n_sec], ebx
.fix_sec:
           mov esi, [sec]
	   mov edi, [esi+CFS.PtrReloc]
           add edi, [coff]
 
           movzx ecx, [esi+CFS.NumReloc]
           test ecx, ecx
           jz .next
.next_reloc:
	   mov ebx, [edi+CRELOC.SymIndex]
	   add ebx,ebx
	   lea ebx,[ebx+ebx*8]
           add ebx, [sym]
 
           mov edx, [ebx+CSYM.Value]
 
           cmp [edi+CRELOC.Type], 6
           je .dir_32
 
           cmp [edi+CRELOC.Type], 20
           jne .next_reloc
.rel_32:
	   mov eax, [edi+CRELOC.VirtualAddress]
           add eax, [esi+CFS.VirtualAddress]
           sub edx, eax
           sub edx, 4
           jmp .fix
.dir_32:
	   mov eax, [edi+CRELOC.VirtualAddress]
           add eax, [esi+CFS.VirtualAddress]
.fix:
           add [eax], edx
           add edi, 10
           dec ecx
           jnz .next_reloc
.next:
           add [sec], COFF_SECTION_SIZE
           dec [n_sec]
           jnz .fix_sec
.exit:
	   ret
endp
 
align 4
proc load_driver stdcall, driver_name:dword
           locals
             coff      dd ?
             sym       dd ?
             strings   dd ?
             img_size  dd ?
             img_base  dd ?
             start     dd ?
 
             exports   dd ?   ;fake exports table
                       dd ?
             file_name rb 14+16+4+1      ; '/rd/1/drivers/.obj'
           endl
 
           lea     edx, [file_name]
           mov     dword [edx], '/rd/'
           mov     dword [edx+4], '1/dr'
           mov     dword [edx+8], 'iver'
           mov     word [edx+12], 's/'
           mov     esi, [driver_name]
           lea     edi, [edx+14]
           mov     ecx, 16
@@:
           lodsb
           test    al, al
           jz      @f
           stosb
           loop    @b
@@:
           mov     dword [edi], '.obj'
           mov     byte [edi+4], 0
           stdcall load_file, edx
 
           test eax, eax
           jz .exit
 
           mov [coff], eax
 
           movzx ecx, [eax+CFH.nSections]
           xor ebx, ebx
 
           lea edx, [eax+20]
@@:
           add ebx, [edx+CFS.SizeOfRawData]
           add ebx, 15
           and ebx, not 15
           add edx, COFF_SECTION_SIZE
           dec ecx
           jnz @B
           mov [img_size], ebx
 
           stdcall kernel_alloc, ebx
           test eax, eax
           jz .fail
           mov [img_base], eax
 
           mov edi, eax
           xor eax, eax
           mov ecx, [img_size]
           add ecx, 4095
           and ecx, not 4095
           shr ecx, 2
           cld
           rep stosd
 
           mov edx, [coff]
           movzx ebx, [edx+CFH.nSections]
           mov edi, [img_base]
           lea eax, [edx+20]
@@:
           mov [eax+CFS.VirtualAddress], edi
           mov esi, [eax+CFS.PtrRawData]
           test esi, esi
           jnz .copy
           add edi, [eax+CFS.SizeOfRawData]
           jmp .next
.copy:
           add esi, edx
           mov ecx, [eax+CFS.SizeOfRawData]
           cld
           rep movsb
.next:
           add edi, 15
           and edi, not 15
           add eax, COFF_SECTION_SIZE
           dec ebx
           jnz @B
 
           mov ebx, [edx+CFH.pSymTable]
           add ebx, edx
           mov [sym], ebx
           mov ecx, [edx+CFH.nSymbols]
           add ecx,ecx
           lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
           add ecx, [sym]
           mov [strings], ecx
 
           lea ebx, [exports]
           mov dword [ebx], kernel_export
           mov dword [ebx+4], 0
           lea eax, [edx+20]
 
           stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
                                     [strings], ebx
           test eax, eax
           jz .link_fail
 
           mov ebx, [coff]
           add ebx, 20
           stdcall fix_coff_relocs, [coff], ebx, [sym]
 
           mov ebx, [coff]
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szVersion
           test eax, eax
           jz .link_fail
 
           mov eax, [eax]
           shr eax, 16
           cmp eax, DRV_COMPAT
           jb .ver_fail
 
           cmp eax, DRV_CURRENT
           ja .ver_fail
 
           mov ebx, [coff]
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szSTART
           mov [start], eax
 
           stdcall kernel_free, [coff]
 
           mov ebx, [start]
           stdcall ebx, DRV_ENTRY
           test eax, eax
           jnz .ok
 
           stdcall kernel_free, [img_base]
           xor eax, eax
           ret
.ok:
           mov ebx, [img_base]
           mov [eax+SRV.base], ebx
           mov ecx, [start]
           mov [eax+SRV.entry], ecx
           ret
 
.ver_fail:
           mov esi, msg_CR
           call sys_msg_board_str
           mov esi, [driver_name]
           call sys_msg_board_str
           mov esi, msg_CR
           call sys_msg_board_str
           mov esi, msg_version
           call sys_msg_board_str
           mov esi, msg_www
           call sys_msg_board_str
           jmp .cleanup
 
.link_fail:
           mov esi, msg_module
           call sys_msg_board_str
           mov esi, [driver_name]
           call sys_msg_board_str
           mov esi, msg_CR
           call sys_msg_board_str
.cleanup:
           stdcall kernel_free,[img_base]
.fail:
           stdcall kernel_free, [coff]
.exit:
           xor eax, eax
           ret
endp
 
align 4
proc load_library stdcall, file_name:dword
           locals
             coff      dd ?
             sym       dd ?
             strings   dd ?
             img_size  dd ?
             img_base  dd ?
             exports   dd ?
           endl
 
           cli
 
           stdcall load_file, [file_name]
           test eax, eax
           jz .fail
 
           mov [coff], eax
           movzx ecx, [eax+CFH.nSections]
           xor ebx, ebx
 
           lea edx, [eax+20]
@@:
           add ebx, [edx+CFS.SizeOfRawData]
           add ebx, 15
           and ebx, not 15
           add edx, COFF_SECTION_SIZE
           dec ecx
           jnz @B
           mov [img_size], ebx
 
           call init_heap
           stdcall user_alloc, [img_size]
 
           test eax, eax
           jz .fail
           mov [img_base], eax
 
           mov edx, [coff]
           movzx ebx, [edx+CFH.nSections]
           mov edi, [img_base]
           lea eax, [edx+20]
@@:
           mov [eax+CFS.VirtualAddress], edi
           mov esi, [eax+CFS.PtrRawData]
           test esi, esi
           jnz .copy
           add edi, [eax+CFS.SizeOfRawData]
           jmp .next
.copy:
           add esi, edx
    ;       add edi, new_app_base
           mov ecx, [eax+CFS.SizeOfRawData]
           cld
           rep movsb
.next:
           add edi, 15 ;-new_app_base
           and edi, -16
           add eax, COFF_SECTION_SIZE
           dec ebx
           jnz @B
 
           mov ebx, [edx+CFH.pSymTable]
           add ebx, edx
           mov [sym], ebx
           mov ecx, [edx+CFH.nSymbols]
           add ecx,ecx
           lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
           add ecx, [sym]
           mov [strings], ecx
 
           lea eax, [edx+20]
 
           stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
                                     [strings], dword 0
           test eax, eax
           jnz @F
 
@@:
           mov edx, [coff]
           movzx ebx, [edx+CFH.nSections]
           mov edi, new_app_base
           lea eax, [edx+20]
@@:
           add [eax+CFS.VirtualAddress], edi  ;patch user space offset
           add eax, COFF_SECTION_SIZE
           dec ebx
           jnz @B
 
           add edx, 20
           stdcall fix_coff_relocs, [coff], edx, [sym]
 
           mov ebx, [coff]
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szEXPORTS
           mov [exports], eax
 
           stdcall kernel_free, [coff]
           mov eax, [exports]
           ret
.fail:
           xor eax, eax
           ret
endp
 
align 4
proc stop_all_services
 
           mov edx, [srv.fd]
.next:
           cmp edx,  srv.fd-SRV_FD_OFFSET
           je .done
           cmp [edx+SRV.magic], ' SRV'
           jne .next
           cmp [edx+SRV.size], SRV_SIZE
           jne .next
           mov ebx, [edx+SRV.entry]
           mov edx, [edx+SRV.fd]
           push edx
           stdcall ebx, dword -1
           pop edx
           jmp .next
.done:
           ret
endp
 
; param
;  eax= size
;  ebx= pid
 
align 4
create_kernel_object:
 
           push ebx
           call malloc
           pop ebx
           test eax, eax
           jz .fail
 
           mov ecx,[current_slot]
           add ecx, APP_OBJ_OFFSET
 
           pushfd
           cli
           mov edx, [ecx+APPOBJ.fd]
           mov [eax+APPOBJ.fd], edx
           mov [eax+APPOBJ.bk], ecx
           mov [eax+APPOBJ.pid], ebx
 
           mov [ecx+APPOBJ.fd], eax
           mov [edx+APPOBJ.bk], eax
           popfd
.fail:
           ret
 
; param
;  eax= object
 
align 4
destroy_kernel_object:
 
           pushfd
           cli
           mov ebx, [eax+APPOBJ.fd]
           mov ecx, [eax+APPOBJ.bk]
           mov [ebx+APPOBJ.bk], ecx
           mov [ecx+APPOBJ.fd], ebx
           popfd
 
           xor edx, edx        ;clear common header
           mov [eax], edx
           mov [eax+4], edx
           mov [eax+8], edx
           mov [eax+12], edx
           mov [eax+16], edx
 
           call free           ;release object memory
           ret
 
 
 
if 0
 
irq:
 
.irq0:
           pusfd
           pushad
           push IRQ_0
           jmp .master
.irq_1:
           pusfd
           pushad
           push IRQ_1
           jmp .master
 
.master:
           mov ax, app_data
           mov ds, eax
           mov es, eax
           mov ebx, [esp+4]  ;IRQ_xx
           mov eax, [irq_handlers+ebx+4]
           call intr_handler
           mov ecx, [esp+4]
           cmp [irq_actids+ecx*4], 0
           je @F
           in al, 0x21
           bts eax, ecx
           out 0x21, al
           mov al, 0x20
           out 0x20, al
           jmp .restart
 
.slave:
           mov ax, app_data
           mov ds, eax
           mov es, eax
           mov ebx, [esp+4]  ;IRQ_xx
           mov eax, [irq_handlers+ebx+4]
           call intr_handler
           mov ecx, [esp+4]
           sub ecx, 8
           cmp [irq_actids+ecx*4], 0
           je @F
           in al, 0xA1
           bts eax, ecx
           out 0xA1, al
           mov al, 0x20
           out 0xA0, al
           out 0x20, al
.restart:
           mov ebx, [next_slot]
           test ebx, ebx
           jz @F
           mov [next_task],0
           mov esi, [prev_slot]
           call do_change_task
           add esp, 4
           iretd
 
end if

Rev 465	Rev 479
1	$Revision: 465 $	1	$Revision: 479 $
2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3	;; ;;	3	;; ;;
4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
5	;; Distributed under terms of the GNU General Public License ;;	5	;; Distributed under terms of the GNU General Public License ;;
6	;; ;;	6	;; ;;
7	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	7	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
8		8
9	DRV_COMPAT equ 5 ;minimal required drivers version	9	DRV_COMPAT equ 5 ;minimal required drivers version
10	DRV_CURRENT equ 5 ;current drivers model version	10	DRV_CURRENT equ 5 ;current drivers model version
11		11
12	DRV_VERSION equ (DRV_COMPAT shl 16) or DRV_CURRENT	12	DRV_VERSION equ (DRV_COMPAT shl 16) or DRV_CURRENT
13		13
14	align 4	14	align 4
15	proc attach_int_handler stdcall, irq:dword, handler:dword	15	proc attach_int_handler stdcall, irq:dword, handler:dword
16		16
17	mov ebx, [irq] ;irq num	17	mov ebx, [irq] ;irq num
18	test ebx, ebx	18	test ebx, ebx
19	jz .err	19	jz .err
20	mov eax, [handler]	20	mov eax, [handler]
21	test eax, eax	21	test eax, eax
22	jz .err	22	jz .err
23	mov [irq_tab+ebx*4], eax	23	mov [irq_tab+ebx*4], eax
24	stdcall enable_irq, [irq]	24	stdcall enable_irq, [irq]
25	ret	25	ret
26	.err:	26	.err:
27	xor eax, eax	27	xor eax, eax
28	ret	28	ret
29	endp	29	endp
30		30
31	align 4	31	align 4
32	proc detach_int_handler	32	proc detach_int_handler
33		33
34	ret	34	ret
35	endp	35	endp
36		36
37	align 4	37	align 4
38	proc enable_irq stdcall, irq_line:dword	38	proc enable_irq stdcall, irq_line:dword
39	mov ebx, [irq_line]	39	mov ebx, [irq_line]
40	mov edx, 0x21	40	mov edx, 0x21
41	cmp ebx, 8	41	cmp ebx, 8
42	jb @F	42	jb @F
43	mov edx, 0xA1	43	mov edx, 0xA1
44	sub ebx,8	44	sub ebx,8
45	@@:	45	@@:
46	in al,dx	46	in al,dx
47	btr eax, ebx	47	btr eax, ebx
48	out dx, al	48	out dx, al
49	ret	49	ret
50	endp	50	endp
51		51
52	align 16	52	align 16
53	;; proc irq_serv	53	;; proc irq_serv
54		54
55	irq_serv:	55	irq_serv:
56		56
57	.irq_1:	57	.irq_1:
58	push eax	58	push eax
59	mov eax, 1	59	mov eax, 1
60	jmp .main	60	jmp .main
61	align 4	61	align 4
62	.irq_2:	62	.irq_2:
63	push eax	63	push eax
64	mov eax, 2	64	mov eax, 2
65	jmp .main	65	jmp .main
66	align 4	66	align 4
67	.irq_3:	67	.irq_3:
68	push eax	68	push eax
69	mov eax, 3	69	mov eax, 3
70	jmp .main	70	jmp .main
71	align 4	71	align 4
72	.irq_4:	72	.irq_4:
73	push eax	73	push eax
74	mov eax, 4	74	mov eax, 4
75	jmp .main	75	jmp .main
76	align 4	76	align 4
77	.irq_5:	77	.irq_5:
78	push eax	78	push eax
79	mov eax, 5	79	mov eax, 5
80	jmp .main	80	jmp .main
81	align 4	81	align 4
82	.irq_6:	82	.irq_6:
83	push eax	83	push eax
84	mov eax, 6	84	mov eax, 6
85	jmp .main	85	jmp .main
86	align 4	86	align 4
87	.irq_7:	87	.irq_7:
88	push eax	88	push eax
89	mov eax, 7	89	mov eax, 7
90	jmp .main	90	jmp .main
91	align 4	91	align 4
92	.irq_8:	92	.irq_8:
93	push eax	93	push eax
94	mov eax, 8	94	mov eax, 8
95	jmp .main	95	jmp .main
96	align 4	96	align 4
97	.irq_9:	97	.irq_9:
98	push eax	98	push eax
99	mov eax, 9	99	mov eax, 9
100	jmp .main	100	jmp .main
101	align 4	101	align 4
102	.irq_10:	102	.irq_10:
103	push eax	103	push eax
104	mov eax, 10	104	mov eax, 10
105	jmp .main	105	jmp .main
106	align 4	106	align 4
107	.irq_11:	107	.irq_11:
108	push eax	108	push eax
109	mov eax, 11	109	mov eax, 11
110	jmp .main	110	jmp .main
111	align 4	111	align 4
112	.irq_12:	112	.irq_12:
113	push eax	113	push eax
114	mov eax, 12	114	mov eax, 12
115	jmp .main	115	jmp .main
116	align 4	116	align 4
117	.irq_13:	117	.irq_13:
118	push eax	118	push eax
119	mov eax, 13	119	mov eax, 13
120	jmp .main	120	jmp .main
121	align 4	121	align 4
122	.irq_14:	122	.irq_14:
123	push eax	123	push eax
124	mov eax, 14	124	mov eax, 14
125	jmp .main	125	jmp .main
126	align 4	126	align 4
127	.irq_15:	127	.irq_15:
128	push eax	128	push eax
129	mov eax, 15	129	mov eax, 15
130	jmp .main	130	jmp .main
131		131
132	align 16	132	align 16
133	.main:	133	.main:
134	save_ring3_context	134	save_ring3_context
135	mov bx, app_data ;os_data	135	mov bx, app_data ;os_data
136	mov ds, bx	136	mov ds, bx
137	mov es, bx	137	mov es, bx
138		138
139	mov ebx, [irq_tab+eax*4]	139	mov ebx, [irq_tab+eax*4]
140	test ebx, ebx	140	test ebx, ebx
141	jz .exit	141	jz .exit
142		142
143	call ebx	143	call ebx
-		144	mov [check_idle_semaphore],5
144		145
145	.exit:	146	.exit:
146	restore_ring3_context	147	restore_ring3_context
147		148
148	cmp eax, 8	149	cmp eax, 8
149	mov al, 0x20	150	mov al, 0x20
150	jb @f	151	jb @f
151	out 0xa0, al	152	out 0xa0, al
152	@@:	153	@@:
153	out 0x20, al	154	out 0x20, al
154		155
155	pop eax	156	pop eax
156	iret	157	iret
157		158
158	align 4	159	align 4
159	proc get_notify stdcall, p_ev:dword	160	proc get_notify stdcall, p_ev:dword
160		161
161	.wait:	162	.wait:
162	mov ebx,[current_slot]	163	mov ebx,[current_slot]
163	test dword [ebx+APPDATA.event_mask],EVENT_NOTIFY	164	test dword [ebx+APPDATA.event_mask],EVENT_NOTIFY
164	jz @f	165	jz @f
165	and dword [ebx+APPDATA.event_mask], not EVENT_NOTIFY	166	and dword [ebx+APPDATA.event_mask], not EVENT_NOTIFY
166	mov edi, [p_ev]	167	mov edi, [p_ev]
167	mov dword [edi], EV_INTR	168	mov dword [edi], EV_INTR
168	mov eax, [ebx+APPDATA.event]	169	mov eax, [ebx+APPDATA.event]
169	mov dword [edi+4], eax	170	mov dword [edi+4], eax
170	ret	171	ret
171	@@:	172	@@:
172	call change_task	173	call change_task
173	jmp .wait	174	jmp .wait
174	endp	175	endp
175		176
176	align 4	177	align 4
177	proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword	178	proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
178	xor eax, eax	179	xor eax, eax
179	xor ebx, ebx	180	xor ebx, ebx
180	mov ah, byte [bus]	181	mov ah, byte [bus]
181	mov al, 6	182	mov al, 6
182	mov bh, byte [devfn]	183	mov bh, byte [devfn]
183	mov bl, byte [reg]	184	mov bl, byte [reg]
184	call pci_read_reg	185	call pci_read_reg
185	ret	186	ret
186	endp	187	endp
187		188
188	align 4	189	align 4
189	proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword	190	proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
190	xor eax, eax	191	xor eax, eax
191	xor ebx, ebx	192	xor ebx, ebx
192	mov ah, byte [bus]	193	mov ah, byte [bus]
193	mov al, 4	194	mov al, 4
194	mov bh, byte [devfn]	195	mov bh, byte [devfn]
195	mov bl, byte [reg]	196	mov bl, byte [reg]
196	call pci_read_reg	197	call pci_read_reg
197	ret	198	ret
198	endp	199	endp
199		200
200	align 4	201	align 4
201	proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword	202	proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
202	xor eax, eax	203	xor eax, eax
203	xor ebx, ebx	204	xor ebx, ebx
204	mov ah, byte [bus]	205	mov ah, byte [bus]
205	mov al, 8	206	mov al, 8
206	mov bh, byte [devfn]	207	mov bh, byte [devfn]
207	mov bl, byte [reg]	208	mov bl, byte [reg]
208	mov ecx, [val]	209	mov ecx, [val]
209	call pci_write_reg	210	call pci_write_reg
210	ret	211	ret
211	endp	212	endp
212		213
213	handle equ IOCTL.handle	214	handle equ IOCTL.handle
214	io_code equ IOCTL.io_code	215	io_code equ IOCTL.io_code
215	input equ IOCTL.input	216	input equ IOCTL.input
216	inp_size equ IOCTL.inp_size	217	inp_size equ IOCTL.inp_size
217	output equ IOCTL.output	218	output equ IOCTL.output
218	out_size equ IOCTL.out_size	219	out_size equ IOCTL.out_size
219		220
220		221
221	align 4	222	align 4
222	proc srv_handler stdcall, ioctl:dword	223	proc srv_handler stdcall, ioctl:dword
223	mov esi, [ioctl]	224	mov esi, [ioctl]
224	test esi, esi	225	test esi, esi
225	jz .err	226	jz .err
226		227
227	mov edi, [esi+handle]	228	mov edi, [esi+handle]
228	cmp [edi+SRV.magic], ' SRV'	229	cmp [edi+SRV.magic], ' SRV'
229	jne .fail	230	jne .fail
230		231
231	cmp [edi+SRV.size], SRV_SIZE	232	cmp [edi+SRV.size], SRV_SIZE
232	jne .fail	233	jne .fail
233		234
234	stdcall [edi+SRV.srv_proc], esi	235	stdcall [edi+SRV.srv_proc], esi
235	ret	236	ret
236	.fail:	237	.fail:
237	xor eax, eax	238	xor eax, eax
238	not eax	239	not eax
239	mov [esi+output], eax	240	mov [esi+output], eax
240	mov [esi+out_size], 4	241	mov [esi+out_size], 4
241	ret	242	ret
242	.err:	243	.err:
243	xor eax, eax	244	xor eax, eax
244	not eax	245	not eax
245	ret	246	ret
246	endp	247	endp
247		248
248	; param	249	; param
249	; ebx= io_control	250	; ebx= io_control
250	;	251	;
251	; retval	252	; retval
252	; eax= error code	253	; eax= error code
253		254
254	align 4	255	align 4
255	srv_handlerEx:	256	srv_handlerEx:
256	cmp ebx, OS_BASE	257	cmp ebx, OS_BASE
257	jae .fail	258	jae .fail
258		259
259	mov eax, [ebx+handle]	260	mov eax, [ebx+handle]
260	cmp [eax+SRV.magic], ' SRV'	261	cmp [eax+SRV.magic], ' SRV'
261	jne .fail	262	jne .fail
262		263
263	cmp [eax+SRV.size], SRV_SIZE	264	cmp [eax+SRV.size], SRV_SIZE
264	jne .fail	265	jne .fail
265		266
266	stdcall [eax+SRV.srv_proc], ebx	267	stdcall [eax+SRV.srv_proc], ebx
267	ret	268	ret
268	.fail:	269	.fail:
269	or eax, -1	270	or eax, -1
270	ret	271	ret
271		272
272	restore handle	273	restore handle
273	restore io_code	274	restore io_code
274	restore input	275	restore input
275	restore inp_size	276	restore inp_size
276	restore output	277	restore output
277	restore out_size	278	restore out_size
278		279
279	align 4	280	align 4
280	proc get_service stdcall, sz_name:dword	281	proc get_service stdcall, sz_name:dword
281	mov eax, [sz_name]	282	mov eax, [sz_name]
282	test eax, eax	283	test eax, eax
283	jnz @F	284	jnz @F
284	ret	285	ret
285	@@:	286	@@:
286	mov edx, [srv.fd]	287	mov edx, [srv.fd]
287	@@:	288	@@:
288	cmp edx, srv.fd-SRV_FD_OFFSET	289	cmp edx, srv.fd-SRV_FD_OFFSET
289	je .not_load	290	je .not_load
290		291
291	stdcall strncmp, edx, [sz_name], 16	292	stdcall strncmp, edx, [sz_name], 16
292	test eax, eax	293	test eax, eax
293	je .ok	294	je .ok
294		295
295	mov edx, [edx+SRV.fd]	296	mov edx, [edx+SRV.fd]
296	jmp @B	297	jmp @B
297	.not_load:	298	.not_load:
298	pop ebp	299	pop ebp
299	jmp load_driver	300	jmp load_driver
300	.ok:	301	.ok:
301	mov eax, edx	302	mov eax, edx
302	ret	303	ret
303	endp	304	endp
304		305
305	align 4	306	align 4
306	reg_service:	307	reg_service:
307	.sz_name equ esp+4	308	.sz_name equ esp+4
308	.handler equ esp+8	309	.handler equ esp+8
309	mov eax, [.sz_name]	310	mov eax, [.sz_name]
310	test eax, eax	311	test eax, eax
311	jz .fail	312	jz .fail
312		313
313	mov ebx, [.handler]	314	mov ebx, [.handler]
314	test ebx, ebx	315	test ebx, ebx
315	jz .fail	316	jz .fail
316		317
317	mov eax, SRV_SIZE	318	mov eax, SRV_SIZE
318	call malloc ;call alloc_service	319	call malloc ;call alloc_service
319	test eax, eax	320	test eax, eax
320	jz .fail	321	jz .fail
321		322
322	mov edi, eax	323	mov edi, eax
323	mov esi, [.sz_name]	324	mov esi, [.sz_name]
324	mov ecx, 16/4	325	mov ecx, 16/4
325	rep movsd	326	rep movsd
326		327
327	mov [eax+SRV.magic], ' SRV'	328	mov [eax+SRV.magic], ' SRV'
328	mov [eax+SRV.size], SRV_SIZE	329	mov [eax+SRV.size], SRV_SIZE
329		330
330	mov ebx, srv.fd-SRV_FD_OFFSET	331	mov ebx, srv.fd-SRV_FD_OFFSET
331	mov edx, [ebx+SRV.fd]	332	mov edx, [ebx+SRV.fd]
332	mov [eax+SRV.fd], edx	333	mov [eax+SRV.fd], edx
333	mov [eax+SRV.bk], ebx	334	mov [eax+SRV.bk], ebx
334	mov [ebx+SRV.fd], eax	335	mov [ebx+SRV.fd], eax
335	mov [edx+SRV.bk], eax	336	mov [edx+SRV.bk], eax
336		337
337	mov ecx, [.handler]	338	mov ecx, [.handler]
338	mov [eax+SRV.srv_proc], ecx	339	mov [eax+SRV.srv_proc], ecx
339	ret 8	340	ret 8
340	.fail:	341	.fail:
341	xor eax, eax	342	xor eax, eax
342	ret 8	343	ret 8
343		344
344	align 4	345	align 4
345	proc get_proc stdcall, exp:dword, sz_name:dword	346	proc get_proc stdcall, exp:dword, sz_name:dword
346		347
347	mov edx, [exp]	348	mov edx, [exp]
348	.next:	349	.next:
349	mov eax, [edx]	350	mov eax, [edx]
350	test eax, eax	351	test eax, eax
351	jz .end	352	jz .end
352		353
353	push edx	354	push edx
354	stdcall strncmp, eax, [sz_name], 16	355	stdcall strncmp, eax, [sz_name], 16
355	pop edx	356	pop edx
356	test eax, eax	357	test eax, eax
357	jz .ok	358	jz .ok
358		359
359	add edx,8	360	add edx,8
360	jmp .next	361	jmp .next
361	.ok:	362	.ok:
362	mov eax, [edx+4]	363	mov eax, [edx+4]
363	.end:	364	.end:
364	ret	365	ret
365	endp	366	endp
366		367
367	align 4	368	align 4
368	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword	369	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
369		370
370	@@:	371	@@:
371	stdcall strncmp, [pSym], [sz_sym], 8	372	stdcall strncmp, [pSym], [sz_sym], 8
372	test eax,eax	373	test eax,eax
373	jz .ok	374	jz .ok
374	add [pSym], 18	375	add [pSym], 18
375	dec [count]	376	dec [count]
376	jnz @b	377	jnz @b
377	xor eax, eax	378	xor eax, eax
378	ret	379	ret
379	.ok:	380	.ok:
380	mov ebx, [pSym]	381	mov ebx, [pSym]
381	mov eax, [ebx+8]	382	mov eax, [ebx+8]
382	ret	383	ret
383	endp	384	endp
384		385
385	align 4	386	align 4
386	proc get_curr_task	387	proc get_curr_task
387	mov eax,[CURRENT_TASK]	388	mov eax,[CURRENT_TASK]
388	shl eax, 8	389	shl eax, 8
389	ret	390	ret
390	endp	391	endp
391		392
392	align 4	393	align 4
393	proc get_fileinfo stdcall, file_name:dword, info:dword	394	proc get_fileinfo stdcall, file_name:dword, info:dword
394	locals	395	locals
395	cmd dd ?	396	cmd dd ?
396	offset dd ?	397	offset dd ?
397	dd ?	398	dd ?
398	count dd ?	399	count dd ?
399	buff dd ?	400	buff dd ?
400	db ?	401	db ?
401	name dd ?	402	name dd ?
402	endl	403	endl
403		404
404	xor eax, eax	405	xor eax, eax
405	mov ebx, [file_name]	406	mov ebx, [file_name]
406	; sub ebx, new_app_base	407	; sub ebx, new_app_base
407	mov ecx, [info]	408	mov ecx, [info]
408	; sub ecx, new_app_base	409	; sub ecx, new_app_base
409		410
410	mov [cmd], 5	411	mov [cmd], 5
411	mov [offset], eax	412	mov [offset], eax
412	mov [offset+4], eax	413	mov [offset+4], eax
413	mov [count], eax	414	mov [count], eax
414	mov [buff], ecx	415	mov [buff], ecx
415	mov byte [buff+4], al	416	mov byte [buff+4], al
416	mov [name], ebx	417	mov [name], ebx
417		418
418	mov eax, 70	419	mov eax, 70
419	lea ebx, [cmd]	420	lea ebx, [cmd]
420	; sub ebx, new_app_base	421	; sub ebx, new_app_base
421	int 0x40	422	int 0x40
422	ret	423	ret
423	endp	424	endp
424		425
425	align 4	426	align 4
426	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\	427	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
427	bytes:dword	428	bytes:dword
428	locals	429	locals
429	cmd dd ?	430	cmd dd ?
430	offset dd ?	431	offset dd ?
431	dd ?	432	dd ?
432	count dd ?	433	count dd ?
433	buff dd ?	434	buff dd ?
434	db ?	435	db ?
435	name dd ?	436	name dd ?
436	endl	437	endl
437		438
438	xor eax, eax	439	xor eax, eax
439	mov ebx, [file_name]	440	mov ebx, [file_name]
440	mov ecx, [off]	441	mov ecx, [off]
441	mov edx, [bytes]	442	mov edx, [bytes]
442	mov esi, [buffer]	443	mov esi, [buffer]
443		444
444	mov [cmd], eax	445	mov [cmd], eax
445	mov [offset], ecx	446	mov [offset], ecx
446	mov [offset+4], eax	447	mov [offset+4], eax
447	mov [count], edx	448	mov [count], edx
448	mov [buff], esi	449	mov [buff], esi
449	mov byte [buff+4], al	450	mov byte [buff+4], al
450	mov [name], ebx	451	mov [name], ebx
451		452
452	pushad	453	pushad
453	push eax	454	push eax
454	lea eax, [cmd]	455	lea eax, [cmd]
455	call file_system_lfn	456	call file_system_lfn
456	pop eax	457	pop eax
457	popad	458	popad
458	ret	459	ret
459	endp	460	endp
460		461
461	; description	462	; description
462	; allocate kernel memory and loads the specified file	463	; allocate kernel memory and loads the specified file
463	;	464	;
464	; param	465	; param
465	; file_name= full path to file	466	; file_name= full path to file
466	;	467	;
467	; retval	468	; retval
468	; eax= file image in kernel memory	469	; eax= file image in kernel memory
469	; ebx= size of file	470	; ebx= size of file
470	;	471	;
471	; warging	472	; warging
472	; You mast call kernel_free() to delete each file	473	; You mast call kernel_free() to delete each file
473	; loaded by the load_file() function	474	; loaded by the load_file() function
474		475
475	align 4	476	align 4
476	proc load_file stdcall, file_name:dword	477	proc load_file stdcall, file_name:dword
477	locals	478	locals
478	attr dd ?	479	attr dd ?
479	flags dd ?	480	flags dd ?
480	cr_time dd ?	481	cr_time dd ?
481	cr_date dd ?	482	cr_date dd ?
482	acc_time dd ?	483	acc_time dd ?
483	acc_date dd ?	484	acc_date dd ?
484	mod_time dd ?	485	mod_time dd ?
485	mod_date dd ?	486	mod_date dd ?
486	file_size dd ?	487	file_size dd ?
487		488
488	file dd ?	489	file dd ?
489	file2 dd ?	490	file2 dd ?
490	endl	491	endl
491		492
492	lea eax, [attr]	493	lea eax, [attr]
493	stdcall get_fileinfo, [file_name], eax	494	stdcall get_fileinfo, [file_name], eax
494	test eax, eax	495	test eax, eax
495	jnz .fail	496	jnz .fail
496		497
497	mov eax, [file_size]	498	mov eax, [file_size]
498	cmp eax, 1024102416	499	cmp eax, 1024102416
499	ja .fail	500	ja .fail

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc @ 465 – Rev 465 → 479