WebSVN – Kolibri OS – Diff – /kernel/trunk/drivers/ati2d.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
format MS COFF
 
include 'proc32.inc'
include 'imports.inc'
 
DEBUG     equ 1
 
VID_ATI     equ 0x1002
 
LOAD_FROM_FILE  equ 0
LOAD_FROM_MEM   equ 1
LOAD_INDIRECT   equ 2
LOAD_SYSTEM     equ 3
 
VIDEO_FREE      equ 2
 
struc BITMAPINFOHEADER {
  .biSize          dd ? ; DWORD
  .biWidth         dd ? ; LONG
  .biHeight        dd ? ; LONG
  .biPlanes        dw ? ; WORD
  .biBitCount      dw ? ; WORD
  .biCompression   dd ? ; DWORD
  .biSizeImage     dd ? ; DWORD
  .biXPelsPerMeter dd ? ; LONG
  .biYPelsPerMeter dd ? ; LONG
  .biClrUsed       dd ? ; DWORD
  .biClrImportant  dd ? ; DWORD
}
 
virtual at 0
  BI BITMAPINFOHEADER
end virtual
 
struc CURSOR
{;common object header
   .magic       dd ?   ;'CURS'
   .destroy     dd ?   ;internal destructor
   .fd          dd ?   ;next object in list
   .bk          dd ?   ;prev object in list
   .pid         dd ?   ;owner id
 
 ;cursor data
   .base        dd ?   ;allocated memory
   .hot_x       dd ?   ;hotspot coords
   .hot_y       dd ?
}
virtual at 0
  CURSOR CURSOR
end virtual
 
CURSOR_SIZE     equ 32
 
R8500       equ 0x514C  ;R200
R9000       equ 0x4966  ;RV250
R9200       equ 0x5961  ;RV280
R9500       equ 0x4144  ;R300
R9500P      equ 0x4E45  ;R300
R9550       equ 0x4153  ;RV350
R9600       equ 0x4150  ;RV350
R9600XT     equ 0x4152  ;RV360
R9700P      equ 0x4E44  ;R300
R9800       equ 0x4E49  ;R350
R9800P      equ 0x4E48  ;R350
R9800XT     equ 0x4E4A  ;R360
 
OS_BASE         equ 0
new_app_base    equ 0x80000000
SLOT_BASE       equ 0x0080000
 
PG_SW        equ 0x003
PG_NOCACHE   equ 0x018
 
struc IOCTL
{  .handle           dd ?
   .io_code          dd ?
   .input            dd ?
   .inp_size         dd ?
   .output           dd ?
   .out_size         dd ?
}
 
virtual at 0
  IOCTL IOCTL
end virtual
 
;MMIO                   equ 0F9000000h
RD_RB3D_CNTL            equ 1c3ch
 
RD_MEM_CNTL                equ 0140h
RD_CRTC_GEN_CNTL           equ 0050h
RD_CRTC_CUR_EN             equ 10000h
RD_DISPLAY_BASE_ADDR       equ 023ch
RD_DEFAULT_OFFSET          equ 16e0h
CUR_HORZ_VERT_OFF          equ 0268h
CUR_HORZ_VERT_POSN         equ 0264h
CUR_OFFSET                 equ 0260h
RD_RB3D_CNTL               equ 1c3ch
RD_RBBM_STATUS             equ 0e40h
RD_RBBM_FIFOCNT_MASK       equ 007fh
RD_RBBM_ACTIVE             equ 80000000h
RD_TIMEOUT                 equ 2000000
 
RD_DP_GUI_MASTER_CNTL      equ 0146ch
RD_DP_BRUSH_BKGD_CLR       equ 01478h
RD_DP_BRUSH_FRGD_CLR       equ 0147ch
RD_DP_SRC_BKGD_CLR         equ 015dch
RD_DP_SRC_FRGD_CLR         equ 015d8h
RD_DP_CNTL                 equ 016c0h
RD_DP_DATATYPE             equ 016c4h
RD_DP_WRITE_MASK           equ 016cch
RD_DP_SRC_SOURCE_MEMORY    equ (2 shl 24)
RD_DP_SRC_SOURCE_HOST_DATA equ (3 shl 24)
RD_DEFAULT_SC_BOTTOM_RIGHT equ 16e8h
RD_GMC_BRUSH_SOLID_COLOR   equ (13 shl 4)
RD_DEFAULT_SC_RIGHT_MAX    equ 1fffh
RD_DEFAULT_SC_BOTTOM_MAX   equ 1fff0000h
RD_GMC_DST_DATATYPE_SHIFT  equ 8
 
RD_ROP3_S                  equ 00cc0000h
RD_ROP3_P                  equ 00f00000h
 
RD_RB2D_DSTCACHE_MODE      equ 03428h
RD_RB2D_DSTCACHE_CTLSTAT   equ 0342ch
RD_RB2D_DC_FLUSH_ALL       equ 000fh
RD_RB2D_DC_BUSY            equ 80000000h
 
RD_GMC_BRUSH_SOLID_COLOR   equ 000000D0h
RD_GMC_SRC_DATATYPE_COLOR  equ (3 shl 12)
RD_GMC_CLR_CMP_CNTL_DIS    equ (1 shl 28)
RD_GMC_WR_MSK_DIS          equ (1 shl 30)
 
cmdSolidFill               equ 73f036d0h
 
RD_DST_PITCH_OFFSET        equ 142ch
RD_SRC_PITCH_OFFSET        equ 1428h
 
RD_DST_X_LEFT_TO_RIGHT     equ 1
RD_DST_Y_TOP_TO_BOTTOM     equ 2
RD_DST_Y_X                 equ 1438h
RD_DST_WIDTH_HEIGHT        equ 1598h
RD_DST_LINE_START          equ 1600h
RD_DST_LINE_END            equ 1604h
R300_MEM_NUM_CHANNELS_MASK equ 0003h
 
macro rdr op1, op2
{
     mov edi, [ati_io]
     mov op1, [edi+op2]
}
 
macro wrr dest, src
{
     mov edi, [ati_io]
     mov dword [edi+dest], src
}
 
 
public START
public service_proc
public version
 
CURSOR_IMAGE_OFFSET  equ 0x00500000
 
DRV_ENTRY equ 1
DRV_EXIT  equ -1
 
section '.flat' code readable align 16
 
proc START stdcall, state:dword
 
           cmp [state], 1
           jne .exit
 
     if DEBUG
           mov esi, msgInit
           call SysMsgBoardStr
     end if
 
           call detect_ati
           test eax, eax
           jz .fail
 
           call init_ati
           test eax, eax
           jz .fail
 
           or eax, -1
           mov [cursor_map], eax
           mov [cursor_map+4], eax
           mov edx, cursor_map
           mov [cursor_start], edx
           add edx, 8
           mov [cursor_end], edx
 
           stdcall RegService, sz_ati_srv, service_proc
           test eax, eax
           jz .fail
           mov dword [SetHwCursor], drvCursorPos ;enable hardware cursor
           mov dword [HwCursorRestore], drv_restore
           mov dword [HwCursorCreate], ati_cursor
           ret
