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

Subversion Repositories Kolibri OS

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