WebSVN – Kolibri OS – Diff – /drivers/usb/usbftdi/usbftdi.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;  FTDI chips driver for KolibriOS                             ;;
;;                                                              ;;
;;   Written by gtament@gmail.com                               ;;
;;                                                              ;;
;;         GNU GENERAL PUBLIC LICENSE                           ;;
;;          Version 2, June 1991                                ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
format PE DLL native 0.05
entry START
 
DEBUG = 1
 
__DEBUG__ = 1
__DEBUG_LEVEL__ = 1
 
node equ ftdi_context
node.next equ ftdi_context.next_context
 
include '../../proc32.inc'
include '../../peimport.inc'
include '../../fdo.inc'
include '../../struct.inc'
 
; USB constants
DEVICE_DESCR_TYPE           = 1
CONFIG_DESCR_TYPE           = 2
STRING_DESCR_TYPE           = 3
INTERFACE_DESCR_TYPE        = 4
ENDPOINT_DESCR_TYPE         = 5
DEVICE_QUALIFIER_DESCR_TYPE = 6
 
CONTROL_PIPE     = 0
ISOCHRONOUS_PIPE = 1
BULK_PIPE        = 2
INTERRUPT_PIPE   = 3
 
; USB HID constants
HID_DESCR_TYPE      = 21h
REPORT_DESCR_TYPE   = 22h
PHYSICAL_DESCR_TYPE = 23h
 
; LibUSB constatnts
LIBUSB_REQUEST_TYPE_STANDARD = (0x00 shl 5)
LIBUSB_REQUEST_TYPE_CLASS = (0x01 shl 5)
LIBUSB_REQUEST_TYPE_VENDOR = (0x02 shl 5)
LIBUSB_REQUEST_TYPE_RESERVED = (0x03 shl 5)
 
LIBUSB_RECIPIENT_DEVICE = 0x00
LIBUSB_RECIPIENT_INTERFACE = 0x01
LIBUSB_RECIPIENT_ENDPOINT = 0x02
LIBUSB_RECIPIENT_OTHER = 0x03
 
LIBUSB_ENDPOINT_IN = 0x80
LIBUSB_ENDPOINT_OUT = 0x00
 
; FTDI Constants
FTDI_DEVICE_OUT_REQTYPE = (LIBUSB_REQUEST_TYPE_VENDOR or LIBUSB_RECIPIENT_DEVICE or LIBUSB_ENDPOINT_OUT)
FTDI_DEVICE_IN_REQTYPE = (LIBUSB_REQUEST_TYPE_VENDOR or LIBUSB_RECIPIENT_DEVICE or LIBUSB_ENDPOINT_IN)
 
; Requests
;Definitions for flow control
SIO_RESET         =0  ;Reset the port
SIO_MODEM_CTRL    =1  ;Set the modem control register 
SIO_SET_FLOW_CTRL =2  ;Set flow control register
SIO_SET_BAUD_RATE =3  ;Set baud rate
SIO_SET_DATA      =4  ;Set the data characteristics of the port
 
SIO_RESET_REQUEST            =SIO_RESET
SIO_SET_BAUDRATE_REQUEST     =SIO_SET_BAUD_RATE
SIO_SET_DATA_REQUEST         =SIO_SET_DATA
SIO_SET_FLOW_CTRL_REQUEST    =SIO_SET_FLOW_CTRL
SIO_SET_MODEM_CTRL_REQUEST   =SIO_MODEM_CTRL
SIO_POLL_MODEM_STATUS_REQUEST=0x05
SIO_SET_EVENT_CHAR_REQUEST   =0x06
SIO_SET_ERROR_CHAR_REQUEST   =0x07
SIO_SET_LATENCY_TIMER_REQUEST=0x09
SIO_GET_LATENCY_TIMER_REQUEST=0x0A
SIO_SET_BITMODE_REQUEST      =0x0B
SIO_READ_PINS_REQUEST        =0x0C
SIO_READ_EEPROM_REQUEST      =0x90
SIO_WRITE_EEPROM_REQUEST     =0x91
SIO_ERASE_EEPROM_REQUEST     =0x92
 
 
SIO_RESET_SIO=0
SIO_RESET_PURGE_RX=1
SIO_RESET_PURGE_TX=2
 
SIO_DISABLE_FLOW_CTRL=0x0
SIO_RTS_CTS_HS =(0x1 shl 8)
SIO_DTR_DSR_HS =(0x2 shl 8)
SIO_XON_XOFF_HS=(0x4 shl 8)
 
SIO_SET_DTR_MASK=0x1
SIO_SET_DTR_HIGH=( 1 or ( SIO_SET_DTR_MASK  shl 8))
SIO_SET_DTR_LOW =( 0 or ( SIO_SET_DTR_MASK  shl 8))
SIO_SET_RTS_MASK=0x2
SIO_SET_RTS_HIGH=( 2 or ( SIO_SET_RTS_MASK shl 8 ))
SIO_SET_RTS_LOW =( 0 or ( SIO_SET_RTS_MASK shl 8 ))
 
SIO_RTS_CTS_HS =(0x1 shl 8)
 
;FTDI chip type
TYPE_AM=0
TYPE_BM=1
TYPE_2232C=2
TYPE_R=3
TYPE_2232H=4
TYPE_4232H=5
TYPE_232H=6
TYPE_230X=7
 
;strings
my_driver       db      'usbother',0
nomemory_msg    db      'K : no memory',13,10,0
 
; Structures
struct ftdi_context
chipType                db      ?
baudrate                dd      ?
bitbangEnabled          db      ?
readBufChunkSize        dd      ?
writeBufChunkSize       dd      ?
readBufPtr              dd      ?
writeBufPtr             dd      ?
readBufSize             dd      ?
writeBufSize            dd      ?
maxPacketSize           dd      ?
interface               dd      ?
index                   dd      ?
inEP                    dd      ?
outEP                   dd      ?
nullP                   dd      ? 
lockPID                 dd      ?
next_context            dd      ?
ends
 
struct IOCTL
handle                  dd      ?
io_code                 dd      ?
input                   dd      ?
inp_size                dd      ?
output                  dd      ?
out_size                dd      ?
ends
 
struct usb_descr
bLength                 db      ?
bDescriptorType         db      ?
bcdUSB                  dw      ?
bDeviceClass            db      ?
bDeviceSubClass         db      ?
bDeviceProtocol         db      ?
bMaxPacketSize0         db      ?
idVendor                dw      ?
idProduct               dw      ?
bcdDevice               dw      ?
iManufacturer           db      ?
iProduct                db      ?
iSerialNumber           db      ?
bNumConfigurations      db      ?
ends
 
struct conf_packet
bmRequestType           db      ?
bRequest                db      ?
wValue                  dw      ?
wIndex                  dw      ?
wLength                 dw      ?
ends
 
section '.flat' code readable executable
; The start procedure.
proc START c, .reason:DWORD, .cmdline:DWORD
 
        xor     eax, eax        ; initialize return value
        cmp     [.reason], 1    ; compare the argument
        jnz     .nothing                
        invoke  RegUSBDriver, my_driver, service_proc, usb_functions
 
.nothing:
        ret
endp
 
 
proc AddDevice stdcall uses ebx esi edi, .config_pipe:DWORD, .config_descr:DWORD, .interface:DWORD
        
        invoke  USBGetParam, [.config_pipe], 0
        mov     edx, eax
        DEBUGF 2,'K : Detected device vendor: 0x%x\n', [eax+usb_descr.idVendor]
        cmp     word[eax+usb_descr.idVendor], 0x0403
        jnz     .notftdi
        mov     eax, sizeof.ftdi_context
        invoke  Kmalloc
        test    eax, eax
        jnz     @f
        mov     esi, nomemory_msg
        invoke  SysMsgBoardStr
        jmp     .nothing
  @@:
        DEBUGF 2,'K : Adding struct to list 0x%x\n', eax
        call    linkedlist_add
        
        mov     ebx, [.config_pipe]
        mov     [eax + ftdi_context.nullP], ebx
        mov     [eax + ftdi_context.index], 0
        mov     [eax + ftdi_context.lockPID], 0
        mov     [eax + ftdi_context.maxPacketSize], 64       
        mov     [eax + ftdi_context.readBufChunkSize], 64
        mov     [eax + ftdi_context.writeBufChunkSize], 64
 
        mov     [eax + ftdi_context.chipType], TYPE_R
        jmp     .slow
        
        mov     cx, [edx+usb_descr.bcdDevice]
        DEBUGF 2, 'K : Chip type 0x%x\n', ecx
        cmp     cx, 0x400
        jnz     @f
        mov     [eax + ftdi_context.chipType], TYPE_BM
        jmp     .slow
  @@:      
        cmp     cx, 0x200
        jnz     @f
        mov     [eax + ftdi_context.chipType], TYPE_AM
        jmp     .slow
  @@:     
        cmp     cx, 0x500
        jnz     @f
        mov     [eax + ftdi_context.chipType], TYPE_2232C 
        jmp     .slow
  @@:      
        cmp     cx, 0x600
        jnz     @f
        mov     [eax + ftdi_context.chipType], TYPE_R
        jmp     .slow
  @@:      
        cmp     cx, 0x700
        jnz     @f
        mov     [eax + ftdi_context.chipType], TYPE_2232H
        jmp     .fast
  @@:      
        cmp     cx, 0x900
        jnz     @f
        mov     [eax + ftdi_context.chipType], TYPE_232H
        jmp     .fast
  @@:      
        cmp     cx, 0x1000
        jnz     .slow
        mov     [eax + ftdi_context.chipType], TYPE_230X
        jmp     .fast
        
  .fast:
        add     [eax + ftdi_context.maxPacketSize], 512-64
  .slow:    
        mov     ebx, eax
        invoke  USBOpenPipe, [.config_pipe], 0x81, \
                            [ebx + ftdi_context.maxPacketSize],  BULK_PIPE, 0
        test    eax, eax
        jz      .nothing
        mov     [ebx + ftdi_context.outEP], eax
        invoke  USBOpenPipe, [.config_pipe], 0x02, \
                            [ebx + ftdi_context.maxPacketSize],  BULK_PIPE, 0
        test    eax, eax
        jz      .nothing
        mov     [ebx + ftdi_context.inEP], eax
        mov     eax, ebx
        ret        
           
  .notftdi:
        DEBUGF 1,'K : Skipping not FTDI device\n'
  .nothing:        
        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
 
