Subversion Repositories Kolibri OS

; RDC M2010/M2012 video driver.

; Standard driver stuff

format PE DLL native at 0

entry start

__DEBUG__ equ 1

__DEBUG_LEVEL__ equ 1

section '.flat' readable writable executable

include '../proc32.inc'

include '../struct.inc'

include '../macros.inc'

include '../fdo.inc'

; Display-specific driver stuff

; Kernel passes to init_cursor cursors with fixed size 32x32

KERNEL_CURSOR_WIDTH = 32

KERNEL_CURSOR_HEIGHT = 32

; Constants for IOCTL codes

SRV_GETVERSION = 0

SRV_ENUM_MODES = 1

SRV_SET_MODE   = 2

; Constants for SRV_GETVERSION result

CURRENT_API     = 0x0200

COMPATIBLE_API  = 0x0100

API_VERSION     = (COMPATIBLE_API shl 16) + CURRENT_API

struct  RWSEM

        wait_list       LHEAD

        count           dd ?

ends

; Some structures

struct  display_t

        x               dd ?

        y               dd ?

        width           dd ?

        height          dd ?

        bits_per_pixel  dd ?

        vrefresh        dd ?

        lfb             dd ?

        lfb_pitch       dd ?

        win_map_lock    RWSEM

        win_map         dd ?

        win_map_pitch   dd ?

        win_map_size    dd ?

        modes           dd ?

        ddev            dd ?

        connector       dd ?

        crtc            dd ?

        cr_list.next    dd ?

        cr_list.prev    dd ?

        cursor          dd ?

        init_cursor     dd ?

        select_cursor   dd ?

        show_cursor     dd ?

        move_cursor     dd ?

        restore_cursor  dd ?

        disable_mouse   dd ?

        mask_seqno      dd ?

        check_mouse     dd ?

        check_m_pixel   dd ?

        bytes_per_pixel dd ?

ends

struct  APPOBJ                  ; common object header

        magic           dd ?    ;

        destroy         dd ?    ; internal destructor

        fd              dd ?    ; next object in list

        bk              dd ?    ; prev object in list

        pid             dd ?    ; owner id

ends

struct  CURSOR          APPOBJ

        base            dd ?   ;allocated memory

        hot_x           dd ?   ;hotspot coords

        hot_y           dd ?

        list_next       dd ?   ;next cursor in cursor list

        list_prev       dd ?   ;prev cursor in cursor list

        dev_obj         dd ?   ;device depended data

ends

; Constants specific to our drivers

; We are handling two videocards: M2010 and M2012

PCI_VENDOR_RDC          = 0x17F3

; I like this approach to select device IDs!

PCI_CHIP_M2010          = 0x2010

PCI_CHIP_M2012          = 0x2012

; I/O ports for CRT registers

COLOR_CRTC_INDEX        = 0x3D4

COLOR_CRTC_DATA         = 0x3D5

; The value that unlocks extended CRT registers:

; index 0x80, value 0xA8

ENABLE_EXTENDED_REGS    = 0xA880

; Hardware cursors have size 64x64

HW_CURSOR_WIDTH = 64

HW_CURSOR_HEIGHT = 64

; Multiplication to powers of two can be replaced with shifts,

; x*HW_CURSOR_WIDTH = x shl HW_CURSOR_WIDTH_SHIFT

HW_CURSOR_WIDTH_SHIFT = 6

HW_CURSOR_HEIGHT_SHIFT = 6

; MMIO registers responsible for hardware cursor, see PRM

HWC_MMIO_CTRL           = 0x580

HWC_MMIO_OFFSET         = 0x584

HWC_MMIO_POSITION       = 0x588

HWC_MMIO_ADDRESS        = 0x58C

; Data for hardware cursors must be stored in videomemory,

; so we need an allocator for objects inside videomemory.

; Currently, we just reserve a fixed amount of memory for cursors

; (cursor size is the same for all cursors) and keep a bitfield

; that describes free blocks. 32 bits fit nicely in one dword.

MAX_CURSORS = 32

; === Entry points for external code ===

; Called once when driver is loading and once at shutdown.