.fail:
     if DEBUG
           mov esi, msgFail
           call SysMsgBoardStr
     end if
 
.exit:
           xor eax, eax
;           mov ebx, SetHwCursor
;           mov dword [ebx], eax    ;force disable hardware cursor
           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 service_proc stdcall, ioctl:dword
 
           mov edi, [ioctl]
           mov ebx, [edi+io_code]
           cmp ebx, VIDEO_FREE
           jne .fail
 
           mov eax, [edi+input]
           call video_free
.fail:
           or eax, -1
           ret
endp
 
restore   handle
restore   io_code
restore   input
restore   inp_size
restore   output
restore   out_size
 
align 4
proc detect_ati
           locals
             last_bus dd ?
           endl
 
           xor eax, eax
           mov [bus], eax
           inc eax
           call PciApi
           cmp eax, -1
           je .err
 
           mov [last_bus], eax
 
.next_bus:
           and [devfn], 0
.next_dev:
           stdcall PciRead32, [bus], [devfn], dword 0
           test eax, eax
           jz .next
           cmp eax, -1
           je .next
 
           mov edi, devices
@@:
           mov ebx, [edi]
           test ebx, ebx
           jz .next
 
           cmp eax, ebx
           je .found
           add edi, 4
           jmp @B
 
.next:
           inc [devfn]
           cmp [devfn], 256
           jb  .next_dev
           mov eax, [bus]
           inc eax
           mov [bus], eax
           cmp eax, [last_bus]
           jna .next_bus
           xor eax, eax
           ret
.found:
           xor eax, eax
           inc eax
           ret
.err:
           xor eax, eax
           ret
endp
 
align 4
proc init_ati
 
           stdcall AllocKernelSpace, dword 0x10000
           test eax, eax
           jz .fail
 
           mov [ati_io], eax
 
           stdcall PciRead32, [bus], [devfn], dword 0x18
           and eax, 0xFFFF0000
           mov esi, eax
 
           mov edi, [ati_io]
           mov edx, 16
@@:
           stdcall MapPage,edi,esi,PG_SW+PG_NOCACHE
           add edi, 0x1000
           add esi, 0x1000
           dec edx
           jnz @B
 
           mov edi, [ati_io]
           mov dword [edi+RD_RB3D_CNTL], 0
           call engRestore
 
           mov edi, [ati_io]
           mov eax, [edi+0x50]
           mov ebx,3
           shl ebx,20
           not ebx
           and eax,ebx
           mov ebx, 2
           shl ebx,20
           or eax, ebx
           mov [edi+0x50], eax
 
           call drvShowCursor
           xor eax, eax
           inc eax
.fail:
           ret
endp
 
align 4
drv_restore:
           ret 8
 
align 4
drvShowCursor:
           mov edi, [ati_io]
 
           mov eax, [edi+RD_CRTC_GEN_CNTL]
           bts eax,16
           mov [edi+RD_CRTC_GEN_CNTL], eax
           ret
 
align 4
proc drvCursorPos stdcall, hcursor:dword, x:dword, y:dword
           pushfd
           cli
 
           xor eax, eax
           xor edx, edx
           mov esi, [hcursor]
           mov ebx, [x]
           mov ecx, [y]
 
           sub ebx, [esi+CURSOR.hot_x]
           jnc @F
           neg ebx
           mov eax, ebx
           shl eax, 16
           xor ebx, ebx
@@:
           sub ecx, [esi+CURSOR.hot_y]
           jnc @F
           neg ecx
           mov ax, cx
           mov edx, ecx
           xor ecx, ecx
@@:
           or eax, 0x80000000
           wrr CUR_HORZ_VERT_OFF, eax
 
           shl ebx, 16
           mov bx, cx
           or ebx, 0x80000000
           wrr CUR_HORZ_VERT_POSN, ebx
 
           shl edx, 8
           add edx, [esi+CURSOR.base]
           sub edx, LFBAddress
           wrr CUR_OFFSET, edx
           popfd
           ret
endp
 
align 4
proc video_alloc
 
           pushfd
           cli
           mov ebx, [cursor_start]
           mov ecx, [cursor_end]
.l1:
           bsf eax,[ebx];
           jnz .found
           add ebx,4
           cmp ebx, ecx
           jb .l1
           popfd
           xor eax,eax
           ret
.found:
           btr [ebx], eax
           popfd
 
           mov [cursor_start],ebx
           sub ebx, cursor_map
           lea eax,[eax+ebx*8]
 
           shl eax,14
           add eax, LFBAddress+CURSOR_IMAGE_OFFSET
           ret
endp
 
align 4
video_free:
           pushfd
           cli
           sub eax, LFBAddress+CURSOR_IMAGE_OFFSET
           shr eax, 14
           mov ebx, cursor_map
           bts [ebx], eax
           shr eax, 3
           and eax, not 3
           add eax, ebx
           cmp [cursor_start], eax
           ja @f
           popfd
           ret
@@:
           mov [cursor_start], eax
           popfd
           ret
 
; param
;  eax= pid
;  ebx= src
;  ecx= flags
 
align 4
ati_cursor:
.src     equ esp
.flags   equ esp+4
.hcursor equ esp+8
 
           sub esp, 4          ;space for .hcursor
           push ecx
           push ebx
 
           mov ebx, eax
           mov eax, CURSOR_SIZE
           call CreateObject
           test eax, eax
           jz .fail
 
           mov [.hcursor],eax
 
           xor ebx, ebx
           mov [eax+CURSOR.magic], 'CURS'
           mov [eax+CURSOR.destroy], destroy_cursor
           mov [eax+CURSOR.hot_x], ebx
           mov [eax+CURSOR.hot_y], ebx
 
           call video_alloc
           mov edi, [.hcursor]
           mov [edi+CURSOR.base], eax
 
           mov esi, [.src]
           mov ebx, [.flags]
           cmp bx, LOAD_INDIRECT
           je .indirect
 
           movzx ecx, word [esi+10]
           movzx edx, word [esi+12]
           mov [edi+CURSOR.hot_x], ecx
           mov [edi+CURSOR.hot_y], edx
 
           stdcall ati_init_cursor, eax, esi
           mov eax, [.hcursor]
.fail:
           add esp, 12
           ret
.indirect:
           shr ebx, 16
           movzx ecx, bh
           movzx edx, bl
           mov [edi+CURSOR.hot_x], ecx
           mov [edi+CURSOR.hot_y], edx
 
           mov edi, eax
           mov ebx, eax
           mov ecx, 64*64
           xor eax,eax
           cld
           rep stosd
           mov edi, ebx
 
           mov esi, [.src]
           mov ebx, 32
           cld
@@:
           mov ecx, 32
           rep movsd
           add edi, 128
           dec ebx
           jnz @B
           mov eax, [.hcursor]
           add esp, 12
           ret
 
