Subversion Repositories Kolibri OS

; HID keyboard driver, part of USBHID driver.

; Global constants.

; They are assembled in a macro to separate code and data;

; the code is located at the point of "include 'keyboard.inc'",

; the data are collected when workers_globals is instantiated.

macro workers_globals

{

; include global constants from previous workers

        workers_globals

align 4

; Callbacks for HID layer.

keyboard_driver:

        dd      keyboard_driver_add_device

        dd      keyboard_driver_disconnect

        dd      keyboard_driver_begin_packet

        dd      keyboard_driver_array_overflow?

        dd      keyboard_driver_input_field

        dd      keyboard_driver_end_packet

; Callbacks for keyboard layer.

kbd_functions:

        dd      12

        dd      CloseKeyboard

        dd      SetKeyboardLights

; Kernel keyboard layer takes input in form of PS/2 scancodes.

; data for keyboard: correspondence between HID usage keys and PS/2 scancodes.

EX = 80h        ; if set, precede the scancode with special scancode 0xE0

label control_keys byte

; Usages 700E0h ... 700E7h: LCtrl, LShift, LAlt, LWin, RCtrl, RShift, RAlt, RWin

        db      1Dh, 2Ah, 38h, 5Bh+EX, 1Dh+EX, 36h, 38h+EX, 5Ch+EX

; Usages 70004h ... 70004h + normal_keys_number - 1

label normal_keys byte

        db      1Eh, 30h, 2Eh, 20h, 12h, 21h, 22h, 23h, 17h, 24h, 25h, 26h, 32h, 31h, 18h, 19h

        db      10h, 13h, 1Fh, 14h, 16h, 2Fh, 11h, 2Dh, 15h, 2Ch, 02h, 03h, 04h, 05h, 06h, 07h

        db      08h, 09h, 0Ah, 0Bh, 1Ch, 01h, 0Eh, 0Fh, 39h, 0Ch, 0Dh, 1Ah, 1Bh, 2Bh, 2Bh, 27h

        db      28h, 29h, 33h, 34h, 35h, 3Ah, 3Bh, 3Ch, 3Dh, 3Eh, 3Fh, 40h, 41h, 42h, 43h, 44h

        db      57h, 58h,37h+EX,46h,0,52h+EX,47h+EX,49h+EX,53h+EX,4Fh+EX,51h+EX,4Dh+EX,4Bh+EX,50h+EX,48h+EX,45h

        db      35h+EX,37h,4Ah,4Eh,1Ch+EX,4Fh,50h, 51h, 4Bh, 4Ch, 4Dh, 47h, 48h, 49h, 52h, 53h

        db      56h,5Dh+EX,5Eh+EX

normal_keys_number = $ - normal_keys

}

; Data that are specific for one keyboard device.

struct keyboard_device_data

handle          dd      ?       ; keyboard handle from RegKeyboard

timer           dd      ?       ; auto-repeat timer handle

repeatkey       db      ?       ; auto-repeat key code

                rb      3       ; padding

usbdev          dd      ?       ; pointer to device_data of USB and HID layers

modifiers       dd      ?       ; state of LCtrl ... RWin

led_report      dd      ?       ; output report for LEDs state

numlock_bit     dd      ?       ; position of NumLock bit in LED output report

capslock_bit    dd      ?

scrolllock_bit  dd      ?       ; guess what

ends

; This procedure is called when HID layer detects a new keyboard.

; in: ebx -> usb_device_data, edi -> collection

; out: eax = device-specific data or NULL on error

proc keyboard_driver_add_device

; 1. Allocate memory for keyboard_device_data. If failed, return NULL.

        movi    eax, sizeof.keyboard_device_data

        call    Kmalloc

        test    eax, eax

        jz      .nothing

; 2. Initialize keyboard_device_data: store pointer to USB layer data,

; zero some fields, initialize bit positions to -1.

        mov     [eax+keyboard_device_data.usbdev], ebx

        xor     ecx, ecx

        mov     [eax+keyboard_device_data.timer], ecx

        mov     [eax+keyboard_device_data.repeatkey], cl

        mov     [eax+keyboard_device_data.modifiers], ecx

        mov     [eax+keyboard_device_data.led_report], ecx

        dec     ecx

        mov     [eax+keyboard_device_data.numlock_bit], ecx

        mov     [eax+keyboard_device_data.capslock_bit], ecx

        mov     [eax+keyboard_device_data.scrolllock_bit], ecx

; 3. Look for LED report and bits corresponding to indicators.

; For now, assume that all LEDs are set by the same report.

; 3a. Save registers.

        push    ebx esi

; 3b. Prepare for loop over output reports: get the first output report.

; If there are no output records, skip step 3;