; When loading, must initialize itself, register itself in the system

; and return eax = value obtained when registering.

; Cdecl with two parameters.

proc start

        push    ebx esi ; save used registers to be stdcall

virtual at esp

                rd      2 ; saved registers

                dd      ? ; return address

.reason         dd      ? ; DRV_ENTRY or DRV_EXIT

.cmdline        dd      ? ; normally NULL

end virtual

; 1. Check the reason for the call, do nothing unless initializing.

        cmp     [.reason], DRV_ENTRY

        jnz     .nothing

; 2. Find the PCI device for our videocard.

; If not found, just return zero.

        invoke  GetPCIList

        mov     ebx, eax

.look_pcidev_loop:

        mov     ebx, [ebx+PCIDEV.fd]

        cmp     ebx, eax

        jz      .pcidev_notfound

        cmp     [ebx+PCIDEV.vendor_device_id], PCI_VENDOR_RDC + (PCI_CHIP_M2010 shl 16)

        jz      .pcidev_found

        cmp     [ebx+PCIDEV.vendor_device_id], PCI_VENDOR_RDC + (PCI_CHIP_M2012 shl 16)

        jnz     .look_pcidev_loop

.pcidev_found:

; 3. Get addresses, sizes and pointers from the hardware.

; 3a. Create mapping for MMIO.

        invoke  PciRead32, dword [ebx+PCIDEV.bus], dword [ebx+PCIDEV.devfn], 14h

        and     al, not 0xF

        invoke  MapIoMem, eax, 10000h, PG_NOCACHE+PG_SW

        test    eax, eax

        jz      .nothing

        mov     [mmio], eax

; 3b. Get videomemory size. It is stored in 3 lower bits of 0xAA extended register

; logarithmically started with 8Mb.

        mov     dx, COLOR_CRTC_INDEX

        mov     ax, ENABLE_EXTENDED_REGS

        out     dx, ax

        mov     al, 0xAA

        out     dx, al

        inc     edx

        in      al, dx

        and     eax, 7

        mov     ecx, eax

        mov     eax, 8 shl 20

        shl     eax, cl

        mov     [video_mem_size], eax

; 3c. Reserve area for cursors in the last part of videomemory.

        sub     eax, MAX_CURSORS * HW_CURSOR_WIDTH * HW_CURSOR_HEIGHT * 4

        mov     [cursors_base_offset], eax

; 3d. Create mapping for part of videomemory that we have reserved for cursors.

; Note: we can't just use system-wide mapping at 0xFE000000, it is too short.

        invoke  PciRead32, dword [ebx+PCIDEV.bus], dword [ebx+PCIDEV.devfn], 10h

        and     al, not 0xF

        add     eax, [cursors_base_offset]

        invoke  MapIoMem, eax, MAX_CURSORS * HW_CURSOR_WIDTH * HW_CURSOR_HEIGHT * 4, PG_SW

        test    eax, eax

        jz      .nothing

        mov     [cursors_base_va], eax

; 4. Install cursor handlers.

; 4a. Get pointer to the structure that keeps everything display-related.

        invoke  GetDisplay

        mov     ebx, eax

; 4b. Make sure that no one tries to use partially-changed structure.

        pushf

        cli

; 4c. Ask the previous handler to restore image hidden beyond cursor.

        stdcall [ebx+display_t.restore_cursor], 0, 0

; 4d. Store pointers to our functions.

        mov     [ebx+display_t.init_cursor], init_cursor

        mov     [ebx+display_t.select_cursor], select_cursor

        mov     [ebx+display_t.show_cursor], 0

        mov     [ebx+display_t.move_cursor], move_cursor

        mov     [ebx+display_t.restore_cursor], restore_cursor

        mov     [ebx+display_t.disable_mouse], disable_mouse

; 4e. The kernel will pass all new cursors to our init_cursor,

; but we must process already created cursors ourselves to be able to

; select_cursor them when requested. Do it now: pass every cursor

; in the list display_t.cr_list to init_cursor.

        add     ebx, display_t.cr_list.next

        mov     esi, ebx

