Subversion Repositories Kolibri OS

DRV_EXIT     equ -1

DRV_COMPAT   equ  4  ;minimal required drivers version

DRV_CURRENT  equ  4  ;current drivers model version

proc attach_int_handler stdcall, irq:dword, handler:dword

	 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

proc  detach_int_handler

endp

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

;; proc irq_serv

	   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

.main:

	   save_ring3_context

	   mov	 bx, os_data

	   mov	 ds, bx

	   mov	 es, bx

	   test ebx, ebx

	   jz .exit

	   restore_ring3_context

	   mov al, 0x20

           jb @f

	   out 0xa0, al

@@:

           out 0x20, al

	   iret

proc get_notify stdcall, p_ev:dword

           mov ebx,[CURRENT_TASK]

           shl ebx,8

           test dword [ebx+SLOT_BASE+0xA8],EVENT_NOTIFY

	   jz @f

           and dword [ebx+SLOT_BASE+0xA8], not EVENT_NOTIFY

	   mov edi, [p_ev]

	   mov dword [edi], EV_INTR

           mov eax, [ebx+SLOT_BASE+APPDATA.event]

	   mov dword [edi+4], eax

	   ret

@@:

	   call change_task

	   jmp .wait

endp

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

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

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

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

proc srv_handler stdcall, ioctl:dword

           mov esi, [ioctl]

           test esi, esi

           jz .err

           cmp [edi+SRV.magic], ' SRV'

	   jne .fail

	   jne .fail

           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

;  ebx= io_control

;

; retval

;  eax= error code

srv_handlerEx:

           test ebx, ebx

           jz .fail

           add ebx, new_app_base

           cmp [eax+SRV.magic], ' SRV'

	   jne .fail

	   jne .fail

           add [ebx+output], new_app_base

           ret

.fail:

           or eax, -1

           ret

restore  io_code

restore  input

restore  inp_size

restore  output

restore  out_size

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

           test eax, eax

           je .ok

           jmp @B

.not_load:

           pop ebp

           jmp load_driver

.ok:

           mov eax, edx

           ret

endp

reg_service:

.sz_name equ esp+4

.handler equ esp+8

           mov eax, [.sz_name]

	   test eax, eax

	   jz .fail

	   test ebx, ebx

	   jz .fail

           call malloc           ;call alloc_service

	   test eax, eax

	   jz .fail

           mov esi, [.sz_name]

           mov ecx, 16/4

           rep movsd

           mov [eax+SRV.size], SRV_SIZE

           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 [eax+SRV.srv_proc], ecx

           ret 8

.fail:

	   xor eax, eax

           ret 8

proc get_proc stdcall, exp:dword, sz_name:dword

.next:

           mov eax, [edx]

           test eax, eax

           jz .end

           stdcall strncmp, eax, [sz_name], 16

           pop edx

           test eax, eax

           jz .ok

           jmp .next

.ok:

           mov eax, [edx+4]

.end:

           ret

endp

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

proc get_curr_task

           mov eax,[CURRENT_TASK]

           shl eax, 8

           ret

endp

proc get_fileinfo stdcall, file_name:dword, info:dword

           locals

             cmd     dd ?

             offset  dd ?

                     dd ?

             count   dd ?

             buff    dd ?

                     db ?

             name    dd ?

           endl

           mov ebx, [file_name]

           sub ebx, new_app_base

           mov ecx, [info]

           sub ecx, new_app_base

           mov [offset], eax

           mov [offset+4], eax

           mov [count], eax

           mov [buff], ecx

           mov byte [buff+4], al

           mov [name], ebx

           lea ebx, [cmd]

           sub ebx, new_app_base

           int 0x40

           ret

endp

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

           mov ebx, [file_name]

           mov ecx, [off]

           mov edx, [bytes]

           mov esi, [buffer]

           sub ebx, new_app_base

           sub esi, new_app_base

           mov [offset], ecx

           mov [offset+4], eax

           mov [count], edx

           mov [buff], esi

           mov byte [buff+4], al

           mov [name], ebx

           lea ebx, [cmd]

           sub ebx, new_app_base

           int 0x40

           ret

endp

;  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

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 ?

             file2      dd ?

           endl

           stdcall get_fileinfo, [file_name], eax

           test eax, eax

           jnz .fail

           cmp eax, 1024*1024*16

           ja .fail

           mov [file], eax

           cmp ebx, [file_size]

           jne .cleanup

           cmp dword [eax], 0x4B43504B

           jne .exit

           mov ebx, [eax+4]

           mov [file_size], ebx

           stdcall kernel_alloc, ebx

           jz .cleanup

           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

proc get_proc_ex stdcall, proc_name:dword, imports:dword

           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

           stdcall strncmp, eax, [proc_name], 16

           pop edx

           test eax, eax

           jz .ok

           jmp .next

.next_table:

           add [imports], 4

           jmp .look_up

.ok:

           mov eax, [edx+4]

           ret

.end:

           xor eax, eax

           ret

endp

