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

Subversion Repositories Kolibri OS

(root)/kernel/branches/flat_kernel/drivers/ati2d.asm – Rev 444 → 462