align 4
destroy_cursor:
 
           push eax
           mov eax, [eax+CURSOR.base]
           call video_free
           pop eax
 
           call DestroyObject
           ret
 
align 4
proc ati_init_cursor stdcall, dst:dword, src:dword
           locals
             rBase    dd ?
             pQuad    dd ?
             pBits    dd ?
             pAnd     dd ?
             width    dd ?
             height   dd ?
             counter  dd ?
           endl
 
           mov esi, [src]
           add esi,[esi+18]
           mov eax,esi
 
           cmp [esi+BI.biBitCount], 24
           je .img_24
           cmp [esi+BI.biBitCount], 8
           je .img_8
           cmp [esi+BI.biBitCount], 4
           je .img_4
 
.img_2:
           add eax, [esi]
           mov [pQuad],eax
           add eax,8
           mov [pBits],eax
           add eax, 128
           mov [pAnd],eax
           mov eax,[esi+4]
           mov [width],eax
           mov ebx,[esi+8]
           shr ebx,1
           mov [height],ebx
 
           mov edi, pCursor
           add edi, 32*31*4
           mov [rBase],edi
 
           mov esi,[pQuad]
.l21:
           mov ebx, [pBits]
           mov ebx, [ebx]
           bswap ebx
           mov eax, [pAnd]
           mov eax, [eax]
           bswap eax
           mov [counter], 32
@@:
           xor edx, edx
           shl eax,1
           setc dl
           dec edx
 
           xor ecx, ecx
           shl ebx,1
           setc cl
           mov ecx, [esi+ecx*4]
           and ecx, edx
           and edx, 0xFF000000
           or edx, ecx
           mov [edi], edx
 
           add edi, 4
           dec [counter]
           jnz @B
 
           add [pBits], 4
           add [pAnd], 4
           mov edi,[rBase]
           sub edi,128
           mov [rBase],edi
           sub [height],1
           jnz .l21
           jmp .copy
.img_4:
           add eax, [esi]
           mov [pQuad],eax
           add eax,64
           mov [pBits],eax
           add eax, 0x200
           mov [pAnd],eax
           mov eax,[esi+4]
           mov [width],eax
           mov ebx,[esi+8]
           shr ebx,1
           mov [height],ebx
 
           mov edi, pCursor
           add edi, 32*31*4
           mov [rBase],edi
 
           mov esi,[pQuad]
           mov ebx, [pBits]
.l4:
           mov eax, [pAnd]
           mov eax, [eax]
           bswap eax
           mov [counter], 16
@@:
           xor edx, edx
           shl eax,1
           setc dl
           dec edx
 
           movzx ecx, byte [ebx]
           and cl, 0xF0
           shr ecx, 2
           mov ecx, [esi+ecx]
           and ecx, edx
           and edx, 0xFF000000
           or edx, ecx
           mov [edi], edx
 
           xor edx, edx
           shl eax,1
           setc dl
           dec edx
 
           movzx ecx, byte [ebx]
           and cl, 0x0F
           mov ecx, [esi+ecx*4]
           and ecx, edx
           and edx, 0xFF000000
           or edx, ecx
           mov [edi+4], edx
 
           inc ebx
           add edi, 8
           dec [counter]
           jnz @B
 
           add [pAnd], 4
           mov edi,[rBase]
           sub edi,128
           mov [rBase],edi
           sub [height],1
           jnz .l4
           jmp .copy
.img_8:
           add eax, [esi]
           mov [pQuad],eax
           add eax,1024
           mov [pBits],eax
           add eax, 1024
           mov [pAnd],eax
           mov eax,[esi+4]
           mov [width],eax
           mov ebx,[esi+8]
           shr ebx,1
           mov [height],ebx
 
           mov edi, pCursor
           add edi, 32*31*4
           mov [rBase],edi
 
           mov esi,[pQuad]
           mov ebx, [pBits]
.l81:
           mov eax, [pAnd]
           mov eax, [eax]
           bswap eax
           mov [counter], 32
@@:
           xor edx, edx
           shl eax,1
           setc dl
           dec edx
 
           movzx ecx,  byte [ebx]
           mov ecx, [esi+ecx*4]
           and ecx, edx
           and edx, 0xFF000000
           or edx, ecx
           mov [edi], edx
 
           inc ebx
           add edi, 4
           dec [counter]
           jnz @B
 
           add [pAnd], 4
           mov edi,[rBase]
           sub edi,128
           mov [rBase],edi
           sub [height],1
           jnz .l81
           jmp .copy
.img_24:
           add eax, [esi]
           mov [pQuad],eax
           add eax, 0xC00
           mov [pAnd],eax
           mov eax,[esi+BI.biWidth]
           mov [width],eax
           mov ebx,[esi+BI.biHeight]
           shr ebx,1
           mov [height],ebx
 
           mov edi, pCursor
           add edi, 32*31*4
           mov [rBase],edi
 
           mov esi,[pAnd]
           mov ebx, [pQuad]
.row_24:
           mov eax, [esi]
           bswap eax
           mov [counter], 32
@@:
           xor edx, edx
           shl eax,1
           setc dl
           dec edx
 
           mov ecx, [ebx]
           and ecx, 0x00FFFFFF
           and ecx, edx
           and edx, 0xFF000000
           or edx, ecx
           mov [edi], edx
           add ebx, 3
           add edi, 4
           dec [counter]
           jnz @B
 
           add esi, 4
           mov edi,[rBase]
           sub edi,128
           mov [rBase],edi
           sub [height],1
           jnz .row_24
.copy:
           mov edi, [dst]
           mov ecx, 64*64
           xor eax,eax
           rep stosd
 
           mov esi, pCursor
           mov edi, [dst]
           mov ebx, 32
           cld
@@:
           mov ecx, 32
           rep movsd
           add edi, 128
           dec ebx
           jnz @B
           ret
endp
 
align 4
proc engFlush
 
           mov edi, [ati_io]
 
           mov eax, [edi+RD_RB2D_DSTCACHE_CTLSTAT]
           or eax,RD_RB2D_DC_FLUSH_ALL
           mov [edi+RD_RB2D_DSTCACHE_CTLSTAT],eax
 
           mov ecx, RD_TIMEOUT
@@:
           mov eax,[edi+RD_RB2D_DSTCACHE_CTLSTAT]
           and eax, RD_RB2D_DC_BUSY
           jz .exit
 
           sub ecx,1
           jnz @B
.exit:
           ret
endp
 
align 4
engWaitForFifo:
cnt equ bp+8
           push ebp
           mov ebp, esp
 
           mov edi, [ati_io]
 
           mov ecx, RD_TIMEOUT
@@:
           mov eax, [edi+RD_RBBM_STATUS]
           and eax, RD_RBBM_FIFOCNT_MASK
           cmp eax, [ebp+8]
           jae .exit
 
           sub ecx,1
           jmp @B
 
.exit:
           leave
           ret 4
 
align 4
proc engWaitForIdle
 
           push dword 64
           call engWaitForFifo
 
           mov edi, [ati_io]
           mov ecx ,RD_TIMEOUT