; default values of led_report and *_bit were set in step 2.

        mov     edx, [edi+collection.output.first_report]

        test    edx, edx

        jz      .led_report_set

.scan_led_report:

; Process one output report.

; 3c. Prepare for loop over field groups in the current report:

; get the first field group.

        mov     ecx, [edx+report.first_field]

.scan_led_field:

; Process one field group.

; 3d. If there are no more field groups, exit the loop over field groups.

        test    ecx, ecx

        jz      .next_led_report

; For now, assume that all LEDs are plain variable fields, not arrays.

; 3e. Ignore array field groups.

        test    byte [ecx+report_field_group.flags], HID_FIELD_VARIABLE

        jz      .next_led_field

; 3f. Loop over all fields in the current group.

        push    [ecx+report_field_group.count]

; esi = pointer to usage of the current field

        lea     esi, [ecx+report_field_group.common_sizeof]

; ebx = bit position of the current field

        mov     ebx, [ecx+report_field_group.offset]

; if report is numbered, add extra byte in the start of report

        cmp     [edx+report.id], 0

        jz      .scan_led_usage

        add     ebx, 8

.scan_led_usage:

; for USAGE_LED_*LOCK, store the current bit position in the corresponding field

; and store the current report as the LED report

        cmp     dword [esi], USAGE_LED_NUMLOCK

        jz      .numlock

        cmp     dword [esi], USAGE_LED_CAPSLOCK

        jz      .capslock

        cmp     dword [esi], USAGE_LED_SCROLLLOCK

        jnz     .next_field

.scrolllock:

        mov     [eax+keyboard_device_data.scrolllock_bit], ebx

        jmp     @f

.capslock:

        mov     [eax+keyboard_device_data.capslock_bit], ebx

        jmp     @f

.numlock:

        mov     [eax+keyboard_device_data.numlock_bit], ebx

@@:

        mov     [eax+keyboard_device_data.led_report], edx

.next_field:

        add     esi, 4

        add     ebx, [ecx+report_field_group.size]

        dec     dword [esp]

        jnz     .scan_led_usage

        pop     ebx

.next_led_field:

; 3g. Continue loop over field groups: get next field group.

        mov     ecx, [ecx+report_field_group.next]

        jmp     .scan_led_field

.next_led_report:

; 3h. If the LED report has been set, break from the loop over reports.

; Otherwise, get the next report and continue if the current report is not

; the last for this collection.

        cmp     [eax+keyboard_device_data.led_report], 0

        jnz     .led_report_set

        cmp     edx, [edi+collection.output.last_report]

        mov     edx, [edx+report.next]

        jnz     .scan_led_report

.led_report_set:

; 3i. Restore registers.

        pop     esi ebx

; 4. Register keyboard in the kernel.

; store pointer to keyboard_device_data in the stack

        push    eax

; call kernel API

        stdcall RegKeyboard, kbd_functions, eax

; restore pointer to keyboard_device_data from the stack,

; putting keyboard handle from API to the stack

        xchg    eax, [esp]

; put keyboard handle from API from the stack to keyboard_device_data field

        pop     [eax+keyboard_device_data.handle]

; If failed, free keyboard_device_data and return NULL.

        cmp     [eax+keyboard_device_data.handle], 0

        jz      .fail_free

; 5. Return pointer to keyboard_device_data.

.nothing:

        ret

.fail_free:

        call    Kfree

        xor     eax, eax

        ret

endp

; This procedure is called when HID layer detects disconnect of a previously

; connected keyboard.

; in: edi -> keyboard_device_data (pointer returned from keyboard_driver_add_device)

proc keyboard_driver_disconnect

; 1. If an autorepeat timer is active, stop it.

        cmp     [edi+keyboard_device_data.timer], 0

        jz      @f

        stdcall CancelTimerHS, [edi+keyboard_device_data.timer]

@@:

; 2. Unregister keyboard in the kernel.

        stdcall DelKeyboard, [edi+keyboard_device_data.handle]

; We should free data in CloseKeyboard, not here.

        ret

endp

; This procedure is called when HID layer starts processing a new input packet

; from a keyboard.

; in: edi -> keyboard_device_data (pointer returned from keyboard_driver_add_device)

proc keyboard_driver_begin_packet

; Nothing to do.

        ret

endp

; This procedure is called when HID layer processes every non-empty array field group.

; in: edi -> keyboard_device_data (pointer returned from keyboard_driver_add_device)

; in: ecx = fields count (always nonzero), edx = pointer to fields values

; in: esi -> report_field_group

; out: CF set => group is ok, CF cleared => group should be ignored

proc keyboard_driver_array_overflow?

; The keyboard signals array overflow by filling the entire array with

