WebSVN – Kolibri OS – Diff – /kernel/branches/flat_kernel/drivers/ati2d.asm


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