@@:
           mov eax, [edi+RD_RBBM_STATUS]
           and eax,RD_RBBM_ACTIVE
           jz .exit
 
           sub ecx,1
           jnz @B
.exit:
           call engFlush
           ret
endp
 
align 4
proc engRestore
 
;             push dword 1
;             call engWaitForFifo
 
;             mov dword  [MMIO+RD_RB2D_DSTCACHE_MODE], 0
 
           push dword 3
           call engWaitForFifo
 
           mov edi, [ati_io]
 
           mov eax, [edi+RD_DISPLAY_BASE_ADDR]
           shr eax, 10d
           or eax,(64d shl 22d)
           mov [edi+RD_DEFAULT_OFFSET],eax
           mov [edi+RD_SRC_PITCH_OFFSET],eax
           mov [edi+RD_DST_PITCH_OFFSET],eax
 
           push dword 1
           call engWaitForFifo
 
           mov edi, [ati_io]
           mov eax, [edi+RD_DP_DATATYPE]
           btr eax, 29d
           mov [edi+RD_DP_DATATYPE],eax
 
           push dword 1
           call engWaitForFifo
 
           mov edi, [ati_io]
           mov dword [edi+RD_DEFAULT_SC_BOTTOM_RIGHT],\
                     (RD_DEFAULT_SC_RIGHT_MAX or RD_DEFAULT_SC_BOTTOM_MAX)
 
           push dword 1
           call engWaitForFifo
 
           mov edi, [ati_io]
           mov dword [edi+RD_DP_GUI_MASTER_CNTL],\
                     (RD_GMC_BRUSH_SOLID_COLOR or \
                      RD_GMC_SRC_DATATYPE_COLOR or \
                     (6 shl RD_GMC_DST_DATATYPE_SHIFT) or \
                      RD_GMC_CLR_CMP_CNTL_DIS or \
                      RD_ROP3_P or \
                      RD_GMC_WR_MSK_DIS)
 
 
           push dword 7
           call engWaitForFifo
 
           mov edi, [ati_io]
 
           mov dword [edi+RD_DST_LINE_START],0
           mov dword [edi+RD_DST_LINE_END], 0
           mov dword [edi+RD_DP_BRUSH_FRGD_CLR], 808000ffh
           mov dword [edi+RD_DP_BRUSH_BKGD_CLR], 002020ffh
           mov dword [edi+RD_DP_SRC_FRGD_CLR],   808000ffh
           mov dword [edi+RD_DP_SRC_BKGD_CLR],   004000ffh
           mov dword [edi+RD_DP_WRITE_MASK],0ffffffffh
 
           call engWaitForIdle
 
           ret
endp
 
align 4
engSetupSolidFill:
           push ebp
           mov ebp, esp
 
           push dword 3
           call engWaitForFifo
 
           wrr RD_DP_GUI_MASTER_CNTL, cmdSolidFill
 
           mov eax, [ebp+8]
           wrr RD_DP_BRUSH_FRGD_CLR,eax
 
           mov edi, [ati_io]
           mov dword [edi+RD_DP_CNTL],(RD_DST_X_LEFT_TO_RIGHT or RD_DST_Y_TOP_TO_BOTTOM)
           leave
           ret 4
 
 
align 4
drvSolidFill:
;x:word,y:word,w:word,h:word,color:dword
            push ebp
            mov ebp, esp
x equ ebp+8
y equ ebp+12
w equ ebp+16
h equ ebp+20
color equ ebp+24
 
           push dword [ebp+24]
           call engSetupSolidFill
 
           push dword 2
           call engWaitForFifo
 
           mov edi, [ati_io]
 
           mov eax, [y]
           mov ebx, [x]
           shl eax,16
           or eax, ebx
 
           mov ecx,  [w]
           mov edx,  [h]
           shl ecx,16
           or ecx, edx
           mov [edi+RD_DST_Y_X], eax
           mov [edi+RD_DST_WIDTH_HEIGHT], ecx
           call engFlush
           leave
           ret 20
 
align 4
devices dd (R8500   shl 16)+VID_ATI
        dd (R9000   shl 16)+VID_ATI
        dd (R9200   shl 16)+VID_ATI
        dd (R9500   shl 16)+VID_ATI
        dd (R9500P  shl 16)+VID_ATI
        dd (R9550   shl 16)+VID_ATI
        dd (R9600   shl 16)+VID_ATI
        dd (R9600XT shl 16)+VID_ATI
        dd (R9700P  shl 16)+VID_ATI
        dd (R9800   shl 16)+VID_ATI
        dd (R9800P  shl 16)+VID_ATI
        dd (R9800XT shl 16)+VID_ATI
        dd 0    ;terminator
 
version dd 0x00040004
 
sz_ati_srv   db 'HWCURSOR',0
 
msgInit      db 'detect hardware...',13,10,0
msgPCI       db 'PCI accsess not supported',13,10,0
msgFail      db 'device not found',13,10,0
msg_neg      db 'neg ecx',13,10,0
buff         db 8 dup(0)
             db 13,10, 0
 
section '.data' data readable writable align 16
 
pCursor  db 4096 dup(?)
 
cursor_map     rd 2
cursor_start   rd 1
cursor_end     rd 1
 
bus            dd ?
devfn          dd ?
ati_io         dd ?