; USAGE_KBD_ROLLOVER codes.

        mov     eax, [edx]      ; eax = first field in the array

        sub     eax, USAGE_KBD_ROLLOVER ; eax = 0 if overflow, nonzero otherwise

        neg     eax     ; CF cleared if eax was zero, CF set if eax was nonzero

        ret

endp

; This procedure is called from HID layer for every field.

; in: edi -> keyboard_device_data (pointer returned from keyboard_driver_add_device)

; in: ecx = field usage, edx = value, esi -> report_field_group

proc keyboard_driver_input_field

if HID_DUMP_UNCLAIMED

.unclaimed = default_driver_input_field

end if

; 1. Process normal keys:

; from USAGE_KBD_FIRST_KEY to USAGE_KBD_FIRST_KEY + normal_keys_number - 1,

; excluding zeroes in [normal_keys].

; 1a. Test whether usage is in the range.

        lea     eax, [ecx-USAGE_KBD_FIRST_KEY]

        cmp     eax, normal_keys_number

        jae     .not_normal_key

; 1b. If the corresponding entry in [normal_keys] is zero,

; pass this field to the default handler - if HID_DUMP_UNCLAIMED is enabled,

; default handler is default_driver_input_field, otherwise just ignore the field.

        cmp     [normal_keys + eax], 0

        jz      .unclaimed

; 1c. Get the scancode.

        movzx   ecx, [normal_keys + eax]

; 1d. Further actions are slightly different for key press and key release.

; Decide what to do.

        test    edx, edx

        jz      .normal_key_released

.normal_key_pressed:

; The key is pressed.

; 1e. Store the last pressed key for autorepeat.

        mov     [edi+keyboard_device_data.repeatkey], cl

; 1f. Copy bit 7 to CF and send scancode with bit 7 cleared.

        btr     ecx, 7

        call    .send_key

; 1g. Stop the previous autorepeat timer, if any.

        mov     eax, [edi+keyboard_device_data.timer]

        test    eax, eax

        jz      @f

        stdcall CancelTimerHS, eax

@@:

; 1h. Start the new autorepeat timer with 250 ms initial delay

; and 50 ms subsequent delays.

        stdcall TimerHS, 25, 5, autorepeat_timer, edi

        mov     [edi+keyboard_device_data.timer], eax

if ~HID_DUMP_UNCLAIMED

.unclaimed:

end if

        ret

.normal_key_released:

; The key is released.

; 1i. Stop the autorepeat timer if it is autorepeating the released key.

        cmp     [edi+keyboard_device_data.repeatkey], cl

        jnz     .no_stop_timer

        push    ecx

        mov     [edi+keyboard_device_data.repeatkey], 0

        mov     eax, [edi+keyboard_device_data.timer]

        test    eax, eax

        jz      @f

        stdcall CancelTimerHS, eax

        mov     [edi+keyboard_device_data.timer], 0

@@:

        pop     ecx

.no_stop_timer:

; 1j. Copy bit 7 to CF and send scancode with bit 7 set.

        bts     ecx, 7

        call    .send_key

        ret

.not_normal_key:

; 2. USAGE_KBD_NOEVENT is simply a filler for free array fields,

; ignore it.

        cmp     ecx, USAGE_KBD_NOEVENT

        jz      .nothing

; 3. Process modifiers: 8 keys starting at USAGE_KBD_LCTRL.

; 3a. Test whether usage is in range.

; If not, we don't know what this field means, so pass it to the default handler.

        lea     eax, [ecx-USAGE_KBD_LCTRL]

        cmp     eax, 8

        jae     .unclaimed

; 3b. Further actions are slightly different for modifier press

; and modifier release. Decide what to do.

        test    edx, edx

        jz      .modifier_not_pressed

.modifier_pressed:

; The modifier is pressed.

; 3c. Set the corresponding status bit.

; If it was not set, send the corresponding scancode to the kernel

; with bit 7 cleared.

        bts     [edi+keyboard_device_data.modifiers], eax

        jc      @f

        movzx   ecx, [control_keys+eax]

        btr     ecx, 7

        call    .send_key

@@:

.nothing:

        ret

.modifier_not_pressed:

; The modifier is not pressed.

; 3d. Clear the correspodning status bit.

; If it was set, send the corresponding scancode to the kernel

; with bit 7 set.

        btr     [edi+keyboard_device_data.modifiers], eax

        jnc     @f

        movzx   ecx, [control_keys+eax]

        bts     ecx, 7

        call    .send_key

@@:

        ret

; Helper procedure. Sends scancode from cl to the kernel.

; If CF is set, precede it with special code 0xE0.

.send_key:

        jnc     @f

        push    ecx

        mov     ecx, 0xE0

        call    SetKeyboardData

        pop     ecx