.init_old_cursors_loop:

        mov     esi, [esi]

        cmp     esi, ebx

        jz      .init_old_cursors_done

        lea     eax, [esi-CURSOR.list_next]

        push    eax

        call    init_cursor

        pop     eax

        jmp     .init_old_cursors_loop

.init_old_cursors_done:

; 4f. Setup the current cursor.

        stdcall move_cursor, [ebx+display_t.cursor-display_t.cr_list.next], 0, 0

        stdcall select_cursor, [ebx+display_t.cursor-display_t.cr_list.next]

; 4g. It is safe now to work with display structure; restore after 4b.

        popf

; 5. Say something happy to the (curious) user.

        mov     esi, success_msg

        invoke  SysMsgBoardStr

; 6. Register ourselves as a service.

; Note: not really needed currently as we don't do any useful in ioctl_handler,

; but do it nevertheless for future expansion.

        invoke  RegService, rdc_name, ioctl_handler

.nothing:

        pop     esi ebx ; restore used registers to be stdcall

        ret

.pcidev_notfound:

        xor     eax, eax

        jmp     .nothing

endp

; Service procedure for the driver - handle all IOCTL requests for the driver.

; Stdcall with one parameter.

proc ioctl_handler

virtual at esp

                dd      ?       ; return address

.ioctl          dd      ?

end virtual

; Not very useful currently - just return API_VERSION as a response to SRV_GETVERSION = 0.

        mov     edx, [.ioctl]

        mov     eax, [edx+IOCTL.io_code]

        test    eax, eax

        jz      .getversion

.error:

        or      eax, -1         ; fail everything unknown

        retn    4

.getversion:

        cmp     [edx+IOCTL.out_size], 4

        jnz     .error

        mov     eax, [edx+IOCTL.output]

        mov     dword [eax], API_VERSION

        xor     eax, eax

        retn    4

endp

; === Cursors ===

; This function is called when an application registers a new cursor.

; Cdecl with one parameter, return value ignored.

proc init_cursor

        push    esi edi

virtual at esp

                rd      2       ; saved registers

                dd      ?       ; return address

.cursor         dd      ?

end virtual

; We store one specific dword in CURSOR.dev_obj,

; index in cursors area from 0 to NUM_CURSORS-1, or -1 for error.

; 1. Prepare: store -1 to CURSOR.dev_obj and pointer to destroy function.

        mov     edx, [.cursor]

        mov     [edx+CURSOR.dev_obj], -1

        mov     [edx+CURSOR.destroy], destroy_cursor

; 2. Allocate videomemory.

        bsr     edi, [free_cursors]

        jz      .nocopy

        btr     [free_cursors], edi

; 3. Store the allocated item to CURSOR.dev_obj.

        mov     [edx+CURSOR.dev_obj], edi

; 4. Copy data from kernel-provided cursor to videomemory,

; transforming KERNEL_CURSOR_WIDTH*KERNEL_CURSOR_HEIGHT*(4 bytes RGBA) to

; HW_CURSOR_WIDTH*HW_CURSOR_HEIGHT*(4 bytes RGBA).

        shl     edi, HW_CURSOR_WIDTH_SHIFT + HW_CURSOR_HEIGHT_SHIFT + 2

        add     edi, [cursors_base_va]

        mov     esi, [edx+CURSOR.base]

        push    KERNEL_CURSOR_HEIGHT

        xor     eax, eax

@@:

        mov     ecx, KERNEL_CURSOR_WIDTH

        rep movsd

        mov     ecx, HW_CURSOR_WIDTH - KERNEL_CURSOR_WIDTH

        rep stosd

        dec     dword [esp]

        jnz     @b

        pop     ecx

        mov     ecx, HW_CURSOR_WIDTH * (HW_CURSOR_HEIGHT - KERNEL_CURSOR_HEIGHT)

        rep stosd

.nocopy:

; 5. We don't need kernel-provided data anymore; free it now.

        invoke  KernelFree, [edx+CURSOR.base]

        pop     edi esi

        ret

endp

; This function is called when a thread that has created a cursor

; is terminating and we need to free the cursor.