Rev 425	Rev 431
-		1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		2	;; ;;
-		3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
-		4	;; Distributed under terms of the GNU General Public License ;;
-		5	;; ;;
-		6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1	format MS COFF	7
2		8	format MS COFF
3	include 'proc32.inc'	9
4	include 'imports.inc'	10	include 'proc32.inc'
5		11	include 'imports.inc'
6	DEBUG equ 1	12
7		13	DEBUG equ 1
8	VID_ATI equ 0x1002	14
9		15	VID_ATI equ 0x1002
10	LOAD_FROM_FILE equ 0	16
11	LOAD_FROM_MEM equ 1	17	LOAD_FROM_FILE equ 0
12	LOAD_INDIRECT equ 2	18	LOAD_FROM_MEM equ 1
13	LOAD_SYSTEM equ 3	19	LOAD_INDIRECT equ 2
14		20	LOAD_SYSTEM equ 3
15	VIDEO_FREE equ 2	21
16		22	VIDEO_FREE equ 2
17	struc BITMAPINFOHEADER {	23
18	.biSize dd ? ; DWORD	24	struc BITMAPINFOHEADER {
19	.biWidth dd ? ; LONG	25	.biSize dd ? ; DWORD
20	.biHeight dd ? ; LONG	26	.biWidth dd ? ; LONG
21	.biPlanes dw ? ; WORD	27	.biHeight dd ? ; LONG
22	.biBitCount dw ? ; WORD	28	.biPlanes dw ? ; WORD
23	.biCompression dd ? ; DWORD	29	.biBitCount dw ? ; WORD
24	.biSizeImage dd ? ; DWORD	30	.biCompression dd ? ; DWORD
25	.biXPelsPerMeter dd ? ; LONG	31	.biSizeImage dd ? ; DWORD
26	.biYPelsPerMeter dd ? ; LONG	32	.biXPelsPerMeter dd ? ; LONG
27	.biClrUsed dd ? ; DWORD	33	.biYPelsPerMeter dd ? ; LONG
28	.biClrImportant dd ? ; DWORD	34	.biClrUsed dd ? ; DWORD
29	}	35	.biClrImportant dd ? ; DWORD
30		36	}
31	virtual at 0	37
32	BI BITMAPINFOHEADER	38	virtual at 0
33	end virtual	39	BI BITMAPINFOHEADER
34		40	end virtual
35	struc CURSOR	41
36	{;common object header	42	struc CURSOR
37	.magic dd ? ;'CURS'	43	{;common object header
38	.destroy dd ? ;internal destructor	44	.magic dd ? ;'CURS'
39	.fd dd ? ;next object in list	45	.destroy dd ? ;internal destructor
40	.bk dd ? ;prev object in list	46	.fd dd ? ;next object in list
41	.pid dd ? ;owner id	47	.bk dd ? ;prev object in list
42		48	.pid dd ? ;owner id
43	;cursor data	49
44	.base dd ? ;allocated memory	50	;cursor data
45	.hot_x dd ? ;hotspot coords	51	.base dd ? ;allocated memory
46	.hot_y dd ?	52	.hot_x dd ? ;hotspot coords
47	}	53	.hot_y dd ?
48	virtual at 0	54	}
49	CURSOR CURSOR	55	virtual at 0
50	end virtual	56	CURSOR CURSOR
51		57	end virtual
52	CURSOR_SIZE equ 32	58
53		59	CURSOR_SIZE equ 32
54	R8500 equ 0x514C ;R200	60
55	R9000 equ 0x4966 ;RV250	61	R8500 equ 0x514C ;R200
56	R9200 equ 0x5961 ;RV280	62	R9000 equ 0x4966 ;RV250
57	R9500 equ 0x4144 ;R300	63	R9200 equ 0x5961 ;RV280
58	R9500P equ 0x4E45 ;R300	64	R9500 equ 0x4144 ;R300
59	R9550 equ 0x4153 ;RV350	65	R9500P equ 0x4E45 ;R300
60	R9600 equ 0x4150 ;RV350	66	R9550 equ 0x4153 ;RV350
61	R9600XT equ 0x4152 ;RV360	67	R9600 equ 0x4150 ;RV350
62	R9700P equ 0x4E44 ;R300	68	R9600XT equ 0x4152 ;RV360
63	R9800 equ 0x4E49 ;R350	69	R9700P equ 0x4E44 ;R300
64	R9800P equ 0x4E48 ;R350	70	R9800 equ 0x4E49 ;R350
65	R9800XT equ 0x4E4A ;R360	71	R9800P equ 0x4E48 ;R350
66		72	R9800XT equ 0x4E4A ;R360
67	OS_BASE equ 0	73
68	new_app_base equ 0x80000000	74	OS_BASE equ 0
69	SLOT_BASE equ 0x0080000	75	new_app_base equ 0x80000000
70		76	SLOT_BASE equ 0x0080000
71	PG_SW equ 0x003	77
72	PG_NOCACHE equ 0x018	78	PG_SW equ 0x003
73		79	PG_NOCACHE equ 0x018
74	struc IOCTL	80
75	{ .handle dd ?	81	struc IOCTL
76	.io_code dd ?	82	{ .handle dd ?
77	.input dd ?	83	.io_code dd ?
78	.inp_size dd ?	84	.input dd ?
79	.output dd ?	85	.inp_size dd ?
80	.out_size dd ?	86	.output dd ?
81	}	87	.out_size dd ?
82		88	}
83	virtual at 0	89
84	IOCTL IOCTL	90	virtual at 0
85	end virtual	91	IOCTL IOCTL
86		92	end virtual
87	;MMIO equ 0F9000000h	93
88	RD_RB3D_CNTL equ 1c3ch	94	;MMIO equ 0F9000000h
89		95	RD_RB3D_CNTL equ 1c3ch
90	RD_MEM_CNTL equ 0140h	96
91	RD_CRTC_GEN_CNTL equ 0050h	97	RD_MEM_CNTL equ 0140h
92	RD_CRTC_CUR_EN equ 10000h	98	RD_CRTC_GEN_CNTL equ 0050h
93	RD_DISPLAY_BASE_ADDR equ 023ch	99	RD_CRTC_CUR_EN equ 10000h
94	RD_DEFAULT_OFFSET equ 16e0h	100	RD_DISPLAY_BASE_ADDR equ 023ch
95	CUR_HORZ_VERT_OFF equ 0268h	101	RD_DEFAULT_OFFSET equ 16e0h
96	CUR_HORZ_VERT_POSN equ 0264h	102	CUR_HORZ_VERT_OFF equ 0268h
97	CUR_OFFSET equ 0260h	103	CUR_HORZ_VERT_POSN equ 0264h
98	RD_RB3D_CNTL equ 1c3ch	104	CUR_OFFSET equ 0260h
99	RD_RBBM_STATUS equ 0e40h	105	RD_RB3D_CNTL equ 1c3ch
100	RD_RBBM_FIFOCNT_MASK equ 007fh	106	RD_RBBM_STATUS equ 0e40h
101	RD_RBBM_ACTIVE equ 80000000h	107	RD_RBBM_FIFOCNT_MASK equ 007fh
102	RD_TIMEOUT equ 2000000	108	RD_RBBM_ACTIVE equ 80000000h
103		109	RD_TIMEOUT equ 2000000
104	RD_DP_GUI_MASTER_CNTL equ 0146ch	110
105	RD_DP_BRUSH_BKGD_CLR equ 01478h	111	RD_DP_GUI_MASTER_CNTL equ 0146ch
106	RD_DP_BRUSH_FRGD_CLR equ 0147ch	112	RD_DP_BRUSH_BKGD_CLR equ 01478h
107	RD_DP_SRC_BKGD_CLR equ 015dch	113	RD_DP_BRUSH_FRGD_CLR equ 0147ch
108	RD_DP_SRC_FRGD_CLR equ 015d8h	114	RD_DP_SRC_BKGD_CLR equ 015dch
109	RD_DP_CNTL equ 016c0h	115	RD_DP_SRC_FRGD_CLR equ 015d8h
110	RD_DP_DATATYPE equ 016c4h	116	RD_DP_CNTL equ 016c0h
111	RD_DP_WRITE_MASK equ 016cch	117	RD_DP_DATATYPE equ 016c4h
112	RD_DP_SRC_SOURCE_MEMORY equ (2 shl 24)	118	RD_DP_WRITE_MASK equ 016cch
113	RD_DP_SRC_SOURCE_HOST_DATA equ (3 shl 24)	119	RD_DP_SRC_SOURCE_MEMORY equ (2 shl 24)
114	RD_DEFAULT_SC_BOTTOM_RIGHT equ 16e8h	120	RD_DP_SRC_SOURCE_HOST_DATA equ (3 shl 24)
115	RD_GMC_BRUSH_SOLID_COLOR equ (13 shl 4)	121	RD_DEFAULT_SC_BOTTOM_RIGHT equ 16e8h
116	RD_DEFAULT_SC_RIGHT_MAX equ 1fffh	122	RD_GMC_BRUSH_SOLID_COLOR equ (13 shl 4)
117	RD_DEFAULT_SC_BOTTOM_MAX equ 1fff0000h	123	RD_DEFAULT_SC_RIGHT_MAX equ 1fffh
118	RD_GMC_DST_DATATYPE_SHIFT equ 8	124	RD_DEFAULT_SC_BOTTOM_MAX equ 1fff0000h
119		125	RD_GMC_DST_DATATYPE_SHIFT equ 8
120	RD_ROP3_S equ 00cc0000h	126
121	RD_ROP3_P equ 00f00000h	127	RD_ROP3_S equ 00cc0000h
122		128	RD_ROP3_P equ 00f00000h
123	RD_RB2D_DSTCACHE_MODE equ 03428h	129
124	RD_RB2D_DSTCACHE_CTLSTAT equ 0342ch	130	RD_RB2D_DSTCACHE_MODE equ 03428h
125	RD_RB2D_DC_FLUSH_ALL equ 000fh	131	RD_RB2D_DSTCACHE_CTLSTAT equ 0342ch
126	RD_RB2D_DC_BUSY equ 80000000h	132	RD_RB2D_DC_FLUSH_ALL equ 000fh
127		133	RD_RB2D_DC_BUSY equ 80000000h
128	RD_GMC_BRUSH_SOLID_COLOR equ 000000D0h	134
129	RD_GMC_SRC_DATATYPE_COLOR equ (3 shl 12)	135	RD_GMC_BRUSH_SOLID_COLOR equ 000000D0h
130	RD_GMC_CLR_CMP_CNTL_DIS equ (1 shl 28)	136	RD_GMC_SRC_DATATYPE_COLOR equ (3 shl 12)
131	RD_GMC_WR_MSK_DIS equ (1 shl 30)	137	RD_GMC_CLR_CMP_CNTL_DIS equ (1 shl 28)
132		138	RD_GMC_WR_MSK_DIS equ (1 shl 30)
133	cmdSolidFill equ 73f036d0h	139
134		140	cmdSolidFill equ 73f036d0h
135	RD_DST_PITCH_OFFSET equ 142ch	141
136	RD_SRC_PITCH_OFFSET equ 1428h	142	RD_DST_PITCH_OFFSET equ 142ch
137		143	RD_SRC_PITCH_OFFSET equ 1428h
138	RD_DST_X_LEFT_TO_RIGHT equ 1	144
139	RD_DST_Y_TOP_TO_BOTTOM equ 2	145	RD_DST_X_LEFT_TO_RIGHT equ 1
140	RD_DST_Y_X equ 1438h	146	RD_DST_Y_TOP_TO_BOTTOM equ 2
141	RD_DST_WIDTH_HEIGHT equ 1598h	147	RD_DST_Y_X equ 1438h
142	RD_DST_LINE_START equ 1600h	148	RD_DST_WIDTH_HEIGHT equ 1598h
143	RD_DST_LINE_END equ 1604h	149	RD_DST_LINE_START equ 1600h
144	R300_MEM_NUM_CHANNELS_MASK equ 0003h	150	RD_DST_LINE_END equ 1604h
145		151	R300_MEM_NUM_CHANNELS_MASK equ 0003h
146	macro rdr op1, op2	152
147	{	153	macro rdr op1, op2
148	mov edi, [ati_io]	154	{
149	mov op1, [edi+op2]	155	mov edi, [ati_io]
150	}	156	mov op1, [edi+op2]
151		157	}
152	macro wrr dest, src	158
153	{	159	macro wrr dest, src
154	mov edi, [ati_io]	160	{
155	mov dword [edi+dest], src	161	mov edi, [ati_io]
156	}	162	mov dword [edi+dest], src
157		163	}
158		164
159	public START	165
160	public service_proc	166	public START
161	public version	167	public service_proc
162		168	public version
163	CURSOR_IMAGE_OFFSET equ 0x00500000	169
164		170	CURSOR_IMAGE_OFFSET equ 0x00500000
165	DRV_ENTRY equ 1	171
166	DRV_EXIT equ -1	172	DRV_ENTRY equ 1
167		173	DRV_EXIT equ -1
168	section '.flat' code readable align 16	174
169		175	section '.flat' code readable align 16
170	proc START stdcall, state:dword	176
171		177	proc START stdcall, state:dword
172	cmp [state], 1	178
173	jne .exit	179	cmp [state], 1
174		180	jne .exit
175	if DEBUG	181
176	mov esi, msgInit	182	if DEBUG
177	call SysMsgBoardStr	183	mov esi, msgInit
178	end if	184	call SysMsgBoardStr
179		185	end if
180	call detect_ati	186
181	test eax, eax	187	call detect_ati
182	jz .fail	188	test eax, eax
183		189	jz .fail
184	call init_ati	190
185	test eax, eax	191	call init_ati
186	jz .fail	192	test eax, eax
187		193	jz .fail
188	or eax, -1	194
189	mov [cursor_map], eax	195	or eax, -1
190	mov [cursor_map+4], eax	196	mov [cursor_map], eax
191	mov edx, cursor_map	197	mov [cursor_map+4], eax
192	mov [cursor_start], edx	198	mov edx, cursor_map
193	add edx, 8	199	mov [cursor_start], edx
194	mov [cursor_end], edx	200	add edx, 8
195		201	mov [cursor_end], edx
196	stdcall RegService, sz_ati_srv, service_proc	202
197	test eax, eax	203	stdcall RegService, sz_ati_srv, service_proc
198	jz .fail	204	test eax, eax
199	mov dword [SetHwCursor], drvCursorPos ;enable hardware cursor	205	jz .fail
200	mov dword [HwCursorRestore], drv_restore	206	mov dword [SetHwCursor], drvCursorPos ;enable hardware cursor
201	mov dword [HwCursorCreate], ati_cursor	207	mov dword [HwCursorRestore], drv_restore
202	ret	208	mov dword [HwCursorCreate], ati_cursor
203	.fail:	209	ret
204	if DEBUG	210	.fail:
205	mov esi, msgFail	211	if DEBUG
206	call SysMsgBoardStr	212	mov esi, msgFail
207	end if	213	call SysMsgBoardStr
208		214	end if
209	.exit:	215
210	xor eax, eax	216	.exit:
211	; mov ebx, SetHwCursor	217	xor eax, eax
212	; mov dword [ebx], eax ;force disable hardware cursor	218	; mov ebx, SetHwCursor
213	ret	219	; mov dword [ebx], eax ;force disable hardware cursor
214	endp	220	ret
215		221	endp
216	handle equ IOCTL.handle	222
217	io_code equ IOCTL.io_code	223	handle equ IOCTL.handle
218	input equ IOCTL.input	224	io_code equ IOCTL.io_code
219	inp_size equ IOCTL.inp_size	225	input equ IOCTL.input
220	output equ IOCTL.output	226	inp_size equ IOCTL.inp_size
221	out_size equ IOCTL.out_size	227	output equ IOCTL.output
222		228	out_size equ IOCTL.out_size
223	align 4	229
224	proc service_proc stdcall, ioctl:dword	230	align 4
225		231	proc service_proc stdcall, ioctl:dword
226	mov edi, [ioctl]	232
227	mov ebx, [edi+io_code]	233	mov edi, [ioctl]
228	cmp ebx, VIDEO_FREE	234	mov ebx, [edi+io_code]
229	jne .fail	235	cmp ebx, VIDEO_FREE
230		236	jne .fail
231	mov eax, [edi+input]	237
232	call video_free	238	mov eax, [edi+input]
233	.fail:	239	call video_free
234	or eax, -1	240	.fail:
235	ret	241	or eax, -1
236	endp	242	ret
237		243	endp
238	restore handle	244
239	restore io_code	245	restore handle
240	restore input	246	restore io_code
241	restore inp_size	247	restore input
242	restore output	248	restore inp_size
243	restore out_size	249	restore output
244		250	restore out_size
245	align 4	251
246	proc detect_ati	252	align 4
247	locals	253	proc detect_ati
248	last_bus dd ?	254	locals
249	endl	255	last_bus dd ?
250		256	endl
251	xor eax, eax	257
252	mov [bus], eax	258	xor eax, eax
253	inc eax	259	mov [bus], eax
254	call PciApi	260	inc eax
255	cmp eax, -1	261	call PciApi
256	je .err	262	cmp eax, -1
257		263	je .err
258	mov [last_bus], eax	264
259		265	mov [last_bus], eax
260	.next_bus:	266
261	and [devfn], 0	267	.next_bus:
262	.next_dev:	268	and [devfn], 0
263	stdcall PciRead32, [bus], [devfn], dword 0	269	.next_dev:
264	test eax, eax	270	stdcall PciRead32, [bus], [devfn], dword 0
265	jz .next	271	test eax, eax
266	cmp eax, -1	272	jz .next
267	je .next	273	cmp eax, -1
268		274	je .next
269	mov edi, devices	275
270	@@:	276	mov edi, devices
271	mov ebx, [edi]	277	@@:
272	test ebx, ebx	278	mov ebx, [edi]
273	jz .next	279	test ebx, ebx
274		280	jz .next
275	cmp eax, ebx	281
276	je .found	282	cmp eax, ebx
277	add edi, 4	283	je .found
278	jmp @B	284	add edi, 4
279		285	jmp @B
280	.next:	286
281	inc [devfn]	287	.next:
282	cmp [devfn], 256	288	inc [devfn]
283	jb .next_dev	289	cmp [devfn], 256
284	mov eax, [bus]	290	jb .next_dev
285	inc eax	291	mov eax, [bus]
286	mov [bus], eax	292	inc eax
287	cmp eax, [last_bus]	293	mov [bus], eax
288	jna .next_bus	294	cmp eax, [last_bus]
289	xor eax, eax	295	jna .next_bus
290	ret	296	xor eax, eax
291	.found:	297	ret
292	xor eax, eax	298	.found:
293	inc eax	299	xor eax, eax
294	ret	300	inc eax
295	.err:	301	ret
296	xor eax, eax	302	.err:
297	ret	303	xor eax, eax
298	endp	304	ret
299		305	endp
300	align 4	306
301	proc init_ati	307	align 4
302		308	proc init_ati
303	stdcall AllocKernelSpace, dword 0x10000	309
304	test eax, eax	310	stdcall AllocKernelSpace, dword 0x10000
305	jz .fail	311	test eax, eax
306		312	jz .fail
307	mov [ati_io], eax	313
308		314	mov [ati_io], eax
309	stdcall PciRead32, [bus], [devfn], dword 0x18	315
310	and eax, 0xFFFF0000	316	stdcall PciRead32, [bus], [devfn], dword 0x18
311	mov esi, eax	317	and eax, 0xFFFF0000
312		318	mov esi, eax
313	mov edi, [ati_io]	319
314	mov edx, 16	320	mov edi, [ati_io]
315	@@:	321	mov edx, 16
316	stdcall MapPage,edi,esi,PG_SW+PG_NOCACHE	322	@@:
317	add edi, 0x1000	323	stdcall MapPage,edi,esi,PG_SW+PG_NOCACHE
318	add esi, 0x1000	324	add edi, 0x1000
319	dec edx	325	add esi, 0x1000
320	jnz @B	326	dec edx
321		327	jnz @B
322	mov edi, [ati_io]	328
323	mov dword [edi+RD_RB3D_CNTL], 0	329	mov edi, [ati_io]
324	call engRestore	330	mov dword [edi+RD_RB3D_CNTL], 0
325		331	call engRestore
326	mov edi, [ati_io]	332
327	mov eax, [edi+0x50]	333	mov edi, [ati_io]
328	mov ebx,3	334	mov eax, [edi+0x50]
329	shl ebx,20	335	mov ebx,3
330	not ebx	336	shl ebx,20
331	and eax,ebx	337	not ebx
332	mov ebx, 2	338	and eax,ebx
333	shl ebx,20	339	mov ebx, 2
334	or eax, ebx	340	shl ebx,20
335	mov [edi+0x50], eax	341	or eax, ebx
336		342	mov [edi+0x50], eax
337	call drvShowCursor	343
338	xor eax, eax	344	call drvShowCursor
339	inc eax	345	xor eax, eax
340	.fail:	346	inc eax
341	ret	347	.fail:
342	endp	348	ret
343		349	endp
344	align 4	350
345	drv_restore:	351	align 4
346	ret 8	352	drv_restore:
347		353	ret 8
348	align 4	354
349	drvShowCursor:	355	align 4
350	mov edi, [ati_io]	356	drvShowCursor:
351		357	mov edi, [ati_io]
352	mov eax, [edi+RD_CRTC_GEN_CNTL]	358
353	bts eax,16	359	mov eax, [edi+RD_CRTC_GEN_CNTL]
354	mov [edi+RD_CRTC_GEN_CNTL], eax	360	bts eax,16
355	ret	361	mov [edi+RD_CRTC_GEN_CNTL], eax
356		362	ret
357	align 4	363
358	proc drvCursorPos stdcall, hcursor:dword, x:dword, y:dword	364	align 4
359	pushfd	365	proc drvCursorPos stdcall, hcursor:dword, x:dword, y:dword
360	cli	366	pushfd
361		367	cli
362	xor eax, eax	368
363	xor edx, edx	369	xor eax, eax
364	mov esi, [hcursor]	370	xor edx, edx
365	mov ebx, [x]	371	mov esi, [hcursor]
366	mov ecx, [y]	372	mov ebx, [x]
367		373	mov ecx, [y]
368	sub ebx, [esi+CURSOR.hot_x]	374
369	jnc @F	375	sub ebx, [esi+CURSOR.hot_x]
370	neg ebx	376	jnc @F
371	mov eax, ebx	377	neg ebx
372	shl eax, 16	378	mov eax, ebx
373	xor ebx, ebx	379	shl eax, 16
374	@@:	380	xor ebx, ebx
375	sub ecx, [esi+CURSOR.hot_y]	381	@@:
376	jnc @F	382	sub ecx, [esi+CURSOR.hot_y]
377	neg ecx	383	jnc @F
378	mov ax, cx	384	neg ecx
379	mov edx, ecx	385	mov ax, cx
380	xor ecx, ecx	386	mov edx, ecx
381	@@:	387	xor ecx, ecx
382	or eax, 0x80000000	388	@@:
383	wrr CUR_HORZ_VERT_OFF, eax	389	or eax, 0x80000000
384		390	wrr CUR_HORZ_VERT_OFF, eax
385	shl ebx, 16	391
386	mov bx, cx	392	shl ebx, 16
387	or ebx, 0x80000000	393	mov bx, cx
388	wrr CUR_HORZ_VERT_POSN, ebx	394	or ebx, 0x80000000
389		395	wrr CUR_HORZ_VERT_POSN, ebx
390	shl edx, 8	396
391	add edx, [esi+CURSOR.base]	397	shl edx, 8
392	sub edx, LFBAddress	398	add edx, [esi+CURSOR.base]
393	wrr CUR_OFFSET, edx	399	sub edx, LFBAddress
394	popfd	400	wrr CUR_OFFSET, edx
395	ret	401	popfd
396	endp	402	ret
397		403	endp
398	align 4	404
399	proc video_alloc	405	align 4
400		406	proc video_alloc
401	pushfd	407
402	cli	408	pushfd
403	mov ebx, [cursor_start]	409	cli
404	mov ecx, [cursor_end]	410	mov ebx, [cursor_start]
405	.l1:	411	mov ecx, [cursor_end]
406	bsf eax,[ebx];	412	.l1:
407	jnz .found	413	bsf eax,[ebx];
408	add ebx,4	414	jnz .found
409	cmp ebx, ecx	415	add ebx,4
410	jb .l1	416	cmp ebx, ecx
411	popfd	417	jb .l1
412	xor eax,eax	418	popfd
413	ret	419	xor eax,eax
414	.found:	420	ret
415	btr [ebx], eax	421	.found:
416	popfd	422	btr [ebx], eax
417		423	popfd
418	mov [cursor_start],ebx	424
419	sub ebx, cursor_map	425	mov [cursor_start],ebx
420	lea eax,[eax+ebx*8]	426	sub ebx, cursor_map
421		427	lea eax,[eax+ebx*8]
422	shl eax,14	428
423	add eax, LFBAddress+CURSOR_IMAGE_OFFSET	429	shl eax,14
424	ret	430	add eax, LFBAddress+CURSOR_IMAGE_OFFSET
425	endp	431	ret
426		432	endp
427	align 4	433
428	video_free:	434	align 4
429	pushfd	435	video_free:
430	cli	436	pushfd
431	sub eax, LFBAddress+CURSOR_IMAGE_OFFSET	437	cli
432	shr eax, 14	438	sub eax, LFBAddress+CURSOR_IMAGE_OFFSET
433	mov ebx, cursor_map	439	shr eax, 14
434	bts [ebx], eax	440	mov ebx, cursor_map
435	shr eax, 3	441	bts [ebx], eax
436	and eax, not 3	442	shr eax, 3
437	add eax, ebx	443	and eax, not 3
438	cmp [cursor_start], eax	444	add eax, ebx
439	ja @f	445	cmp [cursor_start], eax
440	popfd	446	ja @f
441	ret	447	popfd
442	@@:	448	ret
443	mov [cursor_start], eax	449	@@:
444	popfd	450	mov [cursor_start], eax
445	ret	451	popfd
446		452	ret
447	; param	453
448	; eax= pid	454	; param
449	; ebx= src	455	; eax= pid
450	; ecx= flags	456	; ebx= src
451		457	; ecx= flags
452	align 4	458
453	ati_cursor:	459	align 4
454	.src equ esp	460	ati_cursor:
455	.flags equ esp+4	461	.src equ esp
456	.hcursor equ esp+8	462	.flags equ esp+4
457		463	.hcursor equ esp+8
458	sub esp, 4 ;space for .hcursor	464
459	push ecx	465	sub esp, 4 ;space for .hcursor
460	push ebx	466	push ecx
461		467	push ebx
462	mov ebx, eax	468
463	mov eax, CURSOR_SIZE	469	mov ebx, eax
464	call CreateObject	470	mov eax, CURSOR_SIZE
465	test eax, eax	471	call CreateObject
466	jz .fail	472	test eax, eax
467		473	jz .fail
468	mov [.hcursor],eax	474
469		475	mov [.hcursor],eax
470	xor ebx, ebx	476
471	mov [eax+CURSOR.magic], 'CURS'	477	xor ebx, ebx
472	mov [eax+CURSOR.destroy], destroy_cursor	478	mov [eax+CURSOR.magic], 'CURS'
473	mov [eax+CURSOR.hot_x], ebx	479	mov [eax+CURSOR.destroy], destroy_cursor
474	mov [eax+CURSOR.hot_y], ebx	480	mov [eax+CURSOR.hot_x], ebx
475		481	mov [eax+CURSOR.hot_y], ebx
476	call video_alloc	482
477	mov edi, [.hcursor]	483	call video_alloc
478	mov [edi+CURSOR.base], eax	484	mov edi, [.hcursor]
479		485	mov [edi+CURSOR.base], eax
480	mov esi, [.src]	486
481	mov ebx, [.flags]	487	mov esi, [.src]
482	cmp bx, LOAD_INDIRECT	488	mov ebx, [.flags]
483	je .indirect	489	cmp bx, LOAD_INDIRECT
484		490	je .indirect
485	movzx ecx, word [esi+10]	491
486	movzx edx, word [esi+12]	492	movzx ecx, word [esi+10]
487	mov [edi+CURSOR.hot_x], ecx	493	movzx edx, word [esi+12]
488	mov [edi+CURSOR.hot_y], edx	494	mov [edi+CURSOR.hot_x], ecx
489		495	mov [edi+CURSOR.hot_y], edx
490	stdcall ati_init_cursor, eax, esi	496
491	mov eax, [.hcursor]	497	stdcall ati_init_cursor, eax, esi
492	.fail:	498	mov eax, [.hcursor]
493	add esp, 12	499	.fail:
494	ret	500	add esp, 12

Subversion Repositories Kolibri OS

(root)/kernel/trunk/drivers/ati2d.asm – Rev 425 → 431