@@:

        call    SetKeyboardData

        ret

endp

; This procedure is called when HID layer ends processing a new input packet

; from a keyboard.

; in: edi -> keyboard_device_data (pointer returned from keyboard_driver_add_device)

proc keyboard_driver_end_packet

; Nothing to do.

        ret

endp

; Timer callback for SetTimerHS.

proc autorepeat_timer

virtual at esp

                dd      ?       ; return address

.data           dd      ?

end virtual

; Just resend the last pressed key.

        mov     eax, [.data]

        movzx   ecx, [eax+keyboard_device_data.repeatkey]

; Copy bit 7 to CF and send scancode with bit 7 cleared.

        btr     ecx, 7

        call    keyboard_driver_input_field.send_key

        ret     4

endp

; This function is called from the keyboard layer

; when it is safe to free keyboard data.

proc CloseKeyboard

virtual at esp

                dd      ?       ; return address

.device_data    dd      ?

end virtual

        mov     eax, [.device_data]

        call    Kfree

        ret     4

endp

; This function is called from the keyboard layer

; to update LED state on the keyboard.

proc SetKeyboardLights stdcall uses ebx esi edi, device_data, led_state

locals

size    dd      ?

endl

; 1. Get the pointer to the LED report.

; If there is no LED report, exit from the function.

        mov     ebx, [device_data]

        mov     esi, [ebx+keyboard_device_data.led_report]

        test    esi, esi

        jz      .nothing

; 2. Get report size in bytes.

; report.size is size in bits without possible report ID;

; if an ID is assigned, the size is one byte greater.

        mov     eax, [esi+report.size]

        add     eax, 7

        shr     eax, 3

        cmp     [esi+report.id], 0

        jz      @f

        inc     eax

@@:

        mov     [size], eax

; 3. Allocate memory for report + 8 bytes for setup packet.

; Dword-align size for subsequent rep stosd and bts.

; If failed, exit from the function.

        add     eax, 8 + 3

        and     eax, not 3

        push    eax

        call    Kmalloc

        pop     ecx

        test    eax, eax

        jz      .nothing

; 4. Zero-initialize output report.

        push    eax

        mov     edi, eax

        shr     ecx, 2

        xor     eax, eax

        rep stosd

        pop     edi

        add     edi, 8

; 5. Store report ID, if assigned. If not assigned, that would just write zero

; over zeroes.

        mov     edx, [esi+report.id]

        mov     [edi], edx

; 6. Set report bits corresponding to active indicators.

        mov     eax, [led_state]

        test    al, 1           ; PS/2 Scroll Lock

        jz      @f

        mov     ecx, [ebx+keyboard_device_data.scrolllock_bit]

        test    ecx, ecx

        js      @f

        bts     [edi], ecx

@@:

        test    al, 2           ; PS/2 Num Lock

        jz      @f

        mov     ecx, [ebx+keyboard_device_data.numlock_bit]

        test    ecx, ecx

        js      @f

        bts     [edi], ecx

@@:

        test    al, 4           ; PS/2 Caps Lock

        jz      @f

        mov     ecx, [ebx+keyboard_device_data.capslock_bit]

        test    ecx, ecx

        js      @f

        bts     [edi], ecx

@@:

; 7. Fill setup packet.

        shl     edx, 16         ; move Report ID to byte 2

        or      edx, 21h + \    ; Class-specific request to Interface

                (9 shl 8) + \   ; SET_REPORT

                (2 shl 24)      ; Report Type = Output

        lea     eax, [edi-8]

        mov     ebx, [ebx+keyboard_device_data.usbdev]

        mov     dword [eax], edx

        mov     edx, [size]

        shl     edx, 16         ; move Size to last word

        or      edx, [ebx+usb_device_data.interface_number]

        mov     [eax+4], edx

; 8. Submit output control request.

        stdcall USBControlTransferAsync, [ebx+usb_device_data.configpipe], \

                eax, edi, [size], after_set_keyboard_lights, ebx, 0

; If failed, free the buffer now.

; If succeeded, the callback will free the buffer.

        test    eax, eax

        jnz     .nothing

        lea     eax, [edi-8]

        call    Kfree

.nothing:

        ret

endp

; This procedure is called from the USB subsystem when the request initiated by

; SetKeyboardLights is completed, either successfully or unsuccessfully.

proc after_set_keyboard_lights

virtual at esp

                dd      ?       ; return address

.pipe           dd      ?

.status         dd      ?

.buffer         dd      ?

.length         dd      ?

.calldata       dd      ?

end virtual

; Ignore status, just free the buffer allocated by SetKeyboardLights.

        mov     eax, [.buffer]

        sub     eax, 8

        call    Kfree

        ret     20

endp