proc destroy_cursor

; 1. Free allocated videomemory.

        mov     edx, [eax+CURSOR.dev_obj]

        test    edx, edx

        js      .nofree

        bts     [free_cursors], edx

.nofree:

; 2. Remove the cursor from the overall list at display_t.cr_list.

        pushf

        cli

        mov     ecx, [eax+CURSOR.list_next]

        mov     edx, [eax+CURSOR.list_prev]

        mov     [ecx+4], edx

        mov     [edx], ecx

        popf

; 3. Free memory allocated for kernel object.

        jmp     [DestroyObject]

endp

; This function is called when cursor shape needs to be changed,

; either due to explicit request from application

; or due to moving from one window to another.

; Stdcall with one parameter, return value ignored.

proc select_cursor

virtual at esp

                dd      ?       ; return address

.cursor         dd      ?

end virtual

        mov     eax, [.cursor]

        mov     eax, [eax+CURSOR.dev_obj]

        cmp     eax, -1

        jz      .nothing

; Setup base address of cursor, relative to videomemory,

; and enable hardware cursor.

; See PRM for details.

        shl     eax, HW_CURSOR_WIDTH_SHIFT + HW_CURSOR_HEIGHT_SHIFT + 2

        add     eax, [cursors_base_offset]

        shr     eax, 3

        mov     edx, [mmio]

        mov     [edx+HWC_MMIO_ADDRESS], eax

        mov     dword [edx+HWC_MMIO_CTRL], (1 shl 31) + (1 shl 1) + (1 shl 0)

.nothing:

        ret     4

endp

; This function is called when cursor is moved to a new place.

; Stdcall with three parameters, return value ignored.

proc move_cursor

virtual at esp

                dd      ?       ; return address

.cursor         dd      ?

.x              dd      ?

.y              dd      ?

.xoffset        dd      ?

.yoffset        dd      ?

end virtual

; If cursor x is smaller than hotspot x,

; only part of cursor is shown at position x=0

; with x offset = (hotspot x) - (cursor x).

; Otherwise, the entire cursor is shown (x offset = 0)

; at position x = (cursor x) - (hotspot x).

; Similar for y. Refer to PRM for details.

        xor     ecx, ecx

        mov     edx, [.cursor]

        mov     eax, [.x]

        sub     eax, [edx+CURSOR.hot_x]

        jae     @f

        sub     ecx, eax

        xor     eax, eax

@@:

        mov     [.x], eax

        mov     eax, [.y]

        sub     eax, [edx+CURSOR.hot_y]

        jae     @f

        shl     eax, 8

        sub     ecx, eax

        xor     eax, eax

@@:

        mov     [.y], eax

        mov     edx, [mmio]

        mov     eax, [.y]

        add     eax, HW_CURSOR_HEIGHT - 1       ; no scaling

        shl     eax, 16

        add     eax, ecx

        mov     [edx+HWC_MMIO_OFFSET], eax

        mov     eax, [.y]

        shl     eax, 16

        add     eax, [.x]

        mov     [edx+HWC_MMIO_POSITION], eax

        mov     eax, [edx+HWC_MMIO_CTRL]

        mov     [edx+HWC_MMIO_CTRL], eax

        ret     12

endp

; Stdcall with two parameters, return value ignored.

proc restore_cursor

; No-operation for hardware cursors.

        ret     8

endp

; No parameters, return value ignored.

proc disable_mouse

; No-operation for hardware cursors.

        ret

endp

; === Data ===

rdc_name db 'DISPLAY',0

success_msg db 'RDC: using hardware cursors',13,10,0

align 4

; Look at the comment before definition of NUM_CURSORS.

free_cursors    dd      0xFFFFFFFF

data fixups

end data

include '../peimport.inc'

;include_debug_strings

IncludeIGlobals

IncludeUGlobals

align 4

mmio            dd      ?       ; virtual address of MMIO for our device

video_mem_size  dd      ?       ; total size of video memory, in bytes

cursors_base_offset     dd      ?       ; base of cursor data, relative to video memory start

cursors_base_va         dd      ?       ; mapped virtual address of cursor data