proc fix_coff_symbols stdcall, sec:dword, symbols:dword,\

                      sym_count:dword, strings:dword, imports:dword

           locals

             retval dd ?

           endl

           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

           add edi, [strings]

@@:

           push edi

           stdcall get_proc_ex, edi,[imports]

           pop edi

           test eax, eax

           jnz @F

           call sys_msg_board_str

           mov esi, edi

           call sys_msg_board_str

           mov esi, msg_CR

           call sys_msg_board_str

@@:

           mov edi, [symbols]

           mov [edi+CSYM.Value], eax

           jmp .next

.internal:

           dec ebx

           shl ebx, 3

           lea ebx, [ebx+ebx*4]

           add ebx, [sec]

           add [edi+CSYM.Value], eax

.next:

           add edi, CSYM_SIZE

           mov [symbols], edi

           dec [sym_count]

           jnz .fix

           mov eax, [retval]

           ret

endp

proc fix_coff_relocs stdcall, coff:dword, sec:dword, sym:dword

	   locals

             n_sec     dd ?

	   endl

           movzx ebx, [eax+CFH.nSections]

           mov [n_sec], ebx

.fix_sec:

           mov esi, [sec]

	   mov edi, [esi+CFS.PtrReloc]

           add edi, [coff]

           test ecx, ecx

           jz .next

.next_reloc:

	   mov ebx, [edi+CRELOC.SymIndex]

	   add ebx,ebx

	   lea ebx,[ebx+ebx*8]

           add ebx, [sym]

           je .dir_32

           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

proc load_driver stdcall, driver_name:dword

           locals

             coff      dd ?

             sym       dd ?

             strings   dd ?

             img_size  dd ?

             img_base  dd ?

             start     dd ?

                       dd ?

             file_name rb 14+16+4+1      ; '/rd/1/drivers/.obj'

           endl

        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

           jz .exit

           xor ebx, ebx

@@:

           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

           test eax, eax

           jz .fail

           mov [img_base], eax

           xor eax, eax

           mov ecx, [img_size]

           add ecx, 4095

           and ecx, not 4095

           shr ecx, 2

           cld

           rep stosd

           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

           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

           mov dword [ebx], kernel_export

           mov dword [ebx+4], 0

           lea eax, [edx+20]

                                     [strings], ebx

           test eax, eax

           jz .link_fail

           add ebx, 20

           stdcall fix_coff_relocs, [coff], ebx, [sym]

           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szVersion

           test eax, eax

           jz .link_fail

           shr eax, 16

           cmp eax, DRV_COMPAT

           jb .ver_fail

           ja .ver_fail

           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szSTART

           mov [start], eax

           stdcall ebx, DRV_ENTRY

           test eax, eax

           jnz .ok

           xor eax, eax

           ret

.ok:

           mov ebx, [img_base]

           mov [eax+SRV.base], ebx

           mov ecx, [start]

           mov [eax+SRV.entry], ecx

           ret

           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

           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

proc load_library stdcall, file_name:dword

           locals

             coff      dd ?

             sym       dd ?

             strings   dd ?

             img_size  dd ?

             img_base  dd ?

             exports   dd ?

           endl

           test eax, eax

           jz .fail

           movzx ecx, [eax+CFH.nSections]

           xor ebx, ebx

@@:

           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 user_alloc, [img_size]

           jz .fail

           mov [img_base], eax

           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, not 15

           add eax, COFF_SECTION_SIZE

           dec ebx

           jnz @B

           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

                                     [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

           stdcall fix_coff_relocs, [coff], edx, [sym]

           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szEXPORTS

           mov [exports], eax

           mov eax, [exports]

           ret

.fail:

           xor eax, eax

           ret

endp

proc stop_all_services

.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

;  eax= size

;  ebx= pid

create_kernel_object:

           call malloc

           pop ebx

           test eax, eax

           jz .fail

           shl ecx,8

           add ecx, SLOT_BASE+APP_OBJ_OFFSET

           cli

           mov edx, [ecx+APPOBJ.fd]

           mov [eax+APPOBJ.fd], edx

           mov [eax+APPOBJ.bk], ecx

           mov [eax+APPOBJ.pid], ebx

           mov [edx+APPOBJ.bk], eax

           popfd

.fail:

           ret

;  eax= object

destroy_kernel_object:

           cli

           mov ebx, [eax+APPOBJ.fd]

           mov ecx, [eax+APPOBJ.bk]

           mov [ebx+APPOBJ.bk], ecx

           mov [ecx+APPOBJ.fd], ebx

           popfd

           mov [eax], edx

           mov [eax+4], edx

           mov [eax+8], edx

           mov [eax+12], edx

           mov [eax+16], edx

           ret

;szInfinity     db 'INFINITY',0

szHwMouse      db 'ATI2D',0

szEXPORTS      db 'EXPORTS',0

szIMPORTS      db 'IMPORTS',0

msg_module     db 'in module ',0

msg_version    db 'incompatible driver version',13,10,0

msg_www        db 'please visit www.kolibrios.org',13,10,0

msg_CR         db  13,10,0

create_cursor    dd 0

set_hw_cursor    dd 0

hw_restore       dd 0