proc service_proc stdcall uses ebx esi edi, ioctl:DWORD
locals
ConfPacket  rb  10
EventData   rd  3
endl
        mov     edi, [ioctl]
        mov     eax, [edi+io_code]
        DEBUGF 1,'K : FTDI got the request: %d\n', eax
        test    eax, eax            ;0
        jz      .version
        dec     eax                 ;1
        jz      .ftdi_get_list
        
        push    eax
        mov     esi, [edi+input]
        mov     eax, [esi+4]
        call    linkedlist_isvalid
        test    eax, eax
        pop     eax        
        jnz     .endswitch
        
        dec     eax
        jz      .ftdi_lock      ;2
        dec     eax
        jz      .ftdi_unlock    ;3
        
        mov     ebx, [esi+4]
        mov     ecx, [ebx + ftdi_context.lockPID]
        cmp     dword[esi], 0
        jz      .error
        cmp     ecx, [esi]
        jz      .pid_ok
        mov     esi, [edi+output]
        mov     dword[esi], 'LCKD'
        jmp     .endswitch
        
  .pid_ok:
        dec     eax
        jz      .ftdi_get_wchunksize    ;4
        dec     eax
        jz      .ftdi_get_rchunksize    ;5        
        
        mov     edi, [edi+input]
        
        dec     eax
        jz      .ftdi_set_rchunksize    ;6
        dec     eax
        jz      .ftdi_set_wchunksize    ;7
  
        push    eax edi
        mov     ecx, 0x80000000
        cmp     eax, 8-7
        je      .bulkevent
        cmp     eax, 9-7
        je      .bulkevent
        xor     ecx, ecx
  .bulkevent:                
        xor     esi, esi
        invoke  CreateEvent        
        mov     [EventData], eax
        mov     [EventData+4], edx
        pop     edi eax
        
        dec     eax                 ;8
        jz      .ftdi_write_data
        dec     eax                 ;9
        jz      .ftdi_read_data
        dec     eax                 ;10
        jz      .ftdi_set_baudrate
        dec     eax                 ;11
        jz      .ftdi_set_bitmode
        dec     eax                 ;12
        jz      .ftdi_setrtshigh   
        dec     eax                 ;13
        jz      .ftdi_setrtslow  
        dec     eax                 ;14
        jz      .ftdi_setdtrhigh
        dec     eax                 ;15
        jz      .ftdi_setdtrlow
        dec     eax                 ;16
        jz      .ftdi_usb_reset
        dec     eax                 ;17
        jz      .ftdi_setflowctrl
        dec     eax                 ;18
        jz      .ftdi_set_event_char
        dec     eax                 ;19
        jz      .ftdi_set_error_char
        dec     eax                 ;20
        jz      .ftdi_set_latency_timer
        dec     eax                 ;21
        jz      .ftdi_get_latency_timer
        dec     eax                 ;22
        jz      .ftdi_read_pins
        dec     eax                 ;23
        jz      .ftdi_poll_modem_status        
        dec     eax                 ;24
        jz      .ftdi_set_line_property
        dec     eax                 ;25
        jz      .ftdi_purge_rx_buf
        dec     eax                 ;26
        jz      .ftdi_purge_tx_buf
        jmp     .error
                  
  .version:     
        jmp     .endswitch
  .error:
        DEBUGF 1, 'K : FTDI error occured! %d\n', eax
        ;mov     esi, [edi+output]
        ;mov     [esi], dword 'ERR0'
        ;or      [esi], eax
        ret
  .endswitch:
        xor     eax, eax
        ret
        
  .eventdestroy:
        ;---Dirty hack begin
        test    eax, eax
        jz      @f
        mov     eax, dword[ConfPacket]
        invoke  Kfree
  @@:
        ;---Dirty hack end
        mov     eax, [EventData]
        mov     ebx, [EventData+4]
        invoke  DestroyEvent
        jmp     .endswitch
        
  .ftdi_out_control_transfer_withinp:               
        mov     dx, word[edi+8]
        mov     word[ConfPacket+2], dx 
  .ftdi_out_control_transfer_noinp:
        mov     ebx, [edi+4]
        mov     cx, word[ebx + ftdi_context.index]
        mov     word[ConfPacket+4], cx
        xor     cx, cx
        mov     word[ConfPacket+6], cx
  .own_index:
        mov     ebx, [edi+4]
        DEBUGF 2,'K : ConfPacket 0x%x 0x%x\n', [ConfPacket], [ConfPacket+4]          
        lea     esi, [ConfPacket]
        lea     edi, [EventData]        
        invoke  USBControlTransferAsync, [ebx + ftdi_context.nullP],  esi, 0,\
                                            0, control_callback, edi, 0
        test    eax, eax        
        jz      .error
        mov     eax, [EventData]
        mov     ebx, [EventData+4]
        invoke  WaitEvent
        mov     eax, [EventData+8]
        test    eax, eax
        jz      .endswitch
        jmp     .error
        
  .ftdi_setrtshigh:
        DEBUGF 2,'K : FTDI Setting RTS pin HIGH PID: %d Dev handler 0x0x%x\n', [edi],\
                                                                        [edi+4]
        mov     dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                 + (SIO_SET_MODEM_CTRL_REQUEST shl 8) \
                                 + (SIO_SET_RTS_HIGH shl 16)
        jmp     .ftdi_out_control_transfer_noinp         
 
  .ftdi_setrtslow:
        DEBUGF 2,'K : FTDI Setting RTS pin LOW PID: %d Dev handler 0x0x%x\n', [edi],\
                                                                        [edi+4]
        mov     dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                 + (SIO_SET_MODEM_CTRL_REQUEST shl 8) \
                                 + (SIO_SET_RTS_LOW shl 16)
        jmp     .ftdi_out_control_transfer_noinp           
        
  .ftdi_setdtrhigh:
        DEBUGF 2,'K : FTDI Setting DTR pin HIGH PID: %d Dev handler 0x0x%x\n', [edi],\
                                                                        [edi+4]
        mov     dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                 + (SIO_SET_MODEM_CTRL_REQUEST shl 8) \
                                 + (SIO_SET_DTR_HIGH shl 16)
        jmp     .ftdi_out_control_transfer_noinp           
 
  .ftdi_setdtrlow:
        DEBUGF 2,'K : FTDI Setting DTR pin LOW PID: %d Dev handler 0x0x%x\n', [edi],\
                                                                        [edi+4]
        mov     dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                 + (SIO_SET_MODEM_CTRL_REQUEST shl 8) \
                                 + (SIO_SET_DTR_LOW shl 16)
        jmp     .ftdi_out_control_transfer_noinp           
        
  .ftdi_usb_reset:
        DEBUGF 2,'K : FTDI Reseting PID: %d Dev handler 0x0x%x\n', [edi],\
                                                                        [edi+4]
        mov     dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                 + (SIO_RESET_REQUEST shl 8) \
                                 + (SIO_RESET_SIO shl 16)
        jmp     .ftdi_out_control_transfer_noinp  
        
  .ftdi_purge_rx_buf:
        DEBUGF 2, 'K : FTDI Purge TX buffer PID: %d Dev handler 0x0x%x\n', [edi],\
                                                                        [edi+4]
        mov     dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                 + (SIO_RESET_REQUEST shl 8) \
                                 + (SIO_RESET_PURGE_RX shl 16)
        jmp     .ftdi_out_control_transfer_noinp  
        
  .ftdi_purge_tx_buf:
        DEBUGF 2, 'K : FTDI Purge RX buffer PID: %d Dev handler 0x0x%x\n', [edi],\
                                                                        [edi+4]
        mov     dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                 + (SIO_RESET_REQUEST shl 8) \
                                 + (SIO_RESET_PURGE_TX shl 16)
        jmp     .ftdi_out_control_transfer_noinp  
        
  .ftdi_set_bitmode:
        DEBUGF 2, 'K : FTDI Set bitmode 0x%x, bitmask 0x%x %d PID: %d Dev handler 0x0x%x\n', \
                                               [edi+8]:2,[edi+10]:2,[edi],[edi+4]
        mov     word[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                + (SIO_SET_BITMODE_REQUEST shl 8)                                       
        jmp     .ftdi_out_control_transfer_withinp        
     
  .ftdi_set_line_property:
        DEBUGF 2, 'K : FTDI Set line property 0x%x PID: %d Dev handler 0x0x%x\n', \
                                                          [edi+8]:4,[edi],[edi+4]
        mov     word[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                + (SIO_SET_DATA_REQUEST shl 8)
        jmp     .ftdi_out_control_transfer_withinp
        
  .ftdi_set_latency_timer:
        DEBUGF 2, 'K : FTDI Set latency %d PID: %d Dev handler 0x0x%x\n', \
                                                          [edi+8],[edi],[edi+4]
        mov     word[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                + (SIO_SET_LATENCY_TIMER_REQUEST shl 8)        
        jmp     .ftdi_out_control_transfer_withinp
        
  .ftdi_set_event_char:
        DEBUGF 2, 'K : FTDI Set event char %c PID: %d Dev handler 0x0x%x\n', \
                                                          [edi+8],[edi],[edi+4]
        mov     word[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                + (SIO_SET_EVENT_CHAR_REQUEST shl 8)
        jmp     .ftdi_out_control_transfer_withinp
 
  .ftdi_set_error_char:
        DEBUGF 2, 'K : FTDI Set error char %c PID: %d Dev handler 0x0x%x\n', \
                                                          [edi+8],[edi],[edi+4]
        mov     word[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                + (SIO_SET_ERROR_CHAR_REQUEST shl 8)
        jmp     .ftdi_out_control_transfer_withinp 
        
  .ftdi_setflowctrl:
        DEBUGF 2, 'K : FTDI Set flow control PID: %d Dev handler 0x0x%x\n', [edi],\
                                                                        [edi+4]
        mov     dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                 + (SIO_SET_FLOW_CTRL_REQUEST shl 8) + (0 shl 16)
        mov     ebx, [edi+4]
        mov     cx, word[edi+8]   
        or      ecx, [ebx + ftdi_context.index]
        mov     word[ConfPacket+4], cx
        xor     cx, cx
        mov     word[ConfPacket+6], cx
        jmp     .own_index
 
  .ftdi_read_pins:
        DEBUGF 2, 'K : FTDI Read pins PID: %d Dev handler 0x0x%x\n', [edi],\
                                                                     [edi+4]
        mov     ebx, [edi+4] 
        mov     dword[ConfPacket], (FTDI_DEVICE_IN_REQTYPE) \
                                 + (SIO_READ_PINS_REQUEST shl 8) + (0 shl 16)
        mov     ecx, [ebx + ftdi_context.index]
        mov     word[ConfPacket+4], cx
        mov     word[ConfPacket+6], 1
        lea     esi, [ConfPacket]
        lea     edi, [EventData]
        mov     ecx, esi
        add     ecx, 8
        mov     word[ConfPacket+8], 0
        invoke  USBControlTransferAsync, [ebx + ftdi_context.nullP],  esi, ecx, \
                                            1, control_callback, edi, 0
        mov     eax, [EventData]
        mov     ebx, [EventData+4]
        invoke  WaitEvent
        xor     ebx, ebx
        mov     bx, word[ConfPacket+8]
        mov     ecx, [ioctl]
        mov     ecx, [ecx+output]
        mov     [ecx], ebx
        mov     eax, [EventData+8]
        test    eax, eax
        jz      .endswitch
        jmp     .error
        
  .ftdi_set_wchunksize:
        DEBUGF 2, 'K : FTDI Set write chunksize %d bytes PID: %d Dev handler 0x0x%x\n', \
                                                    [edi+8], [edi], [edi+4]
        mov     ebx, [edi+4]
        mov     ecx, [edi+8] 
        cmp     [ebx + ftdi_context.maxPacketSize], ecx
        jg      .error
        mov     [ebx + ftdi_context.writeBufChunkSize], ecx
        jmp     .endswitch
   
  .ftdi_get_wchunksize:
        DEBUGF 2, 'K : FTDI Get write chunksize PID: %d Dev handler 0x0x%x\n', [edi],\
                                                                        [edi+4]
        mov     esi, [edi+output]
        mov     edi, [edi+input]
        mov     ebx, [edi+4]
        mov     ecx, [ebx + ftdi_context.writeBufChunkSize]
        mov     [esi], ecx
        jmp     .endswitch
 
  .ftdi_set_rchunksize:
        DEBUGF 2, 'K : FTDI Set read chunksize %d bytes PID: %d Dev handler 0x0x%x\n', \
                                                    [edi+8], [edi], [edi+4]
        mov     ebx, [edi+4]
        mov     ecx, [edi+8]
        cmp     [ebx + ftdi_context.maxPacketSize], ecx
        jg      .error
        mov     [ebx + ftdi_context.readBufChunkSize], ecx
        jmp     .endswitch
 
  .ftdi_get_rchunksize:
        DEBUGF 2, 'K : FTDI Get read chunksize PID: %d Dev handler 0x0x%x\n', [edi],\
                                                                        [edi+4]
        mov     esi, [edi+output]
        mov     edi, [edi+input]
        mov     ebx, [edi+4]
        mov     ecx, [ebx + ftdi_context.readBufChunkSize]
        mov     [esi], ecx
        jmp     .endswitch        
 
  .ftdi_write_data:
        DEBUGF 2, 'K : FTDI Write %d bytes PID: %d Dev handler 0x%x\n', [edi+8],\
                                                            [edi], [edi+4]
        mov     esi, edi
        add     esi, 12        
        mov     ebx, [edi+4]
        ;---Dirty hack begin
        mov     eax, [edi+8]
        invoke  Kmalloc
        test    eax, eax
        jnz     @f
        mov     esi, nomemory_msg
        invoke  SysMsgBoardStr
        jmp     .eventdestroy
  @@:
        mov     dword[ConfPacket], eax
        mov     ecx, [edi+8]
        push    edi
        mov     edi, eax
        rep movsb
        pop     edi
        mov     esi, dword[ConfPacket]
        ;---Dirty hack end        
        xor     ecx, ecx        ; ecx - offset      
  .write_loop:
        mov     edx, [edi+8]    ; edx - write_size
        sub     edx, ecx
        cmp     edx, [ebx + ftdi_context.writeBufChunkSize]
        jle     .lessthanchunk_write
        mov     edx, [ebx + ftdi_context.writeBufChunkSize]
  .lessthanchunk_write:
        add     esi, ecx
        lea     eax, [EventData]
        push    ecx ebx esi edi
        invoke USBNormalTransferAsync, [ebx + ftdi_context.inEP], esi, edx, \
                                            bulk_callback, eax, 1
        mov     eax, [EventData]
        mov     ebx, [EventData+4]
        invoke  WaitEvent
        pop     edi esi ebx ecx
        cmp     [EventData+8], -1
        jz      .error
        add     ecx, [EventData+8]
        cmp     ecx, [edi+8]
        jge     .eventdestroy
        jmp     .write_loop
        
  .ftdi_read_data:
        DEBUGF 2, 'K : FTDI Read %d bytes PID: %d Dev handler 0x%x\n', [edi+8],\
                                                            [edi], [edi+4]
        mov     edi, [ioctl]
        mov     esi, [edi+input]
        mov     edi, [edi+output]
        mov     ebx, [esi+4]     
        ;---Dirty hack begin
        mov     eax, [esi+8]
        invoke  Kmalloc
        test    eax, eax
        jnz     @f
        mov     esi, nomemory_msg
        invoke  SysMsgBoardStr
        jmp     .eventdestroy
  @@:
        mov     edi, eax
        ; push    edi eax
        ; mov     ecx, [esi+8]
        ; xor     eax, eax
        ; rep     stosb
        ; pop     eax edi
        mov     dword[ConfPacket], eax ; Store in ConfPacket ptr to allocated memory
        ;---Dirty hack end        
        xor     ecx, ecx
  .read_loop:
        mov     edx, [esi+8]
        cmp     ecx, edx
        jge     .read_end;jge     .eventdestroy ;part of Dirty hack
        sub     edx, ecx
        cmp     edx, [ebx + ftdi_context.readBufChunkSize]
        jl      .lessthanchunk_read
        mov     edx, [ebx + ftdi_context.readBufChunkSize]     
  .lessthanchunk_read:
        lea     eax, [EventData]
        add     edi, ecx
        push    esi edi ecx ebx
        invoke  USBNormalTransferAsync, [ebx + ftdi_context.outEP], edi, edx, \
                                            bulk_callback, eax, 1        
        mov     eax, [EventData]
        mov     ebx, [EventData+4]        
        invoke  WaitEvent
        pop     ebx ecx edi esi
        cmp     [EventData+8], -1        
        jz      .error
        add     ecx, [EventData+8]
        jmp     .read_loop 
        ;---Dirty hack begin        
  .read_end:
        mov     esi, dword[ConfPacket]
        mov     edi, [ioctl]
        mov     ecx, [edi+input]
        mov     ecx, [ecx+8]
        mov     edi, [edi+output]
        rep     movsb
        jmp     .eventdestroy
        ;---Dirty hack end
        
  .ftdi_poll_modem_status:
        DEBUGF 2, 'K : FTDI Poll modem status PID: %d Dev handler 0x0x%x\n', [edi],\
                                                                        [edi+4] 
        mov     ebx, [edi+4] 
        mov     dword[ConfPacket], (FTDI_DEVICE_IN_REQTYPE) \
                                 + (SIO_POLL_MODEM_STATUS_REQUEST shl 8) + (0 shl 16)
        mov     ecx, [ebx + ftdi_context.index]
        mov     word[ConfPacket+4], cx
        mov     word[ConfPacket+6], 1
        lea     esi, [ConfPacket]
        lea     edi, [EventData]
        mov     ecx, [ioctl]
        mov     ecx, [ecx+output]
        invoke  USBControlTransferAsync, [ebx + ftdi_context.nullP],  esi, ecx, \
                                            2, control_callback, edi, 0
        mov     eax, [EventData]
        mov     ebx, [EventData+4]
        invoke  WaitEvent
        mov     ax, word[ecx]
        xchg    ah, al
        and     ah, 0xFF
        mov     word[ecx], ax
        jmp     .endswitch
        
  .ftdi_get_latency_timer:
        DEBUGF 2, 'K : FTDI Get latency timer PID: %d Dev handler 0x0x%x\n', [edi],\
                                                                        [edi+4] 
        mov     ebx, [edi+4] 
        mov     dword[ConfPacket], FTDI_DEVICE_IN_REQTYPE \
                                + (SIO_GET_LATENCY_TIMER_REQUEST shl 8) + (0 shl 16)
        mov     ecx, [ebx + ftdi_context.index]
        mov     word[ConfPacket+4], cx
        mov     word[ConfPacket+6], 1
        lea     esi, [ConfPacket]
        lea     edi, [EventData]
        mov     ecx, [ioctl]
        mov     ecx, [ecx+output]
        invoke  USBControlTransferAsync, [ebx + ftdi_context.nullP],  esi, ecx, \
                                            2, control_callback, edi, 0
        mov     eax, [EventData]
        mov     ebx, [EventData+4]
        invoke  WaitEvent
        jmp     .endswitch
                
  .ftdi_get_list:
        DEBUGF 2, 'K : FTDI devices list request\n'  
        mov     edi, [edi+output]
        xor     ecx, ecx
        call    linkedlist_gethead
        test    eax, eax
        jz      .emptylist
        push    edi
        add     edi, 4         
  .nextdev:
        inc     ecx
        cmp     [eax + ftdi_context.lockPID], 0
        jnz      .dev_is_locked        
        mov     dword[edi], 'NLKD'
        jmp     .nextfields
  .dev_is_locked:
        mov     dword[edi], 'LCKD'
  .nextfields:
        mov     bl, [eax + ftdi_context.chipType]
        mov     [edi+4], ebx
        mov     [edi+8], eax
        add     edi, 12
        mov     eax, [eax + ftdi_context.next_context]
        test    eax, eax
        jnz     .nextdev
        pop     edi
  .emptylist:
        mov     [edi], ecx
        jmp     .endswitch
 
  .ftdi_lock:
        DEBUGF 2, 'K : FTDI Lock PID: %d Dev handler 0x0x%x\n', [edi], [edi+4]  
        mov     esi, [edi+input]
        mov     ebx, [esi+4]
        mov     eax, [ebx + ftdi_context.lockPID]
        test    eax, eax
        jnz     .lockedby
        mov     eax, [esi]
        mov     [ebx + ftdi_context.lockPID], eax
  .lockedby:
        mov     edi, [edi+output]
        mov     [edi], eax
        jmp     .endswitch
        
  .ftdi_unlock:
        DEBUGF 2, 'K : FTDI Unlock PID: %d Dev handler 0x0x%x\n', [edi], [edi+4]
        mov     esi, [edi+input]
        mov     edi, [edi+output]
        mov     ebx, [esi+4]
        mov     eax, [ebx + ftdi_context.lockPID]
        cmp     eax, [esi]
        jnz     .unlockimp
        mov     [ebx + ftdi_context.lockPID], 0
        mov     dword[edi], 0
        jmp     .endswitch   
  .unlockimp:     
        mov     [edi], eax
        jmp     .endswitch 
 
H_CLK = 120000000
C_CLK = 48000000        
  .ftdi_set_baudrate:
        DEBUGF 2, 'K : FTDI Set baudrate to %d PID: %d Dev handle: 0x%x\n',\
                   [edi+8], [edi], [edi+4]
        mov     ebx, [edi+4]
        cmp     [ebx + ftdi_context.chipType], TYPE_2232H
        jl      .c_clk        
        imul    eax, [edi+8], 10
        cmp     eax, H_CLK / 0x3FFF        
        jle     .c_clk
  .h_clk:
        cmp     dword[edi+8], H_CLK/10
        jl      .h_nextbaud1
        xor     edx, edx
        mov     ecx, H_CLK/10
        jmp     .calcend
        
  .c_clk:
        cmp     dword[edi+8], C_CLK/16
        jl      .c_nextbaud1
        xor     edx, edx
        mov     ecx, C_CLK/16
        jmp     .calcend  
  
  .h_nextbaud1:
        cmp     dword[edi+8], H_CLK/(10 + 10/2)
        jl      .h_nextbaud2
        mov     edx, 1
        mov     ecx, H_CLK/(10 + 10/2)
        jmp     .calcend
        
  .c_nextbaud1:
        cmp     dword[edi+8], C_CLK/(16 + 16/2)
        jl      .c_nextbaud2
        mov     edx, 1
        mov     ecx, C_CLK/(16 + 16/2)
        jmp     .calcend        
        
  .h_nextbaud2:
        cmp     dword[edi+8], H_CLK/(2*10)
        jl      .h_nextbaud3
        mov     edx, 2
        mov     ecx, H_CLK/(2*10)
        jmp     .calcend
        
  .c_nextbaud2:  
        cmp     dword[edi+8], C_CLK/(2*16)
        jl      .c_nextbaud3
        mov     edx, 2
        mov     ecx, C_CLK/(2*16)
        jmp     .calcend        
        
  .h_nextbaud3:
        mov     eax, H_CLK*16/10  ; eax - best_divisor
        xor     edx, edx
        div     dword[edi+8]      ; [edi+8] - baudrate
        push    eax
        and     eax, 1
        pop     eax
        shr     eax, 1
        jz      .h_rounddowndiv     ; jump by result of and eax, 1
        inc     eax
  .h_rounddowndiv:
        cmp     eax, 0x20000
        jle     .h_best_divok
        mov     eax, 0x1FFFF
  .h_best_divok:
        mov     ecx, eax        
        mov     eax, H_CLK*16/10
        xor     edx, edx
        div     ecx
        xchg    ecx, eax            ; ecx - best_baud
        push    ecx
        and     ecx, 1
        pop     ecx
        shr     ecx, 1
        jz      .rounddownbaud
        inc     ecx
        jmp     .rounddownbaud
        
  .c_nextbaud3:
        mov     eax, C_CLK        ; eax - best_divisor
        xor     edx, edx
        div     dword[edi+8]      ; [edi+8] - baudrate
        push    eax
        and     eax, 1
        pop     eax
        shr     eax, 1
        jnz     .c_rounddowndiv     ; jump by result of and eax, 1
        inc     eax
  .c_rounddowndiv:
        cmp     eax, 0x20000
        jle     .c_best_divok
        mov     eax, 0x1FFFF
  .c_best_divok:
        mov     ecx, eax        
        mov     eax, C_CLK
        xor     edx, edx
        div     ecx
        xchg    ecx, eax            ; ecx - best_baud
        push    ecx
        and     ecx, 1
        pop     ecx
        shr     ecx, 1
        jnz     .rounddownbaud
        inc     ecx
        
  .rounddownbaud:
        mov     edx, eax            ; edx - encoded_divisor
        shr     edx, 3
        and     eax, 0x7      
        push    7 6 5 1 4 2 3 0               
        mov     eax, [esp+eax*4]
        shl     eax, 14
        or      edx, eax        
        add     esp, 32
        
  .calcend:
        mov     eax, edx        ; eax - *value
        mov     ecx, edx        ; ecx - *index
        and     eax, 0xFFFF
        cmp     [ebx + ftdi_context.chipType], TYPE_2232H
        jge     .foxyindex        
        shr     ecx, 16
        jmp     .preparepacket
  .foxyindex:
        shr     ecx, 8
        and     ecx, 0xFF00
        or      ecx, [ebx + ftdi_context.index]
        
  .preparepacket:
        mov     word[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
                                + (SIO_SET_BAUDRATE_REQUEST shl 8)
        mov     word[ConfPacket+2], ax
        mov     word[ConfPacket+4], cx
        mov     word[ConfPacket+6], 0
        jmp     .own_index        
        
endp 
restore   handle
restore   io_code
restore   input
restore   inp_size
restore   output
restore   out_size 
 
 
proc control_callback stdcall uses ebx edi esi, .pipe:DWORD, .status:DWORD, \
                               .buffer:DWORD, .length:DWORD, .calldata:DWORD   
   
        DEBUGF 1, 'K : status is %d\n', [.status] 
        mov     ecx, [.calldata]
        mov     eax, [ecx]
        mov     ebx, [ecx+4]
        mov     edx, [.status]
        mov     [ecx+8], edx
        xor     esi, esi
        xor     edx, edx
        invoke  RaiseEvent              
        ret
endp
 
proc bulk_callback stdcall uses ebx edi esi, .pipe:DWORD, .status:DWORD, \
                            .buffer:DWORD, .length:DWORD, .calldata:DWORD
 
        DEBUGF 1, 'K : status is %d\n', [.status]        
        mov     ecx, [.calldata]
        mov     eax, [ecx]
        mov     ebx, [ecx+4]
        cmp     [.status], 0
        jz      .normal
        cmp     [.status], 9
        jne     .error
  .normal:
        mov     edx, [.length]
        mov     [ecx+8], edx
        jmp     .ok
  .error:
        mov     [ecx+8], dword -1
  .ok:    
        xor     esi, esi
        xor     edx, edx
        invoke  RaiseEvent            
        ret
endp
 
proc DeviceDisconnected stdcall uses  ebx esi edi, .device_data:DWORD
 
        DEBUGF 1, 'K : FTDI deleting device data 0x%x\n', [.device_data]
        mov     eax, [.device_data] 
        call    linkedlist_unlink
        invoke  Kfree
        ret           
endp
 
include 'linkedlist.inc'
 
align 4
 
; Structure with callback functions.
usb_functions:
        dd      12
        dd      AddDevice
        dd      DeviceDisconnected
 
data fixups
end data        
        
;for DEBUGF macro
include_debug_strings

Rev 5363	Rev 7552
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2015. 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	;; FTDI chips driver for KolibriOS ;;	6	;; FTDI chips driver for KolibriOS ;;
7	;; ;;	7	;; ;;
8	;; Written by gtament@gmail.com ;;	8	;; Written by gtament@gmail.com ;;
9	;; ;;	9	;; ;;
10	;; GNU GENERAL PUBLIC LICENSE ;;	10	;; GNU GENERAL PUBLIC LICENSE ;;
11	;; Version 2, June 1991 ;;	11	;; Version 2, June 1991 ;;
12	;; ;;	12	;; ;;
13	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	13	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
14		14
15	format PE DLL native 0.05	15	format PE DLL native 0.05
-		16	entry START
16		17
17	DEBUG = 1	18	DEBUG = 1
18		19
19	__DEBUG__ = 1	20	__DEBUG__ = 1
20	__DEBUG_LEVEL__ = 1	21	__DEBUG_LEVEL__ = 1
21		22
22	node equ ftdi_context	23	node equ ftdi_context
23	node.next equ ftdi_context.next_context	24	node.next equ ftdi_context.next_context
24		25
25	include '../../proc32.inc'	26	include '../../proc32.inc'
26	include '../../peimport.inc'	27	include '../../peimport.inc'
27	include '../../fdo.inc'	28	include '../../fdo.inc'
28	include '../../struct.inc'	29	include '../../struct.inc'
29		30
30	; USB constants	31	; USB constants
31	DEVICE_DESCR_TYPE = 1	32	DEVICE_DESCR_TYPE = 1
32	CONFIG_DESCR_TYPE = 2	33	CONFIG_DESCR_TYPE = 2
33	STRING_DESCR_TYPE = 3	34	STRING_DESCR_TYPE = 3
34	INTERFACE_DESCR_TYPE = 4	35	INTERFACE_DESCR_TYPE = 4
35	ENDPOINT_DESCR_TYPE = 5	36	ENDPOINT_DESCR_TYPE = 5
36	DEVICE_QUALIFIER_DESCR_TYPE = 6	37	DEVICE_QUALIFIER_DESCR_TYPE = 6
37		38
38	CONTROL_PIPE = 0	39	CONTROL_PIPE = 0
39	ISOCHRONOUS_PIPE = 1	40	ISOCHRONOUS_PIPE = 1
40	BULK_PIPE = 2	41	BULK_PIPE = 2
41	INTERRUPT_PIPE = 3	42	INTERRUPT_PIPE = 3
42		43
43	; USB HID constants	44	; USB HID constants
44	HID_DESCR_TYPE = 21h	45	HID_DESCR_TYPE = 21h
45	REPORT_DESCR_TYPE = 22h	46	REPORT_DESCR_TYPE = 22h
46	PHYSICAL_DESCR_TYPE = 23h	47	PHYSICAL_DESCR_TYPE = 23h
47		48
48	; LibUSB constatnts	49	; LibUSB constatnts
49	LIBUSB_REQUEST_TYPE_STANDARD = (0x00 shl 5)	50	LIBUSB_REQUEST_TYPE_STANDARD = (0x00 shl 5)
50	LIBUSB_REQUEST_TYPE_CLASS = (0x01 shl 5)	51	LIBUSB_REQUEST_TYPE_CLASS = (0x01 shl 5)
51	LIBUSB_REQUEST_TYPE_VENDOR = (0x02 shl 5)	52	LIBUSB_REQUEST_TYPE_VENDOR = (0x02 shl 5)
52	LIBUSB_REQUEST_TYPE_RESERVED = (0x03 shl 5)	53	LIBUSB_REQUEST_TYPE_RESERVED = (0x03 shl 5)
53		54
54	LIBUSB_RECIPIENT_DEVICE = 0x00	55	LIBUSB_RECIPIENT_DEVICE = 0x00
55	LIBUSB_RECIPIENT_INTERFACE = 0x01	56	LIBUSB_RECIPIENT_INTERFACE = 0x01
56	LIBUSB_RECIPIENT_ENDPOINT = 0x02	57	LIBUSB_RECIPIENT_ENDPOINT = 0x02
57	LIBUSB_RECIPIENT_OTHER = 0x03	58	LIBUSB_RECIPIENT_OTHER = 0x03
58		59
59	LIBUSB_ENDPOINT_IN = 0x80	60	LIBUSB_ENDPOINT_IN = 0x80
60	LIBUSB_ENDPOINT_OUT = 0x00	61	LIBUSB_ENDPOINT_OUT = 0x00
61		62
62	; FTDI Constants	63	; FTDI Constants
63	FTDI_DEVICE_OUT_REQTYPE = (LIBUSB_REQUEST_TYPE_VENDOR or LIBUSB_RECIPIENT_DEVICE or LIBUSB_ENDPOINT_OUT)	64	FTDI_DEVICE_OUT_REQTYPE = (LIBUSB_REQUEST_TYPE_VENDOR or LIBUSB_RECIPIENT_DEVICE or LIBUSB_ENDPOINT_OUT)
64	FTDI_DEVICE_IN_REQTYPE = (LIBUSB_REQUEST_TYPE_VENDOR or LIBUSB_RECIPIENT_DEVICE or LIBUSB_ENDPOINT_IN)	65	FTDI_DEVICE_IN_REQTYPE = (LIBUSB_REQUEST_TYPE_VENDOR or LIBUSB_RECIPIENT_DEVICE or LIBUSB_ENDPOINT_IN)
65		66
66	; Requests	67	; Requests
67	;Definitions for flow control	68	;Definitions for flow control
68	SIO_RESET =0 ;Reset the port	69	SIO_RESET =0 ;Reset the port
69	SIO_MODEM_CTRL =1 ;Set the modem control register	70	SIO_MODEM_CTRL =1 ;Set the modem control register
70	SIO_SET_FLOW_CTRL =2 ;Set flow control register	71	SIO_SET_FLOW_CTRL =2 ;Set flow control register
71	SIO_SET_BAUD_RATE =3 ;Set baud rate	72	SIO_SET_BAUD_RATE =3 ;Set baud rate
72	SIO_SET_DATA =4 ;Set the data characteristics of the port	73	SIO_SET_DATA =4 ;Set the data characteristics of the port
73		74
74	SIO_RESET_REQUEST =SIO_RESET	75	SIO_RESET_REQUEST =SIO_RESET
75	SIO_SET_BAUDRATE_REQUEST =SIO_SET_BAUD_RATE	76	SIO_SET_BAUDRATE_REQUEST =SIO_SET_BAUD_RATE
76	SIO_SET_DATA_REQUEST =SIO_SET_DATA	77	SIO_SET_DATA_REQUEST =SIO_SET_DATA
77	SIO_SET_FLOW_CTRL_REQUEST =SIO_SET_FLOW_CTRL	78	SIO_SET_FLOW_CTRL_REQUEST =SIO_SET_FLOW_CTRL
78	SIO_SET_MODEM_CTRL_REQUEST =SIO_MODEM_CTRL	79	SIO_SET_MODEM_CTRL_REQUEST =SIO_MODEM_CTRL
79	SIO_POLL_MODEM_STATUS_REQUEST=0x05	80	SIO_POLL_MODEM_STATUS_REQUEST=0x05
80	SIO_SET_EVENT_CHAR_REQUEST =0x06	81	SIO_SET_EVENT_CHAR_REQUEST =0x06
81	SIO_SET_ERROR_CHAR_REQUEST =0x07	82	SIO_SET_ERROR_CHAR_REQUEST =0x07
82	SIO_SET_LATENCY_TIMER_REQUEST=0x09	83	SIO_SET_LATENCY_TIMER_REQUEST=0x09
83	SIO_GET_LATENCY_TIMER_REQUEST=0x0A	84	SIO_GET_LATENCY_TIMER_REQUEST=0x0A
84	SIO_SET_BITMODE_REQUEST =0x0B	85	SIO_SET_BITMODE_REQUEST =0x0B
85	SIO_READ_PINS_REQUEST =0x0C	86	SIO_READ_PINS_REQUEST =0x0C
86	SIO_READ_EEPROM_REQUEST =0x90	87	SIO_READ_EEPROM_REQUEST =0x90
87	SIO_WRITE_EEPROM_REQUEST =0x91	88	SIO_WRITE_EEPROM_REQUEST =0x91
88	SIO_ERASE_EEPROM_REQUEST =0x92	89	SIO_ERASE_EEPROM_REQUEST =0x92
89		90
90		91
91	SIO_RESET_SIO=0	92	SIO_RESET_SIO=0
92	SIO_RESET_PURGE_RX=1	93	SIO_RESET_PURGE_RX=1
93	SIO_RESET_PURGE_TX=2	94	SIO_RESET_PURGE_TX=2
94		95
95	SIO_DISABLE_FLOW_CTRL=0x0	96	SIO_DISABLE_FLOW_CTRL=0x0
96	SIO_RTS_CTS_HS =(0x1 shl 8)	97	SIO_RTS_CTS_HS =(0x1 shl 8)
97	SIO_DTR_DSR_HS =(0x2 shl 8)	98	SIO_DTR_DSR_HS =(0x2 shl 8)
98	SIO_XON_XOFF_HS=(0x4 shl 8)	99	SIO_XON_XOFF_HS=(0x4 shl 8)
99		100
100	SIO_SET_DTR_MASK=0x1	101	SIO_SET_DTR_MASK=0x1
101	SIO_SET_DTR_HIGH=( 1 or ( SIO_SET_DTR_MASK shl 8))	102	SIO_SET_DTR_HIGH=( 1 or ( SIO_SET_DTR_MASK shl 8))
102	SIO_SET_DTR_LOW =( 0 or ( SIO_SET_DTR_MASK shl 8))	103	SIO_SET_DTR_LOW =( 0 or ( SIO_SET_DTR_MASK shl 8))
103	SIO_SET_RTS_MASK=0x2	104	SIO_SET_RTS_MASK=0x2
104	SIO_SET_RTS_HIGH=( 2 or ( SIO_SET_RTS_MASK shl 8 ))	105	SIO_SET_RTS_HIGH=( 2 or ( SIO_SET_RTS_MASK shl 8 ))
105	SIO_SET_RTS_LOW =( 0 or ( SIO_SET_RTS_MASK shl 8 ))	106	SIO_SET_RTS_LOW =( 0 or ( SIO_SET_RTS_MASK shl 8 ))
106		107
107	SIO_RTS_CTS_HS =(0x1 shl 8)	108	SIO_RTS_CTS_HS =(0x1 shl 8)
108		109
109	;FTDI chip type	110	;FTDI chip type
110	TYPE_AM=0	111	TYPE_AM=0
111	TYPE_BM=1	112	TYPE_BM=1
112	TYPE_2232C=2	113	TYPE_2232C=2
113	TYPE_R=3	114	TYPE_R=3
114	TYPE_2232H=4	115	TYPE_2232H=4
115	TYPE_4232H=5	116	TYPE_4232H=5
116	TYPE_232H=6	117	TYPE_232H=6
117	TYPE_230X=7	118	TYPE_230X=7
118		119
119	;strings	120	;strings
120	my_driver db 'usbother',0	121	my_driver db 'usbother',0
121	nomemory_msg db 'K : no memory',13,10,0	122	nomemory_msg db 'K : no memory',13,10,0
122		123
123	; Structures	124	; Structures
124	struct ftdi_context	125	struct ftdi_context
125	chipType db ?	126	chipType db ?
126	baudrate dd ?	127	baudrate dd ?
127	bitbangEnabled db ?	128	bitbangEnabled db ?
128	readBufChunkSize dd ?	129	readBufChunkSize dd ?
129	writeBufChunkSize dd ?	130	writeBufChunkSize dd ?
130	readBufPtr dd ?	131	readBufPtr dd ?
131	writeBufPtr dd ?	132	writeBufPtr dd ?
132	readBufSize dd ?	133	readBufSize dd ?
133	writeBufSize dd ?	134	writeBufSize dd ?
134	maxPacketSize dd ?	135	maxPacketSize dd ?
135	interface dd ?	136	interface dd ?
136	index dd ?	137	index dd ?
137	inEP dd ?	138	inEP dd ?
138	outEP dd ?	139	outEP dd ?
139	nullP dd ?	140	nullP dd ?
140	lockPID dd ?	141	lockPID dd ?
141	next_context dd ?	142	next_context dd ?
142	ends	143	ends
143		144
144	struct IOCTL	145	struct IOCTL
145	handle dd ?	146	handle dd ?
146	io_code dd ?	147	io_code dd ?
147	input dd ?	148	input dd ?
148	inp_size dd ?	149	inp_size dd ?
149	output dd ?	150	output dd ?
150	out_size dd ?	151	out_size dd ?
151	ends	152	ends
152		153
153	struct usb_descr	154	struct usb_descr
154	bLength db ?	155	bLength db ?
155	bDescriptorType db ?	156	bDescriptorType db ?
156	bcdUSB dw ?	157	bcdUSB dw ?
157	bDeviceClass db ?	158	bDeviceClass db ?
158	bDeviceSubClass db ?	159	bDeviceSubClass db ?
159	bDeviceProtocol db ?	160	bDeviceProtocol db ?
160	bMaxPacketSize0 db ?	161	bMaxPacketSize0 db ?
161	idVendor dw ?	162	idVendor dw ?
162	idProduct dw ?	163	idProduct dw ?
163	bcdDevice dw ?	164	bcdDevice dw ?
164	iManufacturer db ?	165	iManufacturer db ?
165	iProduct db ?	166	iProduct db ?
166	iSerialNumber db ?	167	iSerialNumber db ?
167	bNumConfigurations db ?	168	bNumConfigurations db ?
168	ends	169	ends
169		170
170	struct conf_packet	171	struct conf_packet
171	bmRequestType db ?	172	bmRequestType db ?
172	bRequest db ?	173	bRequest db ?
173	wValue dw ?	174	wValue dw ?
174	wIndex dw ?	175	wIndex dw ?
175	wLength dw ?	176	wLength dw ?
176	ends	177	ends
177		178
178	section '.flat' code readable executable	179	section '.flat' code readable executable
179	; The start procedure.	180	; The start procedure.
180	proc START c, .reason:DWORD, .cmdline:DWORD	181	proc START c, .reason:DWORD, .cmdline:DWORD
181		182
182	xor eax, eax ; initialize return value	183	xor eax, eax ; initialize return value
183	cmp [.reason], 1 ; compare the argument	184	cmp [.reason], 1 ; compare the argument
184	jnz .nothing	185	jnz .nothing
185	invoke RegUSBDriver, my_driver, service_proc, usb_functions	186	invoke RegUSBDriver, my_driver, service_proc, usb_functions
186		187
187	.nothing:	188	.nothing:
188	ret	189	ret
189	endp	190	endp
190		191
191		192
192	proc AddDevice stdcall uses ebx esi edi, .config_pipe:DWORD, .config_descr:DWORD, .interface:DWORD	193	proc AddDevice stdcall uses ebx esi edi, .config_pipe:DWORD, .config_descr:DWORD, .interface:DWORD
193		194
194	invoke USBGetParam, [.config_pipe], 0	195	invoke USBGetParam, [.config_pipe], 0
195	mov edx, eax	196	mov edx, eax
196	DEBUGF 2,'K : Detected device vendor: 0x%x\n', [eax+usb_descr.idVendor]	197	DEBUGF 2,'K : Detected device vendor: 0x%x\n', [eax+usb_descr.idVendor]
197	cmp word[eax+usb_descr.idVendor], 0x0403	198	cmp word[eax+usb_descr.idVendor], 0x0403
198	jnz .notftdi	199	jnz .notftdi
199	mov eax, sizeof.ftdi_context	200	mov eax, sizeof.ftdi_context
200	invoke Kmalloc	201	invoke Kmalloc
201	test eax, eax	202	test eax, eax
202	jnz @f	203	jnz @f
203	mov esi, nomemory_msg	204	mov esi, nomemory_msg
204	invoke SysMsgBoardStr	205	invoke SysMsgBoardStr
205	jmp .nothing	206	jmp .nothing
206	@@:	207	@@:
207	DEBUGF 2,'K : Adding struct to list 0x%x\n', eax	208	DEBUGF 2,'K : Adding struct to list 0x%x\n', eax
208	call linkedlist_add	209	call linkedlist_add
209		210
210	mov ebx, [.config_pipe]	211	mov ebx, [.config_pipe]
211	mov [eax + ftdi_context.nullP], ebx	212	mov [eax + ftdi_context.nullP], ebx
212	mov [eax + ftdi_context.index], 0	213	mov [eax + ftdi_context.index], 0
213	mov [eax + ftdi_context.lockPID], 0	214	mov [eax + ftdi_context.lockPID], 0
214	mov [eax + ftdi_context.maxPacketSize], 64	215	mov [eax + ftdi_context.maxPacketSize], 64
215	mov [eax + ftdi_context.readBufChunkSize], 64	216	mov [eax + ftdi_context.readBufChunkSize], 64
216	mov [eax + ftdi_context.writeBufChunkSize], 64	217	mov [eax + ftdi_context.writeBufChunkSize], 64
217		218
218	mov [eax + ftdi_context.chipType], TYPE_R	219	mov [eax + ftdi_context.chipType], TYPE_R
219	jmp .slow	220	jmp .slow
220		221
221	mov cx, [edx+usb_descr.bcdDevice]	222	mov cx, [edx+usb_descr.bcdDevice]
222	DEBUGF 2, 'K : Chip type 0x%x\n', ecx	223	DEBUGF 2, 'K : Chip type 0x%x\n', ecx
223	cmp cx, 0x400	224	cmp cx, 0x400
224	jnz @f	225	jnz @f
225	mov [eax + ftdi_context.chipType], TYPE_BM	226	mov [eax + ftdi_context.chipType], TYPE_BM
226	jmp .slow	227	jmp .slow
227	@@:	228	@@:
228	cmp cx, 0x200	229	cmp cx, 0x200
229	jnz @f	230	jnz @f
230	mov [eax + ftdi_context.chipType], TYPE_AM	231	mov [eax + ftdi_context.chipType], TYPE_AM
231	jmp .slow	232	jmp .slow
232	@@:	233	@@:
233	cmp cx, 0x500	234	cmp cx, 0x500
234	jnz @f	235	jnz @f
235	mov [eax + ftdi_context.chipType], TYPE_2232C	236	mov [eax + ftdi_context.chipType], TYPE_2232C
236	jmp .slow	237	jmp .slow
237	@@:	238	@@:
238	cmp cx, 0x600	239	cmp cx, 0x600
239	jnz @f	240	jnz @f
240	mov [eax + ftdi_context.chipType], TYPE_R	241	mov [eax + ftdi_context.chipType], TYPE_R
241	jmp .slow	242	jmp .slow
242	@@:	243	@@:
243	cmp cx, 0x700	244	cmp cx, 0x700
244	jnz @f	245	jnz @f
245	mov [eax + ftdi_context.chipType], TYPE_2232H	246	mov [eax + ftdi_context.chipType], TYPE_2232H
246	jmp .fast	247	jmp .fast
247	@@:	248	@@:
248	cmp cx, 0x900	249	cmp cx, 0x900
249	jnz @f	250	jnz @f
250	mov [eax + ftdi_context.chipType], TYPE_232H	251	mov [eax + ftdi_context.chipType], TYPE_232H
251	jmp .fast	252	jmp .fast
252	@@:	253	@@:
253	cmp cx, 0x1000	254	cmp cx, 0x1000
254	jnz .slow	255	jnz .slow
255	mov [eax + ftdi_context.chipType], TYPE_230X	256	mov [eax + ftdi_context.chipType], TYPE_230X
256	jmp .fast	257	jmp .fast
257		258
258	.fast:	259	.fast:
259	add [eax + ftdi_context.maxPacketSize], 512-64	260	add [eax + ftdi_context.maxPacketSize], 512-64
260	.slow:	261	.slow:
261	mov ebx, eax	262	mov ebx, eax
262	invoke USBOpenPipe, [.config_pipe], 0x81, \	263	invoke USBOpenPipe, [.config_pipe], 0x81, \
263	[ebx + ftdi_context.maxPacketSize], BULK_PIPE, 0	264	[ebx + ftdi_context.maxPacketSize], BULK_PIPE, 0
264	test eax, eax	265	test eax, eax
265	jz .nothing	266	jz .nothing
266	mov [ebx + ftdi_context.outEP], eax	267	mov [ebx + ftdi_context.outEP], eax
267	invoke USBOpenPipe, [.config_pipe], 0x02, \	268	invoke USBOpenPipe, [.config_pipe], 0x02, \
268	[ebx + ftdi_context.maxPacketSize], BULK_PIPE, 0	269	[ebx + ftdi_context.maxPacketSize], BULK_PIPE, 0
269	test eax, eax	270	test eax, eax
270	jz .nothing	271	jz .nothing
271	mov [ebx + ftdi_context.inEP], eax	272	mov [ebx + ftdi_context.inEP], eax
272	mov eax, ebx	273	mov eax, ebx
273	ret	274	ret
274		275
275	.notftdi:	276	.notftdi:
276	DEBUGF 1,'K : Skipping not FTDI device\n'	277	DEBUGF 1,'K : Skipping not FTDI device\n'
277	.nothing:	278	.nothing:
278	xor eax, eax	279	xor eax, eax
279	ret	280	ret
280	endp	281	endp
281		282
282		283
283	handle equ IOCTL.handle	284	handle equ IOCTL.handle
284	io_code equ IOCTL.io_code	285	io_code equ IOCTL.io_code
285	input equ IOCTL.input	286	input equ IOCTL.input
286	inp_size equ IOCTL.inp_size	287	inp_size equ IOCTL.inp_size
287	output equ IOCTL.output	288	output equ IOCTL.output
288	out_size equ IOCTL.out_size	289	out_size equ IOCTL.out_size
289		290
290	proc service_proc stdcall uses ebx esi edi, ioctl:DWORD	291	proc service_proc stdcall uses ebx esi edi, ioctl:DWORD
291	locals	292	locals
292	ConfPacket rb 10	293	ConfPacket rb 10
293	EventData rd 3	294	EventData rd 3
294	endl	295	endl
295	mov edi, [ioctl]	296	mov edi, [ioctl]
296	mov eax, [edi+io_code]	297	mov eax, [edi+io_code]
297	DEBUGF 1,'K : FTDI got the request: %d\n', eax	298	DEBUGF 1,'K : FTDI got the request: %d\n', eax
298	test eax, eax ;0	299	test eax, eax ;0
299	jz .version	300	jz .version
300	dec eax ;1	301	dec eax ;1
301	jz .ftdi_get_list	302	jz .ftdi_get_list
302		303
303	push eax	304	push eax
304	mov esi, [edi+input]	305	mov esi, [edi+input]
305	mov eax, [esi+4]	306	mov eax, [esi+4]
306	call linkedlist_isvalid	307	call linkedlist_isvalid
307	test eax, eax	308	test eax, eax
308	pop eax	309	pop eax
309	jnz .endswitch	310	jnz .endswitch
310		311
311	dec eax	312	dec eax
312	jz .ftdi_lock ;2	313	jz .ftdi_lock ;2
313	dec eax	314	dec eax
314	jz .ftdi_unlock ;3	315	jz .ftdi_unlock ;3
315		316
316	mov ebx, [esi+4]	317	mov ebx, [esi+4]
317	mov ecx, [ebx + ftdi_context.lockPID]	318	mov ecx, [ebx + ftdi_context.lockPID]
318	cmp dword[esi], 0	319	cmp dword[esi], 0
319	jz .error	320	jz .error
320	cmp ecx, [esi]	321	cmp ecx, [esi]
321	jz .pid_ok	322	jz .pid_ok
322	mov esi, [edi+output]	323	mov esi, [edi+output]
323	mov dword[esi], 'LCKD'	324	mov dword[esi], 'LCKD'
324	jmp .endswitch	325	jmp .endswitch
325		326
326	.pid_ok:	327	.pid_ok:
327	dec eax	328	dec eax
328	jz .ftdi_get_wchunksize ;4	329	jz .ftdi_get_wchunksize ;4
329	dec eax	330	dec eax
330	jz .ftdi_get_rchunksize ;5	331	jz .ftdi_get_rchunksize ;5
331		332
332	mov edi, [edi+input]	333	mov edi, [edi+input]
333		334
334	dec eax	335	dec eax
335	jz .ftdi_set_rchunksize ;6	336	jz .ftdi_set_rchunksize ;6
336	dec eax	337	dec eax
337	jz .ftdi_set_wchunksize ;7	338	jz .ftdi_set_wchunksize ;7
338		339
339	push eax edi	340	push eax edi
340	mov ecx, 0x80000000	341	mov ecx, 0x80000000
341	cmp eax, 8-7	342	cmp eax, 8-7
342	je .bulkevent	343	je .bulkevent
343	cmp eax, 9-7	344	cmp eax, 9-7
344	je .bulkevent	345	je .bulkevent
345	xor ecx, ecx	346	xor ecx, ecx
346	.bulkevent:	347	.bulkevent:
347	xor esi, esi	348	xor esi, esi
348	invoke CreateEvent	349	invoke CreateEvent
349	mov [EventData], eax	350	mov [EventData], eax
350	mov [EventData+4], edx	351	mov [EventData+4], edx
351	pop edi eax	352	pop edi eax
352		353
353	dec eax ;8	354	dec eax ;8
354	jz .ftdi_write_data	355	jz .ftdi_write_data
355	dec eax ;9	356	dec eax ;9
356	jz .ftdi_read_data	357	jz .ftdi_read_data
357	dec eax ;10	358	dec eax ;10
358	jz .ftdi_set_baudrate	359	jz .ftdi_set_baudrate
359	dec eax ;11	360	dec eax ;11
360	jz .ftdi_set_bitmode	361	jz .ftdi_set_bitmode
361	dec eax ;12	362	dec eax ;12
362	jz .ftdi_setrtshigh	363	jz .ftdi_setrtshigh
363	dec eax ;13	364	dec eax ;13
364	jz .ftdi_setrtslow	365	jz .ftdi_setrtslow
365	dec eax ;14	366	dec eax ;14
366	jz .ftdi_setdtrhigh	367	jz .ftdi_setdtrhigh
367	dec eax ;15	368	dec eax ;15
368	jz .ftdi_setdtrlow	369	jz .ftdi_setdtrlow
369	dec eax ;16	370	dec eax ;16
370	jz .ftdi_usb_reset	371	jz .ftdi_usb_reset
371	dec eax ;17	372	dec eax ;17
372	jz .ftdi_setflowctrl	373	jz .ftdi_setflowctrl
373	dec eax ;18	374	dec eax ;18
374	jz .ftdi_set_event_char	375	jz .ftdi_set_event_char
375	dec eax ;19	376	dec eax ;19
376	jz .ftdi_set_error_char	377	jz .ftdi_set_error_char
377	dec eax ;20	378	dec eax ;20
378	jz .ftdi_set_latency_timer	379	jz .ftdi_set_latency_timer
379	dec eax ;21	380	dec eax ;21
380	jz .ftdi_get_latency_timer	381	jz .ftdi_get_latency_timer
381	dec eax ;22	382	dec eax ;22
382	jz .ftdi_read_pins	383	jz .ftdi_read_pins
383	dec eax ;23	384	dec eax ;23
384	jz .ftdi_poll_modem_status	385	jz .ftdi_poll_modem_status
385	dec eax ;24	386	dec eax ;24
386	jz .ftdi_set_line_property	387	jz .ftdi_set_line_property
387	dec eax ;25	388	dec eax ;25
388	jz .ftdi_purge_rx_buf	389	jz .ftdi_purge_rx_buf
389	dec eax ;26	390	dec eax ;26
390	jz .ftdi_purge_tx_buf	391	jz .ftdi_purge_tx_buf
391	jmp .error	392	jmp .error
392		393
393	.version:	394	.version:
394	jmp .endswitch	395	jmp .endswitch
395	.error:	396	.error:
396	DEBUGF 1, 'K : FTDI error occured! %d\n', eax	397	DEBUGF 1, 'K : FTDI error occured! %d\n', eax
397	;mov esi, [edi+output]	398	;mov esi, [edi+output]
398	;mov [esi], dword 'ERR0'	399	;mov [esi], dword 'ERR0'
399	;or [esi], eax	400	;or [esi], eax
400	ret	401	ret
401	.endswitch:	402	.endswitch:
402	xor eax, eax	403	xor eax, eax
403	ret	404	ret
404		405
405	.eventdestroy:	406	.eventdestroy:
406	;---Dirty hack begin	407	;---Dirty hack begin
407	test eax, eax	408	test eax, eax
408	jz @f	409	jz @f
409	mov eax, dword[ConfPacket]	410	mov eax, dword[ConfPacket]
410	invoke Kfree	411	invoke Kfree
411	@@:	412	@@:
412	;---Dirty hack end	413	;---Dirty hack end
413	mov eax, [EventData]	414	mov eax, [EventData]
414	mov ebx, [EventData+4]	415	mov ebx, [EventData+4]
415	invoke DestroyEvent	416	invoke DestroyEvent
416	jmp .endswitch	417	jmp .endswitch
417		418
418	.ftdi_out_control_transfer_withinp:	419	.ftdi_out_control_transfer_withinp:
419	mov dx, word[edi+8]	420	mov dx, word[edi+8]
420	mov word[ConfPacket+2], dx	421	mov word[ConfPacket+2], dx
421	.ftdi_out_control_transfer_noinp:	422	.ftdi_out_control_transfer_noinp:
422	mov ebx, [edi+4]	423	mov ebx, [edi+4]
423	mov cx, word[ebx + ftdi_context.index]	424	mov cx, word[ebx + ftdi_context.index]
424	mov word[ConfPacket+4], cx	425	mov word[ConfPacket+4], cx
425	xor cx, cx	426	xor cx, cx
426	mov word[ConfPacket+6], cx	427	mov word[ConfPacket+6], cx
427	.own_index:	428	.own_index:
428	mov ebx, [edi+4]	429	mov ebx, [edi+4]
429	DEBUGF 2,'K : ConfPacket 0x%x 0x%x\n', [ConfPacket], [ConfPacket+4]	430	DEBUGF 2,'K : ConfPacket 0x%x 0x%x\n', [ConfPacket], [ConfPacket+4]
430	lea esi, [ConfPacket]	431	lea esi, [ConfPacket]
431	lea edi, [EventData]	432	lea edi, [EventData]
432	invoke USBControlTransferAsync, [ebx + ftdi_context.nullP], esi, 0,\	433	invoke USBControlTransferAsync, [ebx + ftdi_context.nullP], esi, 0,\
433	0, control_callback, edi, 0	434	0, control_callback, edi, 0
434	test eax, eax	435	test eax, eax
435	jz .error	436	jz .error
436	mov eax, [EventData]	437	mov eax, [EventData]
437	mov ebx, [EventData+4]	438	mov ebx, [EventData+4]
438	invoke WaitEvent	439	invoke WaitEvent
439	mov eax, [EventData+8]	440	mov eax, [EventData+8]
440	test eax, eax	441	test eax, eax
441	jz .endswitch	442	jz .endswitch
442	jmp .error	443	jmp .error
443		444
444	.ftdi_setrtshigh:	445	.ftdi_setrtshigh:
445	DEBUGF 2,'K : FTDI Setting RTS pin HIGH PID: %d Dev handler 0x0x%x\n', [edi],\	446	DEBUGF 2,'K : FTDI Setting RTS pin HIGH PID: %d Dev handler 0x0x%x\n', [edi],\
446	[edi+4]	447	[edi+4]
447	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \	448	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
448	+ (SIO_SET_MODEM_CTRL_REQUEST shl 8) \	449	+ (SIO_SET_MODEM_CTRL_REQUEST shl 8) \
449	+ (SIO_SET_RTS_HIGH shl 16)	450	+ (SIO_SET_RTS_HIGH shl 16)
450	jmp .ftdi_out_control_transfer_noinp	451	jmp .ftdi_out_control_transfer_noinp
451		452
452	.ftdi_setrtslow:	453	.ftdi_setrtslow:
453	DEBUGF 2,'K : FTDI Setting RTS pin LOW PID: %d Dev handler 0x0x%x\n', [edi],\	454	DEBUGF 2,'K : FTDI Setting RTS pin LOW PID: %d Dev handler 0x0x%x\n', [edi],\
454	[edi+4]	455	[edi+4]
455	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \	456	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
456	+ (SIO_SET_MODEM_CTRL_REQUEST shl 8) \	457	+ (SIO_SET_MODEM_CTRL_REQUEST shl 8) \
457	+ (SIO_SET_RTS_LOW shl 16)	458	+ (SIO_SET_RTS_LOW shl 16)
458	jmp .ftdi_out_control_transfer_noinp	459	jmp .ftdi_out_control_transfer_noinp
459		460
460	.ftdi_setdtrhigh:	461	.ftdi_setdtrhigh:
461	DEBUGF 2,'K : FTDI Setting DTR pin HIGH PID: %d Dev handler 0x0x%x\n', [edi],\	462	DEBUGF 2,'K : FTDI Setting DTR pin HIGH PID: %d Dev handler 0x0x%x\n', [edi],\
462	[edi+4]	463	[edi+4]
463	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \	464	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
464	+ (SIO_SET_MODEM_CTRL_REQUEST shl 8) \	465	+ (SIO_SET_MODEM_CTRL_REQUEST shl 8) \
465	+ (SIO_SET_DTR_HIGH shl 16)	466	+ (SIO_SET_DTR_HIGH shl 16)
466	jmp .ftdi_out_control_transfer_noinp	467	jmp .ftdi_out_control_transfer_noinp
467		468
468	.ftdi_setdtrlow:	469	.ftdi_setdtrlow:
469	DEBUGF 2,'K : FTDI Setting DTR pin LOW PID: %d Dev handler 0x0x%x\n', [edi],\	470	DEBUGF 2,'K : FTDI Setting DTR pin LOW PID: %d Dev handler 0x0x%x\n', [edi],\
470	[edi+4]	471	[edi+4]
471	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \	472	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
472	+ (SIO_SET_MODEM_CTRL_REQUEST shl 8) \	473	+ (SIO_SET_MODEM_CTRL_REQUEST shl 8) \
473	+ (SIO_SET_DTR_LOW shl 16)	474	+ (SIO_SET_DTR_LOW shl 16)
474	jmp .ftdi_out_control_transfer_noinp	475	jmp .ftdi_out_control_transfer_noinp
475		476
476	.ftdi_usb_reset:	477	.ftdi_usb_reset:
477	DEBUGF 2,'K : FTDI Reseting PID: %d Dev handler 0x0x%x\n', [edi],\	478	DEBUGF 2,'K : FTDI Reseting PID: %d Dev handler 0x0x%x\n', [edi],\
478	[edi+4]	479	[edi+4]
479	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \	480	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
480	+ (SIO_RESET_REQUEST shl 8) \+	481	+ (SIO_RESET_REQUEST shl 8) \
481	(SIO_RESET_SIO shl 16)	482	+ (SIO_RESET_SIO shl 16)
482	jmp .ftdi_out_control_transfer_noinp	483	jmp .ftdi_out_control_transfer_noinp
483		484
484	.ftdi_purge_rx_buf:	485	.ftdi_purge_rx_buf:
485	DEBUGF 2, 'K : FTDI Purge TX buffer PID: %d Dev handler 0x0x%x\n', [edi],\	486	DEBUGF 2, 'K : FTDI Purge TX buffer PID: %d Dev handler 0x0x%x\n', [edi],\
486	[edi+4]	487	[edi+4]
487	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \	488	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
488	+ (SIO_RESET_REQUEST shl 8) \	489	+ (SIO_RESET_REQUEST shl 8) \
489	+ (SIO_RESET_PURGE_RX shl 16)	490	+ (SIO_RESET_PURGE_RX shl 16)
490	jmp .ftdi_out_control_transfer_noinp	491	jmp .ftdi_out_control_transfer_noinp
491		492
492	.ftdi_purge_tx_buf:	493	.ftdi_purge_tx_buf:
493	DEBUGF 2, 'K : FTDI Purge RX buffer PID: %d Dev handler 0x0x%x\n', [edi],\	494	DEBUGF 2, 'K : FTDI Purge RX buffer PID: %d Dev handler 0x0x%x\n', [edi],\
494	[edi+4]	495	[edi+4]
495	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \	496	mov dword[ConfPacket], (FTDI_DEVICE_OUT_REQTYPE) \
496	+ (SIO_RESET_REQUEST shl 8) \	497	+ (SIO_RESET_REQUEST shl 8) \
497	+ (SIO_RESET_PURGE_TX shl 16)	498	+ (SIO_RESET_PURGE_TX shl 16)
498	jmp .ftdi_out_control_transfer_noinp	499	jmp .ftdi_out_control_transfer_noinp
499		500

Subversion Repositories Kolibri OS

(root)/drivers/usb/usbftdi/usbftdi.asm – Rev 5363 → 7552