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

Subversion Repositories Kolibri OS

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