video.S file in linux source - Linux

This is a discussion on video.S file in linux source - Linux ; hello i need to load another language font in the begining of linux kernel in order to view messeges in my language ,i loaded the font in the file video.S and then compiled the kernel 2.4.18 and i printed the ...

+ Reply to Thread
Results 1 to 2 of 2

Thread: video.S file in linux source

  1. video.S file in linux source

    hello
    i need to load another language font in the begining of linux kernel in
    order to view messeges in my language ,i loaded the font in the file
    video.S and then compiled the kernel 2.4.18 and i printed the messege
    in other language than english but it stopped after printing my
    messeges so can any one help telling me where is the error and why the
    file video.S didnt complete loading .

    here is the file video.S after editting it and the font file called
    myfont

    /* video.S
    *
    * Display adapter & video mode setup, version 2.13 (14-May-99)
    *
    * Copyright (C) 1995 -- 1998 Martin Mares
    * Based on the original setup.S code (C) Linus Torvalds and Mats
    Anderson
    *
    * Rewritten to use GNU 'as' by Chris Noe May
    1999
    *
    * For further information, look at Documentation/svga.txt.
    *
    */

    #include /* for CONFIG_VIDEO_* */

    /* Enable autodetection of SVGA adapters and modes. */
    #undef CONFIG_VIDEO_SVGA

    /* Enable autodetection of VESA modes */
    #define CONFIG_VIDEO_VESA

    /* Enable compacting of mode table */
    #define CONFIG_VIDEO_COMPACT

    /* Retain screen contents when switching modes */
    #define CONFIG_VIDEO_RETAIN

    /* Enable local mode list */
    #undef CONFIG_VIDEO_LOCAL

    /* Force 400 scan lines for standard modes (hack to fix bad BIOS
    behaviour */
    #undef CONFIG_VIDEO_400_HACK

    /* Hack that lets you force specific BIOS mode ID and specific
    dimensions */
    #undef CONFIG_VIDEO_GFX_HACK
    #define VIDEO_GFX_BIOS_AX 0x4f02 /* 800x600 on ThinkPad */
    #define VIDEO_GFX_BIOS_BX 0x0102
    #define VIDEO_GFX_DUMMY_RESOLUTION 0x6425 /* 100x37 */

    /* This code uses an extended set of video mode numbers. These include:
    * Aliases for standard modes
    * NORMAL_VGA (-1)
    * EXTENDED_VGA (-2)
    * ASK_VGA (-3)
    * Video modes numbered by menu position -- NOT RECOMMENDED because of
    lack
    * of compatibility when extending the table. These are between 0x00
    and 0xff.
    */
    #define VIDEO_FIRST_MENU 0x0000

    /* Standard BIOS video modes (BIOS number + 0x0100) */
    #define VIDEO_FIRST_BIOS 0x0100

    /* VESA BIOS video modes (VESA number + 0x0200) */
    #define VIDEO_FIRST_VESA 0x0200

    /* Video7 special modes (BIOS number + 0x0900) */
    #define VIDEO_FIRST_V7 0x0900

    /* Special video modes */
    #define VIDEO_FIRST_SPECIAL 0x0f00
    #define VIDEO_80x25 0x0f00
    #define VIDEO_8POINT 0x0f01
    #define VIDEO_80x43 0x0f02
    #define VIDEO_80x28 0x0f03
    #define VIDEO_CURRENT_MODE 0x0f04
    #define VIDEO_80x30 0x0f05
    #define VIDEO_80x34 0x0f06
    #define VIDEO_80x60 0x0f07
    #define VIDEO_GFX_HACK 0x0f08
    #define VIDEO_LAST_SPECIAL 0x0f09

    /* Video modes given by resolution */
    #define VIDEO_FIRST_RESOLUTION 0x1000

    /* The "recalculate timings" flag */
    #define VIDEO_RECALC 0x8000

    /* Positions of various video parameters passed to the kernel */
    /* (see also include/linux/tty.h) */
    #define PARAM_CURSOR_POS 0x00
    #define PARAM_VIDEO_PAGE 0x04
    #define PARAM_VIDEO_MODE 0x06
    #define PARAM_VIDEO_COLS 0x07
    #define PARAM_VIDEO_EGA_BX 0x0a
    #define PARAM_VIDEO_LINES 0x0e
    #define PARAM_HAVE_VGA 0x0f
    #define PARAM_FONT_POINTS 0x10

    #define PARAM_LFB_WIDTH 0x12
    #define PARAM_LFB_HEIGHT 0x14
    #define PARAM_LFB_DEPTH 0x16
    #define PARAM_LFB_BASE 0x18
    #define PARAM_LFB_SIZE 0x1c
    #define PARAM_LFB_LINELENGTH 0x24
    #define PARAM_LFB_COLORS 0x26
    #define PARAM_VESAPM_SEG 0x2e
    #define PARAM_VESAPM_OFF 0x30
    #define PARAM_LFB_PAGES 0x32
    #define PARAM_VESA_ATTRIB 0x34

    /* Define DO_STORE according to CONFIG_VIDEO_RETAIN */
    #ifdef CONFIG_VIDEO_RETAIN
    #define DO_STORE call store_screen
    #else
    #define DO_STORE
    #endif /* CONFIG_VIDEO_RETAIN */

    # This is the main entry point called by setup.S
    # %ds *must* be pointing to the bootsector
    video: pushw %ds # We use different segments
    pushw %ds # FS contains original DS
    popw %fs
    pushw %cs # DS is equal to CS
    popw %ds
    pushw %cs # ES is equal to CS
    popw %es
    xorw %ax, %ax
    movw %ax, %gs # GS is zero
    cld
    call basic_detect # Basic adapter type testing (EGA/VGA/MDA/CGA)
    #ifdef CONFIG_VIDEO_SELECT
    movw %fs0x01fa), %ax # User selected video mode
    cmpw $ASK_VGA, %ax # Bring up the menu
    leaw me , %si # "Return/Space/Timeout" message
    call prtstr
    jz vid2
    leaw me , %si # "Return/Space/Timeout" message
    call prtstr
    call mode_set # Set the mode
    jc vid1

    leaw badmdt, %si # Invalid mode ID
    call prtstr
    vid2: call mode_menu
    vid1:
    #ifdef CONFIG_VIDEO_RETAIN
    call restore_screen # Restore screen contents
    #endif /* CONFIG_VIDEO_RETAIN */
    call store_edid
    #endif /* CONFIG_VIDEO_SELECT */
    call mode_params # Store mode parameters
    popw %ds # Restore original DS
    ret

    # Detect if we have CGA, MDA, EGA or VGA and pass it to the kernel.
    basic_detect:
    movb $0, %fsPARAM_HAVE_VGA)
    movb $0x12, %ah # Check EGA/VGA
    movb $0x10, %bl
    int $0x10
    movw %bx, %fsPARAM_VIDEO_EGA_BX) # Identifies EGA to the kernel
    cmpb $0x10, %bl # No, it's a CGA/MDA/HGA card.
    je basret

    incb adapter
    movw $0x1a00, %ax # Check EGA or VGA?
    int $0x10
    cmpb $0x1a, %al # 1a means VGA...
    jne basret # anything else is EGA.

    incb %fsPARAM_HAVE_VGA) # We've detected a VGA
    incb adapter
    basret: ret

    # Store the video mode parameters for later usage by the kernel.
    # This is done by asking the BIOS except for the rows/columns
    # parameters in the default 80x25 mode -- these are set directly,
    # because some very obscure BIOSes supply insane values.
    mode_params:
    #ifdef CONFIG_VIDEO_SELECT
    cmpb $0, graphic_mode
    jnz mopar_gr
    #endif
    movb $0x03, %ah # Read cursor position
    xorb %bh, %bh
    int $0x10
    movw %dx, %fsPARAM_CURSOR_POS)
    movb $0x0f, %ah # Read page/mode/width
    int $0x10
    movw %bx, %fsPARAM_VIDEO_PAGE)
    movw %ax, %fsPARAM_VIDEO_MODE) # Video mode and screen width
    cmpb $0x7, %al # MDA/HGA => segment differs
    jnz mopar0

    movw $0xb000, video_segment
    mopar0: movw %gs0x485), %ax # Font size
    movw %ax, %fsPARAM_FONT_POINTS) # (valid only on EGA/VGA)
    movw force_size, %ax # Forced size?
    orw %ax, %ax
    jz mopar1

    movb %ah, %fsPARAM_VIDEO_COLS)
    movb %al, %fsPARAM_VIDEO_LINES)
    ret

    mopar1: movb $25, %al
    cmpb $0, adapter # If we are on CGA/MDA/HGA, the
    jz mopar2 # screen must have 25 lines.

    movb %gs0x484), %al # On EGA/VGA, use the EGA+ BIOS
    incb %al # location of max lines.
    mopar2: movb %al, %fsPARAM_VIDEO_LINES)
    ret

    #ifdef CONFIG_VIDEO_SELECT
    # Fetching of VESA frame buffer parameters
    mopar_gr:
    leaw modelist+1024, %di
    movb $0x23, %fsPARAM_HAVE_VGA)
    movw 16(%di), %ax
    movw %ax, %fsPARAM_LFB_LINELENGTH)
    movw 18(%di), %ax
    movw %ax, %fsPARAM_LFB_WIDTH)
    movw 20(%di), %ax
    movw %ax, %fsPARAM_LFB_HEIGHT)
    movb 25(%di), %al
    movb $0, %ah
    movw %ax, %fsPARAM_LFB_DEPTH)
    movb 29(%di), %al
    movb $0, %ah
    movw %ax, %fsPARAM_LFB_PAGES)
    movl 40(%di), %eax
    movl %eax, %fsPARAM_LFB_BASE)
    movl 31(%di), %eax
    movl %eax, %fsPARAM_LFB_COLORS)
    movl 35(%di), %eax
    movl %eax, %fsPARAM_LFB_COLORS+4)
    movw 0(%di), %ax
    movw %ax, %fsPARAM_VESA_ATTRIB)

    # get video mem size
    leaw modelist+1024, %di
    movw $0x4f00, %ax
    int $0x10
    xorl %eax, %eax
    movw 18(%di), %ax
    movl %eax, %fsPARAM_LFB_SIZE)

    # switching the DAC to 8-bit is for <= 8 bpp only
    movw %fsPARAM_LFB_DEPTH), %ax
    cmpw $8, %ax
    jg dac_done

    # get DAC switching capability
    xorl %eax, %eax
    movb 10(%di), %al
    testb $1, %al
    jz dac_set

    # attempt to switch DAC to 8-bit
    movw $0x4f08, %ax
    movw $0x0800, %bx
    int $0x10
    cmpw $0x004f, %ax
    jne dac_set
    movb %bh, dac_size # store actual DAC size

    dac_set:
    # set color size to DAC size
    movb dac_size, %al
    movb %al, %fsPARAM_LFB_COLORS+0)
    movb %al, %fsPARAM_LFB_COLORS+2)
    movb %al, %fsPARAM_LFB_COLORS+4)
    movb %al, %fsPARAM_LFB_COLORS+6)

    # set color offsets to 0
    movb $0, %fsPARAM_LFB_COLORS+1)
    movb $0, %fsPARAM_LFB_COLORS+3)
    movb $0, %fsPARAM_LFB_COLORS+5)
    movb $0, %fsPARAM_LFB_COLORS+7)

    dac_done:
    # get protected mode interface informations
    movw $0x4f0a, %ax
    xorw %bx, %bx
    xorw %di, %di
    int $0x10
    cmp $0x004f, %ax
    jnz no_pm

    movw %es, %fsPARAM_VESAPM_SEG)
    movw %di, %fsPARAM_VESAPM_OFF)
    no_pm: ret

    # The video mode menu
    mode_menu:
    leaw keymsg, %si # "Return/Space/Timeout" message
    call prtstr
    call flush
    nokey: call getkt

    cmpb $0x0d, %al # ENTER ?
    je listm # yes - manual mode selection

    cmpb $0x20, %al # SPACE ?
    je defmd1 # no - repeat

    call beep
    jmp nokey

    defmd1: ret # No mode chosen? Default 80x25

    listm: call mode_table # List mode table
    listm0: leaw name_bann, %si # Print adapter name
    call prtstr
    movw card_name, %si
    orw %si, %si
    jnz an2

    movb adapter, %al
    leaw old_name, %si
    orb %al, %al
    jz an1

    leaw ega_name, %si
    decb %al
    jz an1

    leaw vga_name, %si
    jmp an1

    an2: call prtstr
    leaw svga_name, %si
    an1: call prtstr
    leaw listhdr, %si # Table header
    call prtstr
    movb $0x30, %dl # DL holds mode number
    leaw modelist, %si
    lm1: cmpw $ASK_VGA, (%si) # End?
    jz lm2

    movb %dl, %al # Menu selection number
    call prtchr
    call prtsp2
    lodsw
    call prthw # Mode ID
    call prtsp2
    movb 0x1(%si), %al
    call prtdec # Rows
    movb $0x78, %al # the letter 'x'
    call prtchr
    lodsw
    call prtdec # Columns
    movb $0x0d, %al # New line
    call prtchr
    movb $0x0a, %al
    call prtchr
    incb %dl # Next character
    cmpb $0x3a, %dl
    jnz lm1

    movb $0x61, %dl
    jmp lm1

    lm2: leaw prompt, %si # Mode prompt
    call prtstr
    leaw edit_buf, %di # Editor buffer
    lm3: call getkey
    cmpb $0x0d, %al # Enter?
    jz lment

    cmpb $0x08, %al # Backspace?
    jz lmbs

    cmpb $0x20, %al # Printable?
    jc lm3

    cmpw $edit_buf+4, %di # Enough space?
    jz lm3

    stosb
    call prtchr
    jmp lm3

    lmbs: cmpw $edit_buf, %di # Backspace
    jz lm3

    decw %di
    movb $0x08, %al
    call prtchr
    call prtspc
    movb $0x08, %al
    call prtchr
    jmp lm3

    lment: movb $0, (%di)
    leaw crlft, %si
    call prtstr
    leaw edit_buf, %si
    cmpb $0, (%si) # Empty string = default mode
    jz lmdef

    cmpb $0, 1(%si) # One character = menu selection
    jz mnusel

    cmpw $0x6373, (%si) # "scan" => mode scanning
    jnz lmhx

    cmpw $0x6e61, 2(%si)
    jz lmscan

    lmhx: xorw %bx, %bx # Else => mode ID in hex
    lmhex: lodsb
    orb %al, %al
    jz lmuse1

    subb $0x30, %al
    jc lmbad

    cmpb $10, %al
    jc lmhx1

    subb $7, %al
    andb $0xdf, %al
    cmpb $10, %al
    jc lmbad

    cmpb $16, %al
    jnc lmbad

    lmhx1: shlw $4, %bx
    orb %al, %bl
    jmp lmhex

    lmuse1: movw %bx, %ax
    jmp lmuse

    mnusel: lodsb # Menu selection
    xorb %ah, %ah
    subb $0x30, %al
    jc lmbad

    cmpb $10, %al
    jc lmuse

    cmpb $0x61-0x30, %al
    jc lmbad

    subb $0x61-0x30-10, %al
    cmpb $36, %al
    jnc lmbad

    lmuse: call mode_set
    jc lmdef

    lmbad: leaw unknt, %si
    call prtstr
    jmp lm2
    lmscan: cmpb $0, adapter # Scanning only on EGA/VGA
    jz lmbad

    movw $0, mt_end # Scanning of modes is
    movb $1, scanning # done as new autodetection.
    call mode_table
    jmp listm0
    lmdef: ret

    # Additional parts of mode_set... (relative jumps, you know)
    setv7: # Video7 extended modes
    DO_STORE
    subb $VIDEO_FIRST_V7>>8, %bh
    movw $0x6f05, %ax
    int $0x10
    stc
    ret

    _setrec: jmp setrec # Ugly...
    _set_80x25: jmp set_80x25

    # Aliases for backward compatibility.
    setalias:
    movw $VIDEO_80x25, %ax
    incw %bx
    jz mode_set

    movb $VIDEO_8POINT-VIDEO_FIRST_SPECIAL, %al
    incw %bx
    jnz setbad # Fall-through!

    # Setting of user mode (AX=mode ID) => CF=success
    mode_set:
    movw %ax, %fs0x01fa) # Store mode for use in acpi_wakeup.S
    movw %ax, %bx
    cmpb $0xff, %ah
    jz setalias

    testb $VIDEO_RECALC>>8, %ah
    jnz _setrec

    cmpb $VIDEO_FIRST_RESOLUTION>>8, %ah
    jnc setres

    cmpb $VIDEO_FIRST_SPECIAL>>8, %ah
    jz setspc

    cmpb $VIDEO_FIRST_V7>>8, %ah
    jz setv7

    cmpb $VIDEO_FIRST_VESA>>8, %ah
    jnc check_vesa

    orb %ah, %ah
    jz setmenu

    decb %ah
    jz setbios

    setbad: clc
    movb $0, do_restore # The screen needn't be restored
    ret

    setvesa:
    DO_STORE
    subb $VIDEO_FIRST_VESA>>8, %bh
    movw $0x4f02, %ax # VESA BIOS mode set call
    int $0x10
    cmpw $0x004f, %ax # AL=4f if implemented
    jnz setbad # AH=0 if OK

    stc
    ret

    setbios:
    DO_STORE
    int $0x10 # Standard BIOS mode set call
    pushw %bx
    movb $0x0f, %ah # Check if really set
    int $0x10
    popw %bx
    cmpb %bl, %al
    jnz setbad

    stc
    ret

    setspc: xorb %bh, %bh # Set special mode
    cmpb $VIDEO_LAST_SPECIAL-VIDEO_FIRST_SPECIAL, %bl
    jnc setbad

    addw %bx, %bx
    jmp *spec_inits(%bx)

    setmenu:
    orb %al, %al # 80x25 is an exception
    jz _set_80x25

    pushw %bx # Set mode chosen from menu
    call mode_table # Build the mode table
    popw %ax
    shlw $2, %ax
    addw %ax, %si
    cmpw %di, %si
    jnc setbad

    movw (%si), %ax # Fetch mode ID
    _m_s: jmp mode_set

    setres: pushw %bx # Set mode chosen by resolution
    call mode_table
    popw %bx
    xchgb %bl, %bh
    setr1: lodsw
    cmpw $ASK_VGA, %ax # End of the list?
    jz setbad

    lodsw
    cmpw %bx, %ax
    jnz setr1

    movw -4(%si), %ax # Fetch mode ID
    jmp _m_s

    check_vesa:
    leaw modelist+1024, %di
    subb $VIDEO_FIRST_VESA>>8, %bh
    movw %bx, %cx # Get mode information structure
    movw $0x4f01, %ax
    int $0x10
    addb $VIDEO_FIRST_VESA>>8, %bh
    cmpw $0x004f, %ax
    jnz setbad

    movb (%di), %al # Check capabilities.
    andb $0x19, %al
    cmpb $0x09, %al
    jz setvesa # This is a text mode

    movb (%di), %al # Check capabilities.
    andb $0x99, %al
    cmpb $0x99, %al
    jnz _setbad # Doh! No linear frame buffer.

    subb $VIDEO_FIRST_VESA>>8, %bh
    orw $0x4000, %bx # Use linear frame buffer
    movw $0x4f02, %ax # VESA BIOS mode set call
    int $0x10
    cmpw $0x004f, %ax # AL=4f if implemented
    jnz _setbad # AH=0 if OK

    movb $1, graphic_mode # flag graphic mode
    movb $0, do_restore # no screen restore
    stc
    ret

    _setbad: jmp setbad # Ugly...

    # Recalculate vertical display end registers -- this fixes various
    # inconsistencies of extended modes on many adapters. Called when
    # the VIDEO_RECALC flag is set in the mode ID.

    setrec: subb $VIDEO_RECALC>>8, %ah # Set the base mode
    call mode_set
    jnc rct3

    movw %gs0x485), %ax # Font size in pixels
    movb %gs0x484), %bl # Number of rows
    incb %bl
    mulb %bl # Number of visible
    decw %ax # scan lines - 1
    movw $0x3d4, %dx
    movw %ax, %bx
    movb $0x12, %al # Lower 8 bits
    movb %bl, %ah
    outw %ax, %dx
    movb $0x07, %al # Bits 8 and 9 in the overflow register
    call inidx
    xchgb %al, %ah
    andb $0xbd, %ah
    shrb %bh
    jnc rct1
    orb $0x02, %ah
    rct1: shrb %bh
    jnc rct2
    orb $0x40, %ah
    rct2: movb $0x07, %al
    outw %ax, %dx
    stc
    rct3: ret

    # Table of routines for setting of the special modes.
    spec_inits:
    .word set_80x25
    .word set_8pixel
    .word set_80x43
    .word set_80x28
    .word set_current
    .word set_80x30
    .word set_80x34
    .word set_80x60
    .word set_gfx

    # Set the 80x25 mode. If already set, do nothing.
    set_80x25:
    movw $0x5019, force_size # Override possibly broken BIOS
    use_80x25:
    movw $0x1202, %ax # Force 400 scan lines
    movb $0x30, %bl
    int $0x10

    movw $0x1100,%ax #my added
    movb $0x016,%bh
    movb $0x00,%bl
    movb $0xff,%cl # make 128 if rom loaded
    movb $0x40,%dl
    xorb %dh, %dh
    movb %dh,%ch
    pushw %bp
    leaw myfont,%bp #or make offset if not work
    int $0x10
    popw %bp


    movw $0x1103,%ax
    movb $0x00,%bl
    int $0x10



    leaw badmdt, %si
    call prtstr



    # Set the 80x50/80x43 8-pixel mode. Simple BIOS calls.
    set_8pixel:
    DO_STORE
    call use_80x25 # The base is 80x25
    set_8pt:
    movw $0x1112, %ax # Use 8x8 font
    xorb %bl, %bl
    int $0x10
    movw $0x1200, %ax # Use alternate print screen
    movb $0x20, %bl
    int $0x10
    movw $0x1201, %ax # Turn off cursor emulation
    movb $0x34, %bl
    int $0x10
    movb $0x01, %ah # Define cursor scan lines 6-7
    movw $0x0607, %cx
    int $0x10
    set_current:
    stc
    ret

    # Set the 80x28 mode. This mode works on all VGA's, because it's a
    standard
    # 80x25 mode with 14-point fonts instead of 16-point.
    set_80x28:
    DO_STORE
    call use_80x25 # The base is 80x25
    set14: movw $0x1111, %ax # Use 9x14 font
    xorb %bl, %bl
    int $0x10
    movb $0x01, %ah # Define cursor scan lines 11-12
    movw $0x0b0c, %cx
    int $0x10
    stc
    ret

    # Set the 80x43 mode. This mode is works on all VGA's.
    # It's a 350-scanline mode with 8-pixel font.
    set_80x43:
    DO_STORE
    movw $0x1201, %ax # Set 350 scans
    movb $0x30, %bl
    int $0x10
    movw $0x0003, %ax # Reset video mode
    int $0x10
    jmp set_8pt # Use 8-pixel font

    # Set the 80x30 mode (all VGA's). 480 scanlines, 16-pixel font.
    set_80x30:
    call use_80x25 # Start with real 80x25
    DO_STORE
    movw $0x3cc, %dx # Get CRTC port
    inb %dx, %al
    movb $0xd4, %dl
    rorb %al # Mono or color?
    jc set48a

    movb $0xb4, %dl
    set48a: movw $0x0c11, %ax # Vertical sync end (also unlocks CR0-7)
    call outidx
    movw $0x0b06, %ax # Vertical total
    call outidx
    movw $0x3e07, %ax # (Vertical) overflow
    call outidx
    movw $0xea10, %ax # Vertical sync start
    call outidx
    movw $0xdf12, %ax # Vertical display end
    call outidx
    movw $0xe715, %ax # Vertical blank start
    call outidx
    movw $0x0416, %ax # Vertical blank end
    call outidx
    pushw %dx
    movb $0xcc, %dl # Misc output register (read)
    inb %dx, %al
    movb $0xc2, %dl # (write)
    andb $0x0d, %al # Preserve clock select bits and color bit
    orb $0xe2, %al # Set correct sync polarity
    outb %al, %dx
    popw %dx
    movw $0x501e, force_size
    stc # That's all.
    ret

    # Set the 80x34 mode (all VGA's). 480 scans, 14-pixel font.
    set_80x34:
    call set_80x30 # Set 480 scans
    call set14 # And 14-pt font
    movw $0xdb12, %ax # VGA vertical display end
    movw $0x5022, force_size
    setvde: call outidx
    stc
    ret

    # Set the 80x60 mode (all VGA's). 480 scans, 8-pixel font.
    set_80x60:
    call set_80x30 # Set 480 scans
    call set_8pt # And 8-pt font
    movw $0xdf12, %ax # VGA vertical display end
    movw $0x503c, force_size
    jmp setvde

    # Special hack for ThinkPad graphics
    set_gfx:
    #ifdef CONFIG_VIDEO_GFX_HACK
    movw $VIDEO_GFX_BIOS_AX, %ax
    movw $VIDEO_GFX_BIOS_BX, %bx
    int $0x10
    movw $VIDEO_GFX_DUMMY_RESOLUTION, force_size
    stc
    #endif
    ret

    #ifdef CONFIG_VIDEO_RETAIN

    # Store screen contents to temporary buffer.
    store_screen:
    cmpb $0, do_restore # Already stored?
    jnz stsr

    testb $CAN_USE_HEAP, loadflags # Have we space for storing?
    jz stsr

    pushw %ax
    pushw %bx
    pushw force_size # Don't force specific size
    movw $0, force_size
    call mode_params # Obtain params of current mode
    popw force_size
    movb %fsPARAM_VIDEO_LINES), %ah
    movb %fsPARAM_VIDEO_COLS), %al
    movw %ax, %bx # BX=dimensions
    mulb %ah
    movw %ax, %cx # CX=number of characters
    addw %ax, %ax # Calculate image size
    addw $modelist+1024+4, %ax
    cmpw heap_end_ptr, %ax
    jnc sts1 # Unfortunately, out of memory

    movw %fsPARAM_CURSOR_POS), %ax # Store mode params
    leaw modelist+1024, %di
    stosw
    movw %bx, %ax
    stosw
    pushw %ds # Store the screen
    movw video_segment, %ds
    xorw %si, %si
    rep
    movsw
    popw %ds
    incb do_restore # Screen will be restored later
    sts1: popw %bx
    popw %ax
    stsr: ret

    # Restore screen contents from temporary buffer.
    restore_screen:
    cmpb $0, do_restore # Has the screen been stored?
    jz res1

    call mode_params # Get parameters of current mode
    movb %fsPARAM_VIDEO_LINES), %cl
    movb %fsPARAM_VIDEO_COLS), %ch
    leaw modelist+1024, %si # Screen buffer
    lodsw # Set cursor position
    movw %ax, %dx
    cmpb %cl, %dh
    jc res2

    movb %cl, %dh
    decb %dh
    res2: cmpb %ch, %dl
    jc res3

    movb %ch, %dl
    decb %dl
    res3: movb $0x02, %ah
    movb $0x00, %bh
    int $0x10
    lodsw # Display size
    movb %ah, %dl # DL=number of lines
    movb $0, %ah # BX=phys. length of orig. line
    movw %ax, %bx
    cmpb %cl, %dl # Too many?
    jc res4

    pushw %ax
    movb %dl, %al
    subb %cl, %al
    mulb %bl
    addw %ax, %si
    addw %ax, %si
    popw %ax
    movb %cl, %dl
    res4: cmpb %ch, %al # Too wide?
    jc res5

    movb %ch, %al # AX=width of src. line
    res5: movb $0, %cl
    xchgb %ch, %cl
    movw %cx, %bp # BP=width of dest. line
    pushw %es
    movw video_segment, %es
    xorw %di, %di # Move the data
    addw %bx, %bx # Convert BX and BP to _bytes_
    addw %bp, %bp
    res6: pushw %si
    pushw %di
    movw %ax, %cx
    rep
    movsw
    popw %di
    popw %si
    addw %bp, %di
    addw %bx, %si
    decb %dl
    jnz res6

    popw %es # Done
    res1: ret
    #endif /* CONFIG_VIDEO_RETAIN */

    # Write to indexed VGA register (AL=index, AH=data, DX=index reg. port)
    outidx: outb %al, %dx
    pushw %ax
    movb %ah, %al
    incw %dx
    outb %al, %dx
    decw %dx
    popw %ax
    ret

    # Build the table of video modes (stored after the setup.S code at the
    # `modelist' label. Each video mode record looks like:
    # .word MODE-ID (our special mode ID (see above))
    # .byte rows (number of rows)
    # .byte columns (number of columns)
    # Returns address of the end of the table in DI, the end is marked
    # with a ASK_VGA ID.
    mode_table:
    movw mt_end, %di # Already filled?
    orw %di, %di
    jnz mtab1x

    leaw modelist, %di # Store standard modes:
    movl $VIDEO_80x25 + 0x50190000, %eax # The 80x25 mode (ALL)
    stosl
    movb adapter, %al # CGA/MDA/HGA -- no more modes
    orb %al, %al
    jz mtabe

    decb %al
    jnz mtabv

    movl $VIDEO_8POINT + 0x502b0000, %eax # The 80x43 EGA mode
    stosl
    jmp mtabe

    mtab1x: jmp mtab1

    mtabv: leaw vga_modes, %si # All modes for std VGA
    movw $vga_modes_end-vga_modes, %cx
    rep # I'm unable to use movsw as I don't know how to store a half
    movsb # of the expression above to cx without using explicit shr.

    cmpb $0, scanning # Mode scan requested?
    jz mscan1

    call mode_scan
    mscan1:

    #ifdef CONFIG_VIDEO_LOCAL
    call local_modes
    #endif /* CONFIG_VIDEO_LOCAL */

    #ifdef CONFIG_VIDEO_VESA
    call vesa_modes # Detect VESA VGA modes
    #endif /* CONFIG_VIDEO_VESA */

    #ifdef CONFIG_VIDEO_SVGA
    cmpb $0, scanning # Bypass when scanning
    jnz mscan2

    call svga_modes # Detect SVGA cards & modes
    mscan2:
    #endif /* CONFIG_VIDEO_SVGA */

    mtabe:

    #ifdef CONFIG_VIDEO_COMPACT
    leaw modelist, %si
    movw %di, %dx
    movw %si, %di
    cmt1: cmpw %dx, %si # Scan all modes
    jz cmt2

    leaw modelist, %bx # Find in previous entries
    movw 2(%si), %cx
    cmt3: cmpw %bx, %si
    jz cmt4

    cmpw 2(%bx), %cx # Found => don't copy this entry
    jz cmt5

    addw $4, %bx
    jmp cmt3

    cmt4: movsl # Copy entry
    jmp cmt1

    cmt5: addw $4, %si # Skip entry
    jmp cmt1

    cmt2:
    #endif /* CONFIG_VIDEO_COMPACT */

    movw $ASK_VGA, (%di) # End marker
    movw %di, mt_end
    mtab1: leaw modelist, %si # SI=mode list, DI=list end
    ret0: ret

    # Modes usable on all standard VGAs
    vga_modes:
    .word VIDEO_8POINT
    .word 0x5032 # 80x50
    .word VIDEO_80x43
    .word 0x502b # 80x43
    .word VIDEO_80x28
    .word 0x501c # 80x28
    .word VIDEO_80x30
    .word 0x501e # 80x30
    .word VIDEO_80x34
    .word 0x5022 # 80x34
    .word VIDEO_80x60
    .word 0x503c # 80x60
    #ifdef CONFIG_VIDEO_GFX_HACK
    .word VIDEO_GFX_HACK
    .word VIDEO_GFX_DUMMY_RESOLUTION
    #endif

    vga_modes_end:
    # Detect VESA modes.

    #ifdef CONFIG_VIDEO_VESA
    vesa_modes:
    cmpb $2, adapter # VGA only
    jnz ret0

    movw %di, %bp # BP=original mode table end
    addw $0x200, %di # Buffer space
    movw $0x4f00, %ax # VESA Get card info call
    int $0x10
    movw %bp, %di
    cmpw $0x004f, %ax # Successful?
    jnz ret0

    cmpw $0x4556, 0x200(%di)
    jnz ret0

    cmpw $0x4153, 0x202(%di)
    jnz ret0

    movw $vesa_name, card_name # Set name to "VESA VGA"
    pushw %gs
    lgsw 0x20e(%di), %si # GS:SI=mode list
    movw $128, %cx # Iteration limit
    vesa1:
    # gas version 2.9.1, using BFD version 2.9.1.0.23 buggers the next
    inst.
    # XXX: lodsw %gs%si), %ax # Get next mode in the list
    gs; lodsw
    cmpw $0xffff, %ax # End of the table?
    jz vesar

    cmpw $0x0080, %ax # Check validity of mode ID
    jc vesa2

    orb %ah, %ah # Valid IDs: 0x0000-0x007f/0x0100-0x07ff
    jz vesan # Certain BIOSes report 0x80-0xff!

    cmpw $0x0800, %ax
    jnc vesae

    vesa2: pushw %cx
    movw %ax, %cx # Get mode information structure
    movw $0x4f01, %ax
    int $0x10
    movw %cx, %bx # BX=mode number
    addb $VIDEO_FIRST_VESA>>8, %bh
    popw %cx
    cmpw $0x004f, %ax
    jnz vesan # Don't report errors (buggy BIOSES)

    movb (%di), %al # Check capabilities. We require
    andb $0x19, %al # a color text mode.
    cmpb $0x09, %al
    jnz vesan

    cmpw $0xb800, 8(%di) # Standard video memory address required
    jnz vesan

    testb $2, (%di) # Mode characteristics supplied?
    movw %bx, (%di) # Store mode number
    jz vesa3

    xorw %dx, %dx
    movw 0x12(%di), %bx # Width
    orb %bh, %bh
    jnz vesan

    movb %bl, 0x3(%di)
    movw 0x14(%di), %ax # Height
    orb %ah, %ah
    jnz vesan

    movb %al, 2(%di)
    mulb %bl
    cmpw $8193, %ax # Small enough for Linux console driver?
    jnc vesan

    jmp vesaok

    vesa3: subw $0x8108, %bx # This mode has no detailed info specified,
    jc vesan # so it must be a standard VESA mode.

    cmpw $5, %bx
    jnc vesan

    movw vesa_text_mode_table(%bx), %ax
    movw %ax, 2(%di)
    vesaok: addw $4, %di # The mode is valid. Store it.
    vesan: loop vesa1 # Next mode. Limit exceeded => error
    vesae: leaw vesaer, %si
    call prtstr
    movw %bp, %di # Discard already found modes.
    vesar: popw %gs
    ret

    # Dimensions of standard VESA text modes
    vesa_text_mode_table:
    .byte 60, 80 # 0108
    .byte 25, 132 # 0109
    .byte 43, 132 # 010A
    .byte 50, 132 # 010B
    .byte 60, 132 # 010C
    #endif /* CONFIG_VIDEO_VESA */

    # Scan for video modes. A bit dirty, but should work.
    mode_scan:
    movw $0x0100, %cx # Start with mode 0
    scm1: movb $0, %ah # Test the mode
    movb %cl, %al
    int $0x10
    movb $0x0f, %ah
    int $0x10
    cmpb %cl, %al
    jnz scm2 # Mode not set

    movw $0x3c0, %dx # Test if it's a text mode
    movb $0x10, %al # Mode bits
    call inidx
    andb $0x03, %al
    jnz scm2

    movb $0xce, %dl # Another set of mode bits
    movb $0x06, %al
    call inidx
    shrb %al
    jc scm2

    movb $0xd4, %dl # Cursor location
    movb $0x0f, %al
    call inidx
    orb %al, %al
    jnz scm2

    movw %cx, %ax # Ok, store the mode
    stosw
    movb %gs0x484), %al # Number of rows
    incb %al
    stosb
    movw %gs0x44a), %ax # Number of columns
    stosb
    scm2: incb %cl
    jns scm1

    movw $0x0003, %ax # Return back to mode 3
    int $0x10
    ret

    tstidx: outw %ax, %dx # OUT DX,AX and inidx
    inidx: outb %al, %dx # Read from indexed VGA register
    incw %dx # AL=index, DX=index reg port -> AL=data
    inb %dx, %al
    decw %dx
    ret

    # Try to detect type of SVGA card and supply (usually approximate)
    video
    # mode table for it.

    #ifdef CONFIG_VIDEO_SVGA
    svga_modes:
    leaw svga_table, %si # Test all known SVGA adapters
    dosvga: lodsw
    movw %ax, %bp # Default mode table
    orw %ax, %ax
    jz didsv1

    lodsw # Pointer to test routine
    pushw %si
    pushw %di
    pushw %es
    movw $0xc000, %bx
    movw %bx, %es
    call *%ax # Call test routine
    popw %es
    popw %di
    popw %si
    orw %bp, %bp
    jz dosvga

    movw %bp, %si # Found, copy the modes
    movb svga_prefix, %ah
    cpsvga: lodsb
    orb %al, %al
    jz didsv

    stosw
    movsw
    jmp cpsvga

    didsv: movw %si, card_name # Store pointer to card name
    didsv1: ret

    # Table of all known SVGA cards. For each card, we store a pointer to
    # a table of video modes supported by the card and a pointer to a
    routine
    # used for testing of presence of the card. The video mode table is
    always
    # followed by the name of the card or the chipset.
    svga_table:
    .word ati_md, ati_test
    .word oak_md, oak_test
    .word paradise_md, paradise_test
    .word realtek_md, realtek_test
    .word s3_md, s3_test
    .word chips_md, chips_test
    .word video7_md, video7_test
    .word cirrus5_md, cirrus5_test
    .word cirrus6_md, cirrus6_test
    .word cirrus1_md, cirrus1_test
    .word ahead_md, ahead_test
    .word everex_md, everex_test
    .word genoa_md, genoa_test
    .word trident_md, trident_test
    .word tseng_md, tseng_test
    .word 0

    # Test routines and mode tables:

    # S3 - The test algorithm was taken from the SuperProbe package
    # for XFree86 1.2.1. Report bugs to Christoph.Niemann@linux.org
    s3_test:
    movw $0x0f35, %cx # we store some constants in cl/ch
    movw $0x03d4, %dx
    movb $0x38, %al
    call inidx
    movb %al, %bh # store current CRT-register 0x38
    movw $0x0038, %ax
    call outidx # disable writing to special regs
    movb %cl, %al # check whether we can write special reg 0x35
    call inidx
    movb %al, %bl # save the current value of CRT reg 0x35
    andb $0xf0, %al # clear bits 0-3
    movb %al, %ah
    movb %cl, %al # and write it to CRT reg 0x35
    call outidx
    call inidx # now read it back
    andb %ch, %al # clear the upper 4 bits
    jz s3_2 # the first test failed. But we have a

    movb %bl, %ah # second chance
    movb %cl, %al
    call outidx
    jmp s3_1 # do the other tests

    s3_2: movw %cx, %ax # load ah with 0xf and al with 0x35
    orb %bl, %ah # set the upper 4 bits of ah with the orig value
    call outidx # write ...
    call inidx # ... and reread
    andb %cl, %al # turn off the upper 4 bits
    pushw %ax
    movb %bl, %ah # restore old value in register 0x35
    movb %cl, %al
    call outidx
    popw %ax
    cmpb %ch, %al # setting lower 4 bits was successful => bad
    je no_s3 # writing is allowed => this is not an S3

    s3_1: movw $0x4838, %ax # allow writing to special regs by putting
    call outidx # magic number into CRT-register 0x38
    movb %cl, %al # check whether we can write special reg 0x35
    call inidx
    movb %al, %bl
    andb $0xf0, %al
    movb %al, %ah
    movb %cl, %al
    call outidx
    call inidx
    andb %ch, %al
    jnz no_s3 # no, we can't write => no S3

    movw %cx, %ax
    orb %bl, %ah
    call outidx
    call inidx
    andb %ch, %al
    pushw %ax
    movb %bl, %ah # restore old value in register 0x35
    movb %cl, %al
    call outidx
    popw %ax
    cmpb %ch, %al
    jne no_s31 # writing not possible => no S3
    movb $0x30, %al
    call inidx # now get the S3 id ...
    leaw idS3, %di
    movw $0x10, %cx
    repne
    scasb
    je no_s31

    movb %bh, %ah
    movb $0x38, %al
    jmp s3rest

    no_s3: movb $0x35, %al # restore CRT register 0x35
    movb %bl, %ah
    call outidx
    no_s31: xorw %bp, %bp # Detection failed
    s3rest: movb %bh, %ah
    movb $0x38, %al # restore old value of CRT register 0x38
    jmp outidx

    idS3: .byte 0x81, 0x82, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95
    .byte 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa8, 0xb0

    s3_md: .byte 0x54, 0x2b, 0x84
    .byte 0x55, 0x19, 0x84
    .byte 0
    .ascii "S3"
    .byte 0

    # ATI cards.
    ati_test:
    leaw idati, %si
    movw $0x31, %di
    movw $0x09, %cx
    repe
    cmpsb
    je atiok

    xorw %bp, %bp
    atiok: ret

    idati: .ascii "761295520"

    ati_md: .byte 0x23, 0x19, 0x84
    .byte 0x33, 0x2c, 0x84
    .byte 0x22, 0x1e, 0x64
    .byte 0x21, 0x19, 0x64
    .byte 0x58, 0x21, 0x50
    .byte 0x5b, 0x1e, 0x50
    .byte 0
    .ascii "ATI"
    .byte 0

    # AHEAD
    ahead_test:
    movw $0x200f, %ax
    movw $0x3ce, %dx
    outw %ax, %dx
    incw %dx
    inb %dx, %al
    cmpb $0x20, %al
    je isahed

    cmpb $0x21, %al
    je isahed

    xorw %bp, %bp
    isahed: ret

    ahead_md:
    .byte 0x22, 0x2c, 0x84
    .byte 0x23, 0x19, 0x84
    .byte 0x24, 0x1c, 0x84
    .byte 0x2f, 0x32, 0xa0
    .byte 0x32, 0x22, 0x50
    .byte 0x34, 0x42, 0x50
    .byte 0
    .ascii "Ahead"
    .byte 0

    # Chips & Tech.
    chips_test:
    movw $0x3c3, %dx
    inb %dx, %al
    orb $0x10, %al
    outb %al, %dx
    movw $0x104, %dx
    inb %dx, %al
    movb %al, %bl
    movw $0x3c3, %dx
    inb %dx, %al
    andb $0xef, %al
    outb %al, %dx
    cmpb $0xa5, %bl
    je cantok

    xorw %bp, %bp
    cantok: ret

    chips_md:
    .byte 0x60, 0x19, 0x84
    .byte 0x61, 0x32, 0x84
    .byte 0
    .ascii "Chips & Technologies"
    .byte 0

    # Cirrus Logic 5X0
    cirrus1_test:
    movw $0x3d4, %dx
    movb $0x0c, %al
    outb %al, %dx
    incw %dx
    inb %dx, %al
    movb %al, %bl
    xorb %al, %al
    outb %al, %dx
    decw %dx
    movb $0x1f, %al
    outb %al, %dx
    incw %dx
    inb %dx, %al
    movb %al, %bh
    xorb %ah, %ah
    shlb $4, %al
    movw %ax, %cx
    movb %bh, %al
    shrb $4, %al
    addw %ax, %cx
    shlw $8, %cx
    addw $6, %cx
    movw %cx, %ax
    movw $0x3c4, %dx
    outw %ax, %dx
    incw %dx
    inb %dx, %al
    andb %al, %al
    jnz nocirr

    movb %bh, %al
    outb %al, %dx
    inb %dx, %al
    cmpb $0x01, %al
    je iscirr

    nocirr: xorw %bp, %bp
    iscirr: movw $0x3d4, %dx
    movb %bl, %al
    xorb %ah, %ah
    shlw $8, %ax
    addw $0x0c, %ax
    outw %ax, %dx
    ret

    cirrus1_md:
    .byte 0x1f, 0x19, 0x84
    .byte 0x20, 0x2c, 0x84
    .byte 0x22, 0x1e, 0x84
    .byte 0x31, 0x25, 0x64
    .byte 0
    .ascii "Cirrus Logic 5X0"
    .byte 0

    # Cirrus Logic 54XX
    cirrus5_test:
    movw $0x3c4, %dx
    movb $6, %al
    call inidx
    movb %al, %bl # BL=backup
    movw $6, %ax
    call tstidx
    cmpb $0x0f, %al
    jne c5fail

    movw $0x1206, %ax
    call tstidx
    cmpb $0x12, %al
    jne c5fail

    movb $0x1e, %al
    call inidx
    movb %al, %bh
    movb %bh, %ah
    andb $0xc0, %ah
    movb $0x1e, %al
    call tstidx
    andb $0x3f, %al
    jne c5xx

    movb $0x1e, %al
    movb %bh, %ah
    orb $0x3f, %ah
    call tstidx
    xorb $0x3f, %al
    andb $0x3f, %al
    c5xx: pushf
    movb $0x1e, %al
    movb %bh, %ah
    outw %ax, %dx
    popf
    je c5done

    c5fail: xorw %bp, %bp
    c5done: movb $6, %al
    movb %bl, %ah
    outw %ax, %dx
    ret

    cirrus5_md:
    .byte 0x14, 0x19, 0x84
    .byte 0x54, 0x2b, 0x84
    .byte 0
    .ascii "Cirrus Logic 54XX"
    .byte 0

    # Cirrus Logic 64XX -- no known extra modes, but must be identified,
    because
    # it's misidentified by the Ahead test.
    cirrus6_test:
    movw $0x3ce, %dx
    movb $0x0a, %al
    call inidx
    movb %al, %bl # BL=backup
    movw $0xce0a, %ax
    call tstidx
    orb %al, %al
    jne c2fail

    movw $0xec0a, %ax
    call tstidx
    cmpb $0x01, %al
    jne c2fail

    movb $0xaa, %al
    call inidx # 4X, 5X, 7X and 8X are valid 64XX chip ID's.
    shrb $4, %al
    subb $4, %al
    jz c6done

    decb %al
    jz c6done

    subb $2, %al
    jz c6done

    decb %al
    jz c6done

    c2fail: xorw %bp, %bp
    c6done: movb $0x0a, %al
    movb %bl, %ah
    outw %ax, %dx
    ret

    cirrus6_md:
    .byte 0
    .ascii "Cirrus Logic 64XX"
    .byte 0

    # Everex / Trident
    everex_test:
    movw $0x7000, %ax
    xorw %bx, %bx
    int $0x10
    cmpb $0x70, %al
    jne noevrx

    shrw $4, %dx
    cmpw $0x678, %dx
    je evtrid

    cmpw $0x236, %dx
    jne evrxok

    evtrid: leaw trident_md, %bp
    evrxok: ret

    noevrx: xorw %bp, %bp
    ret

    everex_md:
    .byte 0x03, 0x22, 0x50
    .byte 0x04, 0x3c, 0x50
    .byte 0x07, 0x2b, 0x64
    .byte 0x08, 0x4b, 0x64
    .byte 0x0a, 0x19, 0x84
    .byte 0x0b, 0x2c, 0x84
    .byte 0x16, 0x1e, 0x50
    .byte 0x18, 0x1b, 0x64
    .byte 0x21, 0x40, 0xa0
    .byte 0x40, 0x1e, 0x84
    .byte 0
    .ascii "Everex/Trident"
    .byte 0

    # Genoa.
    genoa_test:
    leaw idgenoa, %si # Check Genoa 'clues'
    xorw %ax, %ax
    movb %es0x37), %al
    movw %ax, %di
    movw $0x04, %cx
    decw %si
    decw %di
    l1: incw %si
    incw %di
    movb (%si), %al
    testb %al, %al
    jz l2

    cmpb %es%di), %al
    l2: loope l1
    orw %cx, %cx
    je isgen

    xorw %bp, %bp
    isgen: ret

    idgenoa: .byte 0x77, 0x00, 0x99, 0x66

    genoa_md:
    .byte 0x58, 0x20, 0x50
    .byte 0x5a, 0x2a, 0x64
    .byte 0x60, 0x19, 0x84
    .byte 0x61, 0x1d, 0x84
    .byte 0x62, 0x20, 0x84
    .byte 0x63, 0x2c, 0x84
    .byte 0x64, 0x3c, 0x84
    .byte 0x6b, 0x4f, 0x64
    .byte 0x72, 0x3c, 0x50
    .byte 0x74, 0x42, 0x50
    .byte 0x78, 0x4b, 0x64
    .byte 0
    .ascii "Genoa"
    .byte 0

    # OAK
    oak_test:
    leaw idoakvga, %si
    movw $0x08, %di
    movw $0x08, %cx
    repe
    cmpsb
    je isoak

    xorw %bp, %bp
    isoak: ret

    idoakvga: .ascii "OAK VGA "

    oak_md: .byte 0x4e, 0x3c, 0x50
    .byte 0x4f, 0x3c, 0x84
    .byte 0x50, 0x19, 0x84
    .byte 0x51, 0x2b, 0x84
    .byte 0
    .ascii "OAK"
    .byte 0

    # WD Paradise.
    paradise_test:
    leaw idparadise, %si
    movw $0x7d, %di
    movw $0x04, %cx
    repe
    cmpsb
    je ispara

    xorw %bp, %bp
    ispara: ret

    idparadise: .ascii "VGA="

    paradise_md:
    .byte 0x41, 0x22, 0x50
    .byte 0x47, 0x1c, 0x84
    .byte 0x55, 0x19, 0x84
    .byte 0x54, 0x2c, 0x84
    .byte 0
    .ascii "Paradise"
    .byte 0

    # Trident.
    trident_test:
    movw $0x3c4, %dx
    movb $0x0e, %al
    outb %al, %dx
    incw %dx
    inb %dx, %al
    xchgb %al, %ah
    xorb %al, %al
    outb %al, %dx
    inb %dx, %al
    xchgb %ah, %al
    movb %al, %bl # Strange thing ... in the book this wasn't
    andb $0x02, %bl # necessary but it worked on my card which
    jz setb2 # is a trident. Without it the screen goes
    # blurred ...
    andb $0xfd, %al
    jmp clrb2

    setb2: orb $0x02, %al
    clrb2: outb %al, %dx
    andb $0x0f, %ah
    cmpb $0x02, %ah
    je istrid

    xorw %bp, %bp
    istrid: ret

    trident_md:
    .byte 0x50, 0x1e, 0x50
    .byte 0x51, 0x2b, 0x50
    .byte 0x52, 0x3c, 0x50
    .byte 0x57, 0x19, 0x84
    .byte 0x58, 0x1e, 0x84
    .byte 0x59, 0x2b, 0x84
    .byte 0x5a, 0x3c, 0x84
    .byte 0
    .ascii "Trident"
    .byte 0

    # Tseng.
    tseng_test:
    movw $0x3cd, %dx
    inb %dx, %al # Could things be this simple ! :-)
    movb %al, %bl
    movb $0x55, %al
    outb %al, %dx
    inb %dx, %al
    movb %al, %ah
    movb %bl, %al
    outb %al, %dx
    cmpb $0x55, %ah
    je istsen

    isnot: xorw %bp, %bp
    istsen: ret

    tseng_md:
    .byte 0x26, 0x3c, 0x50
    .byte 0x2a, 0x28, 0x64
    .byte 0x23, 0x19, 0x84
    .byte 0x24, 0x1c, 0x84
    .byte 0x22, 0x2c, 0x84
    .byte 0x21, 0x3c, 0x84
    .byte 0
    .ascii "Tseng"
    .byte 0

    # Video7.
    video7_test:
    movw $0x3cc, %dx
    inb %dx, %al
    movw $0x3b4, %dx
    andb $0x01, %al
    jz even7

    movw $0x3d4, %dx
    even7: movb $0x0c, %al
    outb %al, %dx
    incw %dx
    inb %dx, %al
    movb %al, %bl
    movb $0x55, %al
    outb %al, %dx
    inb %dx, %al
    decw %dx
    movb $0x1f, %al
    outb %al, %dx
    incw %dx
    inb %dx, %al
    movb %al, %bh
    decw %dx
    movb $0x0c, %al
    outb %al, %dx
    incw %dx
    movb %bl, %al
    outb %al, %dx
    movb $0x55, %al
    xorb $0xea, %al
    cmpb %bh, %al
    jne isnot

    movb $VIDEO_FIRST_V7>>8, svga_prefix # Use special mode switching
    ret

    video7_md:
    .byte 0x40, 0x2b, 0x50
    .byte 0x43, 0x3c, 0x50
    .byte 0x44, 0x3c, 0x64
    .byte 0x41, 0x19, 0x84
    .byte 0x42, 0x2c, 0x84
    .byte 0x45, 0x1c, 0x84
    .byte 0
    .ascii "Video 7"
    .byte 0

    # Realtek VGA
    realtek_test:
    leaw idrtvga, %si
    movw $0x45, %di
    movw $0x0b, %cx
    repe
    cmpsb
    je isrt

    xorw %bp, %bp
    isrt: ret

    idrtvga: .ascii "REALTEK VGA"

    realtek_md:
    .byte 0x1a, 0x3c, 0x50
    .byte 0x1b, 0x19, 0x84
    .byte 0x1c, 0x1e, 0x84
    .byte 0x1d, 0x2b, 0x84
    .byte 0x1e, 0x3c, 0x84
    .byte 0
    .ascii "REALTEK"
    .byte 0

    #endif /* CONFIG_VIDEO_SVGA */

    # User-defined local mode table (VGA only)
    #ifdef CONFIG_VIDEO_LOCAL
    local_modes:
    leaw local_mode_table, %si
    locm1: lodsw
    orw %ax, %ax
    jz locm2

    stosw
    movsw
    jmp locm1

    locm2: ret

    # This is the table of local video modes which can be supplied manually
    # by the user. Each entry consists of mode ID (word) and dimensions
    # (byte for column count and another byte for row count). These modes
    # are placed before all SVGA and VESA modes and override them if table
    # compacting is enabled. The table must end with a zero word followed
    # by NUL-terminated video adapter name.
    local_mode_table:
    .word 0x0100 # Example: 40x25
    .byte 25,40
    .word 0
    .ascii "Local"
    .byte 0
    #endif /* CONFIG_VIDEO_LOCAL */

    # Read a key and return the ASCII code in al, scan code in ah
    getkey: xorb %ah, %ah
    int $0x16
    ret

    # Read a key with a timeout of 30 seconds.
    # The hardware clock is used to get the time.
    getkt: call gettime
    addb $30, %al # Wait 30 seconds
    cmpb $60, %al
    jl lminute

    subb $60, %al
    lminute:
    movb %al, %cl
    again: movb $0x01, %ah
    int $0x16
    jnz getkey # key pressed, so get it

    call gettime
    cmpb %cl, %al
    jne again

    movb $0x20, %al # timeout, return `space'
    ret

    # Flush the keyboard buffer
    flush: movb $0x01, %ah
    int $0x16
    jz empty

    xorb %ah, %ah
    int $0x16
    jmp flush

    empty: ret

    # Print hexadecimal number.
    prthw: pushw %ax
    movb %ah, %al
    call prthb
    popw %ax
    prthb: pushw %ax
    shrb $4, %al
    call prthn
    popw %ax
    andb $0x0f, %al
    prthn: cmpb $0x0a, %al
    jc prth1

    addb $0x07, %al
    prth1: addb $0x30, %al
    jmp prtchr

    # Print decimal number in al
    prtdec: pushw %ax
    pushw %cx
    xorb %ah, %ah
    movb $0x0a, %cl
    idivb %cl
    cmpb $0x09, %al
    jbe lt100

    call prtdec
    jmp skip10

    lt100: addb $0x30, %al
    call prtchr
    skip10: movb %ah, %al
    addb $0x30, %al
    call prtchr
    popw %cx
    popw %ax
    ret

    store_edid:
    pushw %es # just save all registers
    pushw %ax
    pushw %bx
    pushw %cx
    pushw %dx
    pushw %di

    pushw %fs
    popw %es

    movl $0x13131313, %eax # memset block with 0x13
    movw $32, %cx
    movw $0x440, %di
    cld
    rep
    stosl

    movw $0x4f15, %ax # do VBE/DDC
    movw $0x01, %bx
    movw $0x00, %cx
    movw $0x01, %dx
    movw $0x440, %di
    int $0x10

    popw %di # restore all registers
    popw %dx
    popw %cx
    popw %bx
    popw %ax
    popw %es
    ret

    # VIDEO_SELECT-only variables
    mt_end: .word 0 # End of video mode table if built
    edit_buf: .space 6 # Line editor buffer
    card_name: .word 0 # Pointer to adapter name
    scanning: .byte 0 # Performing mode scan
    do_restore: .byte 0 # Screen contents altered during mode change
    svga_prefix: .byte VIDEO_FIRST_BIOS>>8 # Default prefix for BIOS modes
    graphic_mode: .byte 0 # Graphic mode with a linear frame buffer
    dac_size: .byte 6 # DAC bit depth

    # Status messages
    keymsg: .ascii "Press to see video modes available, "
    .ascii " to continue or wait 30 secs"
    .byte 0x0d, 0x0a, 0

    listhdr: .byte 0x0d, 0x0a
    .ascii "Mode: COLSxROWS:"

    myfont:


    ..byte 0x80,0x83,0x86,0x89,0x8c,0x8f,0x92,0x95,0x98,0x9c, 0x9f,0xa2,0xa5,0xa8,0xab,0xae
    .byte 0xb0,0xb3,0xb6,0xb9,0xbc,0xbf,0xc1,0xc4,0xc7,0xc9, 0xcc,0xce,0xd1,0xd3,0xd5,0xd8
    .byte 0xda,0xdc,0xde,0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec, 0xed,0xef,0xf0,0xf2,0xf3,0xf5
    .byte 0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfc,0xfd,0xfe, 0xfe,0xff,0xff,0xff,0xff,0xff
    .byte 0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xfe,0xfd,0xfc, 0xfc,0xfb,0xfa,0xf9,0xf8,0xf7
    .byte 0xf6,0xf5,0xf3,0xf2,0xf0,0xef,0xed,0xec,0xea,0xe8, 0xe6,0xe4,0xe2,0xe0,0xde,0xdc
    .byte 0xda,0xd8,0xd5,0xd3,0xd1,0xce,0xcc,0xc9,0xc7,0xc4, 0xc1,0xbf,0xbc,0xb9,0xb6,0xb3
    .byte 0xb0,0xae,0xab,0xa8,0xa5,0xa2,0x9f,0x9c,0x98,0x95, 0x92,0x8f,0x8c,0x89,0x86,0x83
    .byte 0x80,0x7c,0x79,0x76,0x73,0x70,0x6d,0x6a,0x67,0x63, 0x60,0x5d,0x5a,0x57,0x54,0x51
    .byte 0x4f,0x4c,0x49,0x46,0x43,0x40,0x3e,0x3b,0x38,0x36, 0x33,0x31,0x2e,0x2c,0x2a,0x27
    .byte 0x25,0x23,0x21,0x1f,0x1d,0x1b,0x19,0x17,0x15,0x13, 0x12,0x10,0x0f,0x0d,0x0c,0x0a
    .byte 0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x03,0x02,0x01, 0x01,0x00,0x00,0x00,0x00,0x00
    .byte 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x02,0x03, 0x03,0x04,0x05,0x06,0x07,0x08
    .byte 0x09,0x0a,0x0c,0x0d,0x0f,0x10,0x12,0x13,0x15,0x17, 0x19,0x1b,0x1d,0x1f,0x21,0x23
    .byte 0x25,0x27,0x2a,0x2c,0x2e,0x31,0x33,0x36,0x38,0x3b, 0x3e,0x40,0x43,0x46,0x49,0x4c
    .byte 0x4f,0x51,0x54,0x57,0x5a,0x5d,0x60,0x63,0x67,0x6a, 0x6d,0x70,0x73,0x76,0x79,0x7c
    ..byte 0x80,0x83,0x86,0x89,0x8c,0x8f,0x92,0x95,0x98,0x9c, 0x9f,0xa2,0xa5,0xa8,0xab,0xae
    .byte 0xb0,0xb3,0xb6,0xb9,0xbc,0xbf,0xc1,0xc4,0xc7,0xc9, 0xcc,0xce,0xd1,0xd3,0xd5,0xd8
    .byte 0xda,0xdc,0xde,0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec, 0xed,0xef,0xf0,0xf2,0xf3,0xf5
    .byte 0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfc,0xfd,0xfe, 0xfe,0xff,0xff,0xff,0xff,0xff
    .byte 0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xfe,0xfd,0xfc, 0xfc,0xfb,0xfa,0xf9,0xf8,0xf7
    .byte 0xf6,0xf5,0xf3,0xf2,0xf0,0xef,0xed,0xec,0xea,0xe8, 0xe6,0xe4,0xe2,0xe0,0xde,0xdc
    .byte 0xda,0xd8,0xd5,0xd3,0xd1,0xce,0xcc,0xc9,0xc7,0xc4, 0xc1,0xbf,0xbc,0xb9,0xb6,0xb3
    .byte 0xb0,0xae,0xab,0xa8,0xa5,0xa2,0x9f,0x9c,0x98,0x95, 0x92,0x8f,0x8c,0x89,0x86,0x83
    .byte 0x80,0x7c,0x79,0x76,0x73,0x70,0x6d,0x6a,0x67,0x63, 0x60,0x5d,0x5a,0x57,0x54,0x51
    .byte 0x4f,0x4c,0x49,0x46,0x43,0x40,0x3e,0x3b,0x38,0x36, 0x33,0x31,0x2e,0x2c,0x2a,0x27
    .byte 0x25,0x23,0x21,0x1f,0x1d,0x1b,0x19,0x17,0x15,0x13, 0x12,0x10,0x0f,0x0d,0x0c,0x0a
    .byte 0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x03,0x02,0x01, 0x01,0x00,0x00,0x00,0x00,0x00
    .byte 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x02,0x03, 0x03,0x04,0x05,0x06,0x07,0x08
    .byte 0x09,0x0a,0x0c,0x0d,0x0f,0x10,0x12,0x13,0x15,0x17, 0x19,0x1b,0x1d,0x1f,0x21,0x23
    .byte 0x25,0x27,0x2a,0x2c,0x2e,0x31,0x33,0x36,0x38,0x3b, 0x3e,0x40,0x43,0x46,0x49,0x4c
    .byte 0x4f,0x51,0x54,0x57,0x5a,0x5d,0x60,0x63,0x67,0x6a, 0x6d,0x70,0x73,0x76,0x79,0x7c
    ..byte 0x80,0x83,0x86,0x89,0x8c,0x8f,0x92,0x95,0x98,0x9c, 0x9f,0xa2,0xa5,0xa8,0xab,0xae
    .byte 0xb0,0xb3,0xb6,0xb9,0xbc,0xbf,0xc1,0xc4,0xc7,0xc9, 0xcc,0xce,0xd1,0xd3,0xd5,0xd8
    .byte 0xda,0xdc,0xde,0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec, 0xed,0xef,0xf0,0xf2,0xf3,0xf5
    .byte 0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfc,0xfd,0xfe, 0xfe,0xff,0xff,0xff,0xff,0xff
    .byte 0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xfe,0xfd,0xfc, 0xfc,0xfb,0xfa,0xf9,0xf8,0xf7
    .byte 0xf6,0xf5,0xf3,0xf2,0xf0,0xef,0xed,0xec,0xea,0xe8, 0xe6,0xe4,0xe2,0xe0,0xde,0xdc
    .byte 0xda,0xd8,0xd5,0xd3,0xd1,0xce,0xcc,0xc9,0xc7,0xc4, 0xc1,0xbf,0xbc,0xb9,0xb6,0xb3
    .byte 0xb0,0xae,0xab,0xa8,0xa5,0xa2,0x9f,0x9c,0x98,0x95, 0x92,0x8f,0x8c,0x89,0x86,0x83
    .byte 0x80,0x7c,0x79,0x76,0x73,0x70,0x6d,0x6a,0x67,0x63, 0x60,0x5d,0x5a,0x57,0x54,0x51
    .byte 0x4f,0x4c,0x49,0x46,0x43,0x40,0x3e,0x3b,0x38,0x36, 0x33,0x31,0x2e,0x2c,0x2a,0x27
    .byte 0x25,0x23,0x21,0x1f,0x1d,0x1b,0x19,0x17,0x15,0x13, 0x12,0x10,0x0f,0x0d,0x0c,0x0a
    .byte 0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x03,0x02,0x01, 0x01,0x00,0x00,0x00,0x00,0x00
    .byte 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x02,0x03, 0x03,0x04,0x05,0x06,0x07,0x08
    .byte 0x09,0x0a,0x0c,0x0d,0x0f,0x10,0x12,0x13,0x15,0x17, 0x19,0x1b,0x1d,0x1f,0x21,0x23
    .byte 0x25,0x27,0x2a,0x2c,0x2e,0x31,0x33,0x36,0x38,0x3b, 0x3e,0x40,0x43,0x46,0x49,0x4c
    .byte 0x4f,0x51,0x54,0x57,0x5a,0x5d,0x60,0x63,0x67,0x6a, 0x6d,0x70,0x73,0x76,0x79,0x7c
    ..byte 0x80,0x83,0x86,0x89,0x8c,0x8f,0x92,0x95,0x98,0x9c, 0x9f,0xa2,0xa5,0xa8,0xab,0xae
    .byte 0xb0,0xb3,0xb6,0xb9,0xbc,0xbf,0xc1,0xc4,0xc7,0xc9, 0xcc,0xce,0xd1,0xd3,0xd5,0xd8
    .byte 0xda,0xdc,0xde,0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec, 0xed,0xef,0xf0,0xf2,0xf3,0xf5
    .byte 0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfc,0xfd,0xfe, 0xfe,0xff,0xff,0xff,0xff,0xff
    .byte 0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xfe,0xfd,0xfc, 0xfc,0xfb,0xfa,0xf9,0xf8,0xf7
    .byte 0xf6,0xf5,0xf3,0xf2,0xf0,0xef,0xed,0xec,0xea,0xe8, 0xe6,0xe4,0xe2,0xe0,0xde,0xdc
    .byte 0xda,0xd8,0xd5,0xd3,0xd1,0xce,0xcc,0xc9,0xc7,0xc4, 0xc1,0xbf,0xbc,0xb9,0xb6,0xb3
    .byte 0xb0,0xae,0xab,0xa8,0xa5,0xa2,0x9f,0x9c,0x98,0x95, 0x92,0x8f,0x8c,0x89,0x86,0x83
    .byte 0x80,0x7c,0x79,0x76,0x73,0x70,0x6d,0x6a,0x67,0x63, 0x60,0x5d,0x5a,0x57,0x54,0x51
    .byte 0x4f,0x4c,0x49,0x46,0x43,0x40,0x3e,0x3b,0x38,0x36, 0x33,0x31,0x2e,0x2c,0x2a,0x27
    .byte 0x25,0x23,0x21,0x1f,0x1d,0x1b,0x19,0x17,0x15,0x13, 0x12,0x10,0x0f,0x0d,0x0c,0x0a
    .byte 0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x03,0x02,0x01, 0x01,0x00,0x00,0x00,0x00,0x00
    .byte 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x02,0x03, 0x03,0x04,0x05,0x06,0x07,0x08
    .byte 0x09,0x0a,0x0c,0x0d,0x0f,0x10,0x12,0x13,0x15,0x17, 0x19,0x1b,0x1d,0x1f,0x21,0x23
    .byte 0x25,0x27,0x2a,0x2c,0x2e,0x31,0x33,0x36,0x38,0x3b, 0x3e,0x40,0x43,0x46,0x49,0x4c
    .byte 0x4f,0x51,0x54,0x57,0x5a,0x5d,0x60,0x63,0x67,0x6a, 0x6d,0x70,0x73,0x76,0x79,0x7c
    ..byte 0x80,0x83,0x86,0x89,0x8c,0x8f,0x92,0x95,0x98,0x9c, 0x9f,0xa2,0xa5,0xa8,0xab,0xae
    .byte 0xb0,0xb3,0xb6,0xb9,0xbc,0xbf,0xc1,0xc4,0xc7,0xc9, 0xcc,0xce,0xd1,0xd3,0xd5,0xd8
    .byte 0xda,0xdc,0xde,0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec, 0xed,0xef,0xf0,0xf2,0xf3,0xf5
    .byte 0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfc,0xfd,0xfe, 0xfe,0xff,0xff,0xff,0xff,0xff
    .byte 0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xfe,0xfd,0xfc, 0xfc,0xfb,0xfa,0xf9,0xf8,0xf7
    .byte 0xf6,0xf5,0xf3,0xf2,0xf0,0xef,0xed,0xec,0xea,0xe8, 0xe6,0xe4,0xe2,0xe0,0xde,0xdc
    .byte 0xda,0xd8,0xd5,0xd3,0xd1,0xce,0xcc,0xc9,0xc7,0xc4, 0xc1,0xbf,0xbc,0xb9,0xb6,0xb3
    .byte 0xb0,0xae,0xab,0xa8,0xa5,0xa2,0x9f,0x9c,0x98,0x95, 0x92,0x8f,0x8c,0x89,0x86,0x83
    .byte 0x80,0x7c,0x79,0x76,0x73,0x70,0x6d,0x6a,0x67,0x63, 0x60,0x5d,0x5a,0x57,0x54,0x51
    .byte 0x4f,0x4c,0x49,0x46,0x43,0x40,0x3e,0x3b,0x38,0x36, 0x33,0x31,0x2e,0x2c,0x2a,0x27
    .byte 0x25,0x23,0x21,0x1f,0x1d,0x1b,0x19,0x17,0x15,0x13, 0x12,0x10,0x0f,0x0d,0x0c,0x0a
    .byte 0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x03,0x02,0x01, 0x01,0x00,0x00,0x00,0x00,0x00
    .byte 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x02,0x03, 0x03,0x04,0x05,0x06,0x07,0x08
    .byte 0x09,0x0a,0x0c,0x0d,0x0f,0x10,0x12,0x13,0x15,0x17, 0x19,0x1b,0x1d,0x1f,0x21,0x23
    .byte 0x25,0x27,0x2a,0x2c,0x2e,0x31,0x33,0x36,0x38,0x3b, 0x3e,0x40,0x43,0x46,0x49,0x4c
    .byte 0x4f,0x51,0x54,0x57,0x5a,0x5d,0x60,0x63,0x67,0x6a, 0x6d,0x70,0x73,0x76,0x79,0x7c


    crlft: .byte 0x0d, 0x0a, 0

    prompt: .byte 0x0d, 0x0a
    .asciz "Enter mode number or `scan': "

    unknt: .asciz "Unknown mode ID. Try again."

    badmdt: .ascii "abcdefghijklmnopqrstuvwzxy1234567890"
    .byte 0x0d, 0x0a, 0

    vesaer: .ascii "Error: Scanning of VESA modes failed. Please "
    .ascii "report to ."
    .byte 0x0d, 0x0a, 0

    old_name: .asciz "CGA/MDA/HGA"
    me:.ascii "mememememememmememememmememem"
    ega_name: .asciz "EGA"

    svga_name: .ascii " "

    vga_name: .asciz "VGA"

    vesa_name: .asciz "VESA"

    name_bann: .asciz "Video adapter: "
    #endif /* CONFIG_VIDEO_SELECT */

    # Other variables:
    adapter: .byte 0 # Video adapter: 0=CGA/MDA/HGA,1=EGA,2=VGA
    video_segment: .word 0xb800 # Video memory segment
    force_size: .word 0 # Use this size instead of the one in BIOS vars


  2. Re: video.S file in linux source

    zizo47000@yahoo.com writes:

    > video: pushw %ds # We use different segments


    What's this doing in c.o.l.alpha?

    --
    Måns Rullgård
    mru@inprovide.com

+ Reply to Thread