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'
 
R500_HW2D       equ 0
 
API_VERSION     equ 0x01000100
 
DEBUG           equ 1
 
STRIDE          equ 8
 
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
 
OS_BASE         equ 0x80000000
SLOT_BASE       equ (OS_BASE+0x0080000)
LFB_BASE        equ 0xFE000000
 
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
}
 
macro rmask dest, val, mask
{
     mov edi, [ati_io]
     mov eax, [edi+dest]
     and eax, not mask
     or eax, (val and mask)
     mov [edi+dest], eax
}
 
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 .restore
 
     if DEBUG
           mov esi, msgInit
           call SysMsgBoardStr
     end if
 
           call detect_ati
           test eax, eax
           jz .fail
 
           mov ebx, [SelectHwCursor]
           mov ecx, [SetHwCursor]
           mov edx, [HwCursorRestore]
           mov esi, [HwCursorCreate]
 
           mov [oldSelect], ebx
           mov [oldSet], ecx
           mov [oldRestore], edx
           mov [oldCreate], esi
 
           call eax
 
           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 .restore
 
if R500_HW2D
           stdcall RegService, sz_HDraw_srv, r500_HDraw
 
           mov ebx, START
           and ebx, -4096
           mov [eax+0x20], ebx
           mov [eax+0x24], dword 0                       ;hack
end if
           mov ebx, [fnSelect]
           mov ecx, [fnSet]
 
           mov [SelectHwCursor], ebx
           mov [SetHwCursor], ecx
           mov dword [HwCursorRestore], drv_restore
           mov dword [HwCursorCreate], ati_cursor
 
           ret
.restore:
           mov eax, [oldSelect]
           mov ebx, [oldSet]
           mov ecx, [oldRestore]
           mov edx, [oldCreate]
 
           mov [SelectHwCursor], eax
           mov [SetHwCursor], ebx
           mov [HwCursorRestore], ecx
           mov [HwCursorCreate], edx
 
           xor eax, eax
           ret
 
.fail:
     if DEBUG
           mov esi, msgFail
           call SysMsgBoardStr
     end if
 
           xor eax, eax
           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, STRIDE
           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:
           mov eax, [edi+4]
           ret
.err:
           xor eax, eax
           ret
endp
 
align 4
proc init_r200
           stdcall PciRead32, [bus], [devfn], dword 0x18
           stdcall MapIoMem,eax,0x10000,(PG_SW+PG_NOCACHE)
           test eax, eax
           jz .fail
 
           mov [ati_io], eax
           mov edi, eax
 
           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 r200_ShowCursor
 
           mov [fnSelect], r200_SelectCursor
           mov [fnSet], r200_SetCursor
 
           xor eax, eax
           inc eax
.fail:
           ret
endp
 
if R500_HW2D
  include 'r500hw.inc'
end if
 
align 4
proc init_r500
 
           stdcall PciRead32, [bus], [devfn], dword 0x18
           stdcall MapIoMem,eax,0x10000,(PG_SW+PG_NOCACHE)
           test eax, eax
           jz .fail
 
           mov [ati_io], eax
 
           mov [fnSelect], r500_SelectCursor
           mov [fnSet], r500_SetCursor
 
           rdr eax, 0x6110
           mov [r500_LFB], eax
 
if R500_HW2D
           call R5xx2DInit
end if
           wrr 0x6410, 0x001F001F
           wrr 0x6400, dword (3 shl 8)
 
           xor eax, eax
           inc eax
.fail:
           ret
endp
 
 
align 4
drv_restore:
           ret 8
 
 
align 4
proc r500_SelectCursor stdcall,hcursor:dword
 
           mov esi, [hcursor]
 
           mov edx, [esi+CURSOR.base]
           sub edx, LFB_BASE
           add edx, [r500_LFB]
           wrr 0x6408, edx
 
           mov eax, [esi+CURSOR.hot_x]
           shl eax, 16
           mov ax, word [esi+CURSOR.hot_y]
           wrr 0x6418, eax
           ret
endp
 
align 4
proc r500_SetCursor stdcall, hcursor:dword, x:dword, y:dword
           pushfd
           cli
 
           mov esi, [hcursor]
           mov edi, [ati_io]
 
           mov eax, [x]
           shl eax, 16
           mov ax, word [y]
 
           mov [edi+0x6414], eax
           or dword [edi+0x6400], 1
 
if 0
           stdcall R5xxSetupForSolidFill, 0x80808080, 3, 0xFFFFFFFF
           stdcall R5xxSolidFillRect, 100,100, 100,100
 
           stdcall R5xxSetupForSolidFill, 0xFFFF0000, 3, 0xFFFFFFFF
           stdcall R5xxSolidFillRect, 110,110, 80,80
 
           stdcall R5xxSetupForSolidFill, 0xFF00FF00, 3, 0xFFFFFFFF
           stdcall R5xxSolidFillRect, 120,120, 60,60
 
           stdcall R5xxSetupForSolidFill, 0xFF0000FF, 3, 0xFFFFFFFF
           stdcall R5xxSolidFillRect, 130,130, 40,40
end if
 
           popfd
           ret
endp
 
align 4
r500_ShowCursor:
 
           mov edi, [ati_io]
           or dword [edi+0x6400], 1
           ret
 
align 4
r200_ShowCursor:
           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 r200_SelectCursor stdcall,hcursor:dword
 
           ret
endp
 
align 4
proc r200_SetCursor 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
dword2str:
      mov  esi, hex_buff
      mov ecx, -8
@@:
      rol eax, 4
      mov ebx, eax
      and ebx, 0x0F
      mov bl, [ebx+hexletters]
      mov [8+esi+ecx], bl
      inc ecx
      jnz @B
      ret
 
hexletters   db '0123456789ABCDEF'
hex_buff     db 8 dup(0),13,10,0
 
R200M       equ 0x5a62  ;R300
R7000       equ 0x5159  ;R200
R750M       equ 0x4c57  ;M7 mobile rv200
R8500       equ 0x514C  ;R200
R9000       equ 0x4966  ;RV250
R9200       equ 0x5961  ;RV280
R9200SE     equ 0x5964  ;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
 
 
align 4
 
devices:
        dd (R200M   shl 16)+VID_ATI, init_r200   ;R300
        dd (R7000   shl 16)+VID_ATI, init_r200
        dd (R750M   shl 16)+VID_ATI, init_r200   ;M7
        dd (R8500   shl 16)+VID_ATI, init_r200
        dd (R9000   shl 16)+VID_ATI, init_r200
        dd (0x514D  shl 16)+VID_ATI, init_r200   ;R200     9100
 
        dd (R9200   shl 16)+VID_ATI, init_r200
        dd (R9200SE shl 16)+VID_ATI, init_r200
 
        dd (0x5960  shl 16)+VID_ATI, init_r200   ;RV280    9250
 
        dd (R9500   shl 16)+VID_ATI, init_r200
        dd (R9500P  shl 16)+VID_ATI, init_r200
        dd (R9550   shl 16)+VID_ATI, init_r200
 
        dd (R9600   shl 16)+VID_ATI, init_r200
        dd (R9600XT shl 16)+VID_ATI, init_r200
        dd (0x4155  shl 16)+VID_ATI, init_r200   ;RV350    9600
        dd (0x4151  shl 16)+VID_ATI, init_r200   ;RV350    9600
        dd (0x4E51  shl 16)+VID_ATI, init_r200   ;RV350    9600
 
        dd (R9700P  shl 16)+VID_ATI, init_r200
 
        dd (0x4148  shl 16)+VID_ATI, init_r200   ;R350    9800
        dd (R9800   shl 16)+VID_ATI, init_r200
        dd (R9800P  shl 16)+VID_ATI, init_r200
        dd (R9800XT shl 16)+VID_ATI, init_r200
 
        dd (0x5B60  shl 16)+VID_ATI, init_r200   ;RV370    X300/X550
        dd (0x5B63  shl 16)+VID_ATI, init_r200   ;RV370    X550
        dd (0x5B62  shl 16)+VID_ATI, init_r200   ;RV380x   X600
        dd (0x3E50  shl 16)+VID_ATI, init_r200   ;RV380    X600/X550
 
        dd (0x5B4F  shl 16)+VID_ATI, init_r200   ;RV410    X700
        dd (0x5B4D  shl 16)+VID_ATI, init_r200   ;RV410    X700
        dd (0x5B4B  shl 16)+VID_ATI, init_r200   ;RV410    X700
        dd (0x5B4C  shl 16)+VID_ATI, init_r200   ;RV410    X700
 
        dd (0x4a49  shl 16)+VID_ATI, init_r200   ;R420     X800 PRO/GTO
        dd (0x4a4B  shl 16)+VID_ATI, init_r200   ;R420     X800
        dd (0x5549  shl 16)+VID_ATI, init_r200   ;R423     X800
        dd (0x4a4A  shl 16)+VID_ATI, init_r200   ;R420     X800
        dd (0x554F  shl 16)+VID_ATI, init_r200   ;R430     X800
        dd (0x554D  shl 16)+VID_ATI, init_r200   ;R430     X800
        dd (0x554E  shl 16)+VID_ATI, init_r200   ;R430     X800
        dd (0x5D57  shl 16)+VID_ATI, init_r200   ;R423     X800 XT
        dd (0x4A50  shl 16)+VID_ATI, init_r200   ;R420     X800 XT
        dd (0x554A  shl 16)+VID_ATI, init_r200   ;R423     X800 XT
        dd (0x5D4F  shl 16)+VID_ATI, init_r200   ;R423     X800/X850
        dd (0x554B  shl 16)+VID_ATI, init_r200   ;R423     X800 GT
 
        dd (0x4B4B  shl 16)+VID_ATI, init_r200   ;R481     X850
        dd (0x4B49  shl 16)+VID_ATI, init_r200   ;R481     X850
        dd (0x4B4C  shl 16)+VID_ATI, init_r200   ;R481     X850
 
        dd (0x5D4D  shl 16)+VID_ATI, init_r200   ;R480     X850
        dd (0x5D52  shl 16)+VID_ATI, init_r200   ;R480     X850
 
        dd (0x791E  shl 16)+VID_ATI, init_r500   ;RS690   X1200
 
        dd (0x7140  shl 16)+VID_ATI, init_r500   ;RV515   X1300
        dd (0x7142  shl 16)+VID_ATI, init_r500   ;RV515   X1300
        dd (0x7146  shl 16)+VID_ATI, init_r500   ;RV515   X1300
        dd (0x714D  shl 16)+VID_ATI, init_r500   ;RV515   X1300
        dd (0x714E  shl 16)+VID_ATI, init_r500   ;RV515   X1300
 
        dd (0x7183  shl 16)+VID_ATI, init_r500   ;RV515   X1300
        dd (0x7187  shl 16)+VID_ATI, init_r500   ;RV515   X1300
        dd (0x718F  shl 16)+VID_ATI, init_r500   ;RV515   X1300
 
        dd (0x7143  shl 16)+VID_ATI, init_r500   ;RV515   X1550
        dd (0x7147  shl 16)+VID_ATI, init_r500   ;RV515   X1550
        dd (0x715F  shl 16)+VID_ATI, init_r500   ;RV515   X1550
        dd (0x7193  shl 16)+VID_ATI, init_r500   ;RV515   X1550
        dd (0x719F  shl 16)+VID_ATI, init_r500   ;RV515   X1550
 
        dd (0x71C0  shl 16)+VID_ATI, init_r500   ;RV530   X1600
        dd (0x71C1  shl 16)+VID_ATI, init_r500   ;RV535   X1650
        dd (0x71C2  shl 16)+VID_ATI, init_r500   ;RV530   X1600
        dd (0x71C3  shl 16)+VID_ATI, init_r500   ;RV535   X1600
        dd (0x71C6  shl 16)+VID_ATI, init_r500   ;RV530   X1600
        dd (0x71C7  shl 16)+VID_ATI, init_r500   ;RV534   X1650
 
        dd (0x7181  shl 16)+VID_ATI, init_r500   ;RV515   X1600
        dd (0x71CD  shl 16)+VID_ATI, init_r500   ;RV530   X1600
 
        dd (0x7291  shl 16)+VID_ATI, init_r500   ;R580    X1650
        dd (0x7293  shl 16)+VID_ATI, init_r500   ;R580    X1650
 
        dd (0x7100  shl 16)+VID_ATI, init_r500   ;RV520   X1800
        dd (0x7109  shl 16)+VID_ATI, init_r500   ;RV520   X1800
        dd (0x710A  shl 16)+VID_ATI, init_r500   ;RV520   X1800 GTO
 
        dd (0x7249  shl 16)+VID_ATI, init_r500   ;RV580   X1900
        dd (0x724B  shl 16)+VID_ATI, init_r500   ;RV580   X1900 GT
 
        dd (0x7240  shl 16)+VID_ATI, init_r500   ;RV580   X1950
        dd (0x7244  shl 16)+VID_ATI, init_r500   ;RV580   X1950
        dd (0x7248  shl 16)+VID_ATI, init_r500   ;RV580   X1950
 
        dd (0x7288  shl 16)+VID_ATI, init_r500   ;R580    X1950 GT
        dd (0x7280  shl 16)+VID_ATI, init_r500   ;R580    X1950 PRO
 
        dd (0x94C3  shl 16)+VID_ATI, init_r500   ;RV610   HD 2400 PRO
        dd (0x94C1  shl 16)+VID_ATI, init_r500   ;RV610   HD 2400 XT
 
        dd (0x9589  shl 16)+VID_ATI, init_r500   ;RV630   HD 2600 PRO
        dd (0x958A  shl 16)+VID_ATI, init_r500   ;RV630   HD 2600 X2
        dd (0x9588  shl 16)+VID_ATI, init_r500   ;RV630   HD 2600 XT
 
        dd (0x9403  shl 16)+VID_ATI, init_r500   ;R600    HD 2900 PRO
        dd (0x9409  shl 16)+VID_ATI, init_r500   ;R600    HD 2900 XT
 
 
        dd 0    ;terminator
 
version      dd (5 shl 16) or (API_VERSION and 0xFFFF)
 
if R500_HW2D
 
align 16
R5xxRops  dd R5XX_ROP3_ZERO, R5XX_ROP3_ZERO  ;GXclear
          dd R5XX_ROP3_DSa,  R5XX_ROP3_DPa   ;Gxand
          dd R5XX_ROP3_SDna, R5XX_ROP3_PDna  ;GXandReverse
          dd R5XX_ROP3_S,    R5XX_ROP3_P     ;GXcopy
          dd R5XX_ROP3_DSna, R5XX_ROP3_DPna  ;GXandInverted
          dd R5XX_ROP3_D,    R5XX_ROP3_D     ;GXnoop
          dd R5XX_ROP3_DSx,  R5XX_ROP3_DPx   ;GXxor
          dd R5XX_ROP3_DSo,  R5XX_ROP3_DPo   ;GXor
          dd R5XX_ROP3_DSon, R5XX_ROP3_DPon  ;GXnor
          dd R5XX_ROP3_DSxn, R5XX_ROP3_PDxn  ;GXequiv
          dd R5XX_ROP3_Dn,   R5XX_ROP3_Dn    ;GXinvert
          dd R5XX_ROP3_SDno, R5XX_ROP3_PDno  ;GXorReverse
          dd R5XX_ROP3_Sn,   R5XX_ROP3_Pn    ;GXcopyInverted
          dd R5XX_ROP3_DSno, R5XX_ROP3_DPno  ;GXorInverted
          dd R5XX_ROP3_DSan, R5XX_ROP3_DPan  ;GXnand
          dd R5XX_ROP3_ONE,  R5XX_ROP3_ONE   ;GXset
end if
 
 
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
 
if R500_HW2D
 
sz_HDraw_srv db 'HDRAW',0
 
msgR5xx2DFlushtimeout \
             db 'R5xx2DFlush timeout error',13,10,0
msgR5xxFIFOWaitLocaltimeout \
             db 'R5xxFIFOWaitLocal timeout error', 13, 10,0
msgR5xx2DIdleLocaltimeout \
             db 'R5xx2DIdleLocal timeout error', 13,10,0
end if
 
if 0
msg6100      db '6100:  ',0
msg6104      db '6104:  ',0
msg6108      db '6108:  ',0
msg6110      db '6110:  ',0
msg6120      db '6120:  ',0
msg6124      db '6124:  ',0
msg6128      db '6128:  ',0
msg612C      db '612C:  ',0
msg6130      db '6130:  ',0
msg6134      db '6134:  ',0
msg6138      db '6138:  ',0
end if
 
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
 
fnSelect       rd 1
fnSet          rd 1
oldSelect      rd 1
oldSet         rd 1
oldRestore     rd 1
oldCreate      rd 1
 
r500_LFB       rd 1
 
bus            dd ?
devfn          dd ?
ati_io         dd ?
 
if R500_HW2D
 
__xmin         rd 1
__xmax         rd 1
__ymin         rd 1
__ymax         rd 1
 
rhd            RHD
 
end if

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/drivers/ati2d.asm – Rev 741 → 749