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

-; standard driver stuff
+; standard driver stuff; version of driver model = 5
-format MS COFF
+format PE DLL native 0.05
+entry START
 DEBUG = 1
 DUMP_PACKETS = 0
 ; this is for DEBUGF macro from 'fdo.inc'
-__DEBUG__ = 1
-__DEBUG_LEVEL__ = 1
+__DEBUG__ = 1
-include 'proc32.inc'
-include 'imports.inc'
-include 'fdo.inc'
 __DEBUG_LEVEL__ = 1
 public START
-public version
+include '../struct.inc'
 ISOCHRONOUS_PIPE = 1
 BULK_PIPE = 2
 INTERRUPT_PIPE = 3
-; USB structures
-virtual at 0
+; USB structures
-config_descr:
+struct config_descr
-.bLength                db      ?
+bLength                 db      ?
-.bDescriptorType        db      ?
+bDescriptorType         db      ?
-.wTotalLength           dw      ?
+wTotalLength            dw      ?
-.bNumInterfaces         db      ?
+bNumInterfaces          db      ?
-.bConfigurationValue    db      ?
+bConfigurationValue     db      ?
-.iConfiguration         db      ?
+iConfiguration          db      ?
-.bmAttributes           db      ?
+bmAttributes            db      ?
-.bMaxPower              db      ?
-.sizeof:
+bMaxPower               db      ?
-end virtual
+ends
-virtual at 0
-interface_descr:
+struct interface_descr
-.bLength                db      ?
+bLength                 db      ?
-.bDescriptorType        db      ?
+bDescriptorType         db      ?
-.bInterfaceNumber       db      ?
+bInterfaceNumber        db      ?
-.bAlternateSetting      db      ?
+bAlternateSetting       db      ?
-.bNumEndpoints          db      ?
+bNumEndpoints           db      ?
-.bInterfaceClass        db      ?
+bInterfaceClass         db      ?
-.bInterfaceSubClass     db      ?
+bInterfaceSubClass      db      ?
-.bInterfaceProtocol     db      ?
+bInterfaceProtocol      db      ?
-.iInterface             db      ?
-.sizeof:
+iInterface              db      ?
-end virtual
+ends
-virtual at 0
-endpoint_descr:
+struct endpoint_descr
-.bLength                db      ?
+bLength                 db      ?
-.bDescriptorType        db      ?
+bDescriptorType         db      ?
-.bEndpointAddress       db      ?
+bEndpointAddress        db      ?
-.bmAttributes           db      ?
+bmAttributes            db      ?
-.wMaxPacketSize         dw      ?
+wMaxPacketSize          dw      ?
-.bInterval              db      ?
-.sizeof:
+bInterval               db      ?
-end virtual
+ends
 ; Mass storage protocol constants, USB layer
 REQUEST_GETMAXLUN = 0xFE        ; get max lun
 REQUEST_BORESET = 0xFF          ; bulk-only reset
-; Mass storage protocol structures, USB layer
-; Sent from host to device in the first stage of an operation.
+; Mass storage protocol structures, USB layer
-struc command_block_wrapper
+; Sent from host to device in the first stage of an operation.
-{
+struct command_block_wrapper
-.Signature      dd      ?       ; the constant 'USBC'
+Signature       dd      ?       ; the constant 'USBC'
-.Tag            dd      ?       ; identifies response with request
+Tag             dd      ?       ; identifies response with request
-.Length         dd      ?       ; length of data-transport phase
+Length          dd      ?       ; length of data-transport phase
-.Flags          db      ?       ; one of CBW_FLAG_*
+Flags           db      ?       ; one of CBW_FLAG_*
 CBW_FLAG_OUT = 0
 CBW_FLAG_IN = 80h
-.LUN            db      ?       ; addressed unit
-.CommandLength  db      ?       ; the length of the following field
-.Command        rb      16
-.sizeof:
-}
+LUN             db      ?       ; addressed unit
-virtual at 0
+CommandLength   db      ?       ; the length of the following field
-command_block_wrapper   command_block_wrapper
+Command         rb      16
-end virtual
+ends
-; Sent from device to host in the last stage of an operation.
-struc command_status_wrapper
+; Sent from device to host in the last stage of an operation.
-{
+struct command_status_wrapper
-.Signature      dd      ?       ; the constant 'USBS'
+Signature       dd      ?       ; the constant 'USBS'
-.Tag            dd      ?       ; identifies response with request
+Tag             dd      ?       ; identifies response with request
-.LengthRest     dd      ?       ; .Length - (size of data which were transferred)
+LengthRest      dd      ?       ; .Length - (size of data which were transferred)
-.Status         db      ?       ; one of CSW_STATUS_*
-CSW_STATUS_OK = 0
-CSW_STATUS_FAIL = 1
-CSW_STATUS_FATAL = 2
-.sizeof:
+Status          db      ?       ; one of CSW_STATUS_*
 CSW_STATUS_OK = 0
-virtual at 0
+CSW_STATUS_FAIL = 1
-command_status_wrapper  command_status_wrapper
+CSW_STATUS_FATAL = 2
-end virtual
+ends
 SENSE_MISCOMPARE = 14
 ; 15 is reserved
 ; Structures of SCSI layer
 ; Result of SCSI INQUIRY request.
-struc inquiry_data
-{
+struct inquiry_data
-.PeripheralDevice       db      ?       ; lower 5 bits are PeripheralDeviceType
+PeripheralDevice        db      ?       ; lower 5 bits are PeripheralDeviceType
                                         ; upper 3 bits are PeripheralQualifier
-.RemovableMedium        db      ?       ; upper bit is RemovableMedium
+RemovableMedium         db      ?       ; upper bit is RemovableMedium
                                         ; other bits are for compatibility
-.Version                db      ?       ; lower 3 bits are ANSI-Approved version
+Version                 db      ?       ; lower 3 bits are ANSI-Approved version
                                         ; next 3 bits are ECMA version
                                         ; upper 2 bits are ISO version
-.ResponseDataFormat     db      ?       ; lower 4 bits are ResponseDataFormat
+ResponseDataFormat      db      ?       ; lower 4 bits are ResponseDataFormat
                                         ; bit 6 is TrmIOP
                                         ; bit 7 is AENC
-.AdditionalLength       db      ?
+AdditionalLength        db      ?
                         dw      ?       ; reserved
-.Flags                  db      ?
+Flags                   db      ?
-.VendorID               rb      8       ; vendor ID, big-endian
+VendorID                rb      8       ; vendor ID, big-endian
-.ProductID              rb      16      ; product ID, big-endian
+ProductID               rb      16      ; product ID, big-endian
-.ProductRevBE           dd      ?       ; product revision, big-endian
-.sizeof:
-}
-virtual at 0
-inquiry_data inquiry_data
+ProductRevBE            dd      ?       ; product revision, big-endian
-end virtual
+ends
-struc sense_data
 struct sense_data
-.ErrorCode              db      ?       ; lower 7 bits are error code:
+ErrorCode               db      ?       ; lower 7 bits are error code:
                                         ; 70h = current error,
                                         ; 71h = deferred error
                                         ; upper bit is InformationValid
-.SegmentNumber          db      ?       ; number of segment descriptor
+SegmentNumber           db      ?       ; number of segment descriptor
                                         ; for commands COPY [+VERIFY], COMPARE
-.SenseKey               db      ?       ; bits 0-3 are one of SENSE_*
+SenseKey                db      ?       ; bits 0-3 are one of SENSE_*
                                         ; bit 4 is reserved
                                         ; bit 5 is IncorrectLengthIndicator
                                         ; bits 6 and 7 are used by
                                         ; sequential-access devices
-.Information            dd      ?       ; command-specific
+Information             dd      ?       ; command-specific
-.AdditionalLength       db      ?       ; length of data starting here
+AdditionalLength        db      ?       ; length of data starting here
-.CommandInformation     dd      ?       ; command-specific
+CommandInformation      dd      ?       ; command-specific
-.AdditionalSenseCode    db      ?       ; \ more detailed error code
+AdditionalSenseCode     db      ?       ; \ more detailed error code
-.AdditionalSenseQual    db      ?       ; / standard has a large table of them
+AdditionalSenseQual     db      ?       ; / standard has a large table of them
-.FRUCode                db      ?       ; which part of device has failed
+FRUCode                 db      ?       ; which part of device has failed
-                                        ; (device-specific, not regulated)
-.SenseKeySpecific       rb      3       ; depends on SenseKey
-.sizeof:
-}
-virtual at 0
+                                        ; (device-specific, not regulated)
-sense_data sense_data
+SenseKeySpecific        rb      3       ; depends on SenseKey
-end virtual
+ends
 ; Device data
-; USB Mass storage device has one or more logical units, identified by LUN,
-; logical unit number. The highest value of LUN, that is, number of units
+; USB Mass storage device has one or more logical units, identified by LUN,
-; minus 1, can be obtained via control request Get Max LUN.
+; logical unit number. The highest value of LUN, that is, number of units
-virtual at 0
+; minus 1, can be obtained via control request Get Max LUN.
-usb_device_data:
+struct usb_device_data
-.ConfigPipe             dd      ?       ; configuration pipe
+ConfigPipe              dd      ?       ; configuration pipe
-.OutPipe                dd      ?       ; pipe for OUT bulk endpoint
+OutPipe                 dd      ?       ; pipe for OUT bulk endpoint
-.InPipe                 dd      ?       ; pipe for IN bulk endpoint
+InPipe                  dd      ?       ; pipe for IN bulk endpoint
-.MaxLUN                 dd      ?       ; maximum Logical Unit Number
+MaxLUN                  dd      ?       ; maximum Logical Unit Number
-.LogicalDevices         dd      ?       ; pointer to array of usb_unit_data
+LogicalDevices          dd      ?       ; pointer to array of usb_unit_data
 ; 1 for a connected USB device, 1 for each disk device
 ; the structure can be freed when .NumReferences decreases to zero
-.NumReferences          dd      ?       ; number of references
+NumReferences           dd      ?       ; number of references
-.ConfigRequest          rb      8       ; buffer for configuration requests
+ConfigRequest           rb      8       ; buffer for configuration requests
-.LengthRest             dd      ?       ; Length - (size of data which were transferred)
+LengthRest              dd      ?       ; Length - (size of data which were transferred)
 ; All requests to a given device are serialized,
 ; only one request to a given device can be processed at a time.
 ; The current request and all pending requests are organized in the following
 ; queue, the head being the current request.
 ; NB: the queue must be device-wide due to the protocol:
 ; data stage is not tagged (unlike command_*_wrapper), so the only way to know
 ; what request the data are associated with is to guarantee that only one
 ; request is processing at the time.
-.RequestsQueue          rd      2
+RequestsQueue           rd      2
-.QueueLock              rd      3       ; protects .RequestsQueue
+QueueLock               rd      3       ; protects .RequestsQueue
-.InquiryData            inquiry_data    ; information about device
+InquiryData             inquiry_data    ; information about device
 ; data for the current request
-.Command                command_block_wrapper
+Command                 command_block_wrapper
-.DeviceDisconnected     db      ?
-.Status                 command_status_wrapper
+DeviceDisconnected      db      ?
-.Sense                  sense_data
+Status                  command_status_wrapper
-.sizeof:
-end virtual
+Sense                   sense_data
+ends
-; Information about one logical device.
-virtual at 0
+; Information about one logical device.
-usb_unit_data:
+struct usb_unit_data
-.Parent         dd      ?       ; pointer to parent usb_device_data
+Parent          dd      ?       ; pointer to parent usb_device_data
-.LUN            db      ?       ; index in usb_device_data.LogicalDevices array
+LUN             db      ?       ; index in usb_device_data.LogicalDevices array
-.DiskIndex      db      ?       ; for name "usbhd"
+DiskIndex       db      ?       ; for name "usbhd"
-.MediaPresent   db      ?
+MediaPresent    db      ?
                 db      ?       ; alignment
-.DiskDevice     dd      ?       ; handle of disk device or NULL
+DiskDevice      dd      ?       ; handle of disk device or NULL
-.SectorSize     dd      ?       ; sector size
+SectorSize      dd      ?       ; sector size
 ; For some devices, the first request to the medium fails with 'unit not ready'.
 ; When the code sees this status, it retries the command several times.
-; Two following variables track the retry count and total time for those;
-; total time is currently used only for debug output.
+; Two following variables track the retry count and total time for those;
-.UnitReadyAttempts      dd      ?
+; total time is currently used only for debug output.
-.TimerTicks             dd      ?
-.sizeof:
+UnitReadyAttempts       dd      ?
-end virtual
+TimerTicks              dd      ?
+ends
-; This is the structure for items in the queue usb_device_data.RequestsQueue.
-virtual at 0
+; This is the structure for items in the queue usb_device_data.RequestsQueue.
-request_queue_item:
+struct request_queue_item
-.Next           dd      ?       ; next item in the queue
+Next            dd      ?       ; next item in the queue
-.Prev           dd      ?       ; prev item in the queue
+Prev            dd      ?       ; prev item in the queue
-.ReqBuilder     dd      ?       ; procedure to fill command_block_wrapper
+ReqBuilder      dd      ?       ; procedure to fill command_block_wrapper
-.Buffer         dd      ?       ; input or output data
+Buffer          dd      ?       ; input or output data
                                 ; (length is command_block_wrapper.Length)
-.Callback       dd      ?       ; procedure to call in the end of transfer
+Callback        dd      ?       ; procedure to call in the end of transfer
-.UserData       dd      ?       ; passed as-is to .Callback
+UserData        dd      ?       ; passed as-is to .Callback
 ; There are 3 possible stages of any request, one of them optional:
 ; command stage (host sends command_block_wrapper to device),
 ; optional data stage,
 ; status stage (device sends command_status_wrapper to host).
+; Also, if a request fails, the code queues additional request
+; SCSI_REQUEST_SENSE; sense_data from SCSI_REQUEST_SENSE
+; contains some information about the error.
-; Also, if a request fails, the code queues additional request
+Stage           db      ?
+ends
-; SCSI_REQUEST_SENSE; sense_data from SCSI_REQUEST_SENSE
-; contains some information about the error.
+section '.flat' code readable writable executable
-.Stage          db      ?
+include '../proc32.inc'
-.sizeof:
+include '../peimport.inc'
-end virtual
+include '../fdo.inc'
 include '../macros.inc'
-section '.flat' code readable align 16
+; The start procedure.
-; The start procedure.
+proc START
-proc START
+virtual at esp
-virtual at esp
+        dd      ?       ; return address
-        dd      ?       ; return address
+.reason dd      ?       ; DRV_ENTRY or DRV_EXIT
-.reason dd      ?       ; DRV_ENTRY or DRV_EXIT
+.cmdline dd     ?
 end virtual
 ; 1. Test whether the procedure is called with the argument DRV_ENTRY.
 ; If not, return 0.
         xor     eax, eax        ; initialize return value
         cmp     [.reason], 1    ; compare the argument
         jnz     .nothing
 ; 2. Initialize: we have one global mutex.
         mov     ecx, free_numbers_lock
-        call    MutexInit
+        invoke  MutexInit
 ; 3. Register self as a USB driver.
 ; The name is my_driver = 'usbstor'; IOCTL interface is not supported;
 ; usb_functions is an offset of a structure with callback functions.
-        stdcall RegUSBDriver, my_driver, 0, usb_functions
+        invoke  RegUSBDriver, my_driver, 0, usb_functions
 .Buffer         dd      ?       ; request_queue_item.Buffer
 .Callback       dd      ?       ; request_queue_item.Callback
 .UserData       dd      ?       ; request_queue_item.UserData
 end virtual
 ; 1. Allocate the memory for the request description.
-        movi    eax, request_queue_item.sizeof
+        movi    eax, sizeof.request_queue_item
-        call    Kmalloc
+        invoke  Kmalloc
         test    eax, eax
         jnz     @f
         mov     esi, nomemory
-        call    SysMsgBoardStr
+        invoke  SysMsgBoardStr
         pop     esi ebx
         ret     20
 @@:
 ; 2. Fill user-provided parts of the request description.
         push    edi
 ; 3. Set stage to zero: not started.
         mov     [ebx+request_queue_item.Stage], 0
 ; 4. Lock the queue.
         mov     esi, [.device]
         lea     ecx, [esi+usb_device_data.QueueLock]
-        call    MutexLock
+        invoke  MutexLock
 ; 5. Insert the request to the tail of the queue.
         add     esi, usb_device_data.RequestsQueue
         mov     edx, [esi+request_queue_item.Prev]
         mov     [ebx+request_queue_item.Next], esi
         mov     [ebx+request_queue_item.Prev], edx
 ; start it.
         sub     esi, usb_device_data.RequestsQueue
         call    setup_request
         jmp     .nothing
 .unlock:
-        call    MutexUnlock
+        invoke  MutexUnlock
 ; 9. Return.
 .nothing:
         pop     esi ebx
         ret     20
 endp
         mov     ebx, [esi+usb_device_data.RequestsQueue+request_queue_item.Next]
 ; 3. Call the callback.
         stdcall [ebx+request_queue_item.Callback], esi, [ebx+request_queue_item.UserData]
 ; 4. Lock the queue.
         lea     ecx, [esi+usb_device_data.QueueLock]
-        call    MutexLock
+        invoke  MutexLock
 ; 5. Remove the request.
         lea     edx, [esi+usb_device_data.RequestsQueue]
         mov     eax, [ebx+request_queue_item.Next]
         mov     [eax+request_queue_item.Prev], edx
         mov     [edx+request_queue_item.Next], eax
 ; 6. Free the request memory.
         push    eax edx
         xchg    eax, ebx
-        call    Kfree
+        invoke  Kfree
         pop     edx ebx
 ; 7. If there is a next request, start processing.
         cmp     ebx, edx
         jnz     setup_request
 ; 8. Unlock the queue and return.
         lea     ecx, [esi+usb_device_data.QueueLock]
-        call    MutexUnlock
+        invoke  MutexUnlock
         ret
 endp
 ; Start processing the request. Called either by queue_request
         jb      .norecovery
 ; 2a. Send Bulk-Only Mass Storage Reset command to config pipe.
         lea     edx, [esi+usb_device_data.ConfigRequest]
         mov     word [edx], (REQUEST_BORESET shl 8) + 21h       ; class request
         mov     word [edx+6], ax        ; length = 0
-        stdcall USBControlTransferAsync, [esi+usb_device_data.ConfigPipe], edx, eax, eax, recovery_callback1, esi, eax
+        invoke  USBControlTransferAsync, [esi+usb_device_data.ConfigPipe], edx, eax, eax, recovery_callback1, esi, eax
 ; 2b. Fail here = fatal error.
         test    eax, eax
         jz      .fatal
 ; 2c. Otherwise, unlock the queue and return. recovery_callback1 will continue processing.
 .unlock_return:
         lea     ecx, [esi+usb_device_data.QueueLock]
-        call    MutexUnlock
+        invoke  MutexUnlock
         ret
 .norecovery:
 ; 3. Send the command. Fail (no memory or device disconnected) = fatal error.
 ; Otherwise, go to 2c.
         call    request_stage1
         jnz     .unlock_return
 .fatal:
 ; 4. Fatal error. Set status = FATAL, unlock the queue, complete the request.
         mov     [esi+usb_device_data.Status.Status], CSW_STATUS_FATAL
         lea     ecx, [esi+usb_device_data.QueueLock]
-        call    MutexUnlock
+        invoke  MutexUnlock
         jmp     complete_request
 endp
 ; Initiate USB transfer for the first stage of a request (send command).
 ; 4. Initiate USB transfer.
         lea     edx, [esi+usb_device_data.Command]
 if DUMP_PACKETS
         DEBUGF 1,'K : USBSTOR out:'
         mov     eax, edx
-        mov     ecx, command_block_wrapper.sizeof
+        mov     ecx, sizeof.command_block_wrapper
         call    debug_dump
         DEBUGF 1,'\n'
 end if
-        stdcall USBNormalTransferAsync, [esi+usb_device_data.OutPipe], edx, command_block_wrapper.sizeof, request_callback1, esi, 0
+        invoke  USBNormalTransferAsync, [esi+usb_device_data.OutPipe], edx, sizeof.command_block_wrapper, request_callback1, esi, 0
         test    eax, eax
         jz      .nothing
 ; 5. If the next stage is data stage in the same direction, enqueue it here.
         cmp     [esi+usb_device_data.Command.Flags], 0
         js      .nothing
         mov     eax, [edx+request_queue_item.Buffer]
         mov     ecx, [esi+usb_device_data.Command.Length]
         call    debug_dump
         DEBUGF 1,'\n'
 end if
-        stdcall USBNormalTransferAsync, [esi+usb_device_data.OutPipe], [edx+request_queue_item.Buffer], [esi+usb_device_data.Command.Length], request_callback2, esi, 0
+        invoke  USBNormalTransferAsync, [esi+usb_device_data.OutPipe], [edx+request_queue_item.Buffer], [esi+usb_device_data.Command.Length], request_callback2, esi, 0
 .nothing:
         ret
 endp
         jz      ..request_get_status
 ; 4b. If data were enqueued in the first stage, do nothing, wait for request_callback2.
         cmp     [ecx+usb_device_data.Command.Flags], 0
         jns     .nothing
 ; 5. Initiate USB transfer. If this fails, go to the error handler.
-        stdcall USBNormalTransferAsync, [ecx+usb_device_data.InPipe], [edx+request_queue_item.Buffer], [ecx+usb_device_data.Command.Length], request_callback2, ecx, 0
+        invoke  USBNormalTransferAsync, [ecx+usb_device_data.InPipe], [edx+request_queue_item.Buffer], [ecx+usb_device_data.Command.Length], request_callback2, ecx, 0
         test    eax, eax
         jz      .error
 ; 6. The status stage goes to the same direction, enqueue it now.
         mov     ecx, [.calldata]
         jmp     ..enqueue_status
         mov     edx, [ecx+usb_device_data.RequestsQueue+request_queue_item.Next]
         inc     [edx+request_queue_item.Stage]
 ; 4. Initiate USB transfer. If this fails, go to the error handler.
 ..enqueue_status:
         lea     edx, [ecx+usb_device_data.Status]
-        stdcall USBNormalTransferAsync, [ecx+usb_device_data.InPipe], edx, command_status_wrapper.sizeof, request_callback3, ecx, 0
+        invoke  USBNormalTransferAsync, [ecx+usb_device_data.InPipe], edx, sizeof.command_status_wrapper, request_callback3, ecx, 0
         test    eax, eax
         jz      .error
 .nothing:
         ret     20
 .error:
         jmp     .complete
 .invalid:
 ; 6. Invalid status block. Say error, set status to fatal and complete request.
         push    esi
         mov     esi, invresponse
-        call    SysMsgBoardStr
+        invoke  SysMsgBoardStr
         pop     esi
         mov     [esi+usb_device_data.Status.Status], CSW_STATUS_FATAL
         jmp     .complete
 .fail:
 ; 7. The command has failed.
 ; Builder for SCSI_REQUEST_SENSE request.
 ; edx = first argument = pointer to usb_device_data.Command,
 ; second argument = custom data given to queue_request (ignored).
 proc request_sense_req
-        mov     [edx+command_block_wrapper.Length], sense_data.sizeof
+        mov     [edx+command_block_wrapper.Length], sizeof.sense_data
         mov     [edx+command_block_wrapper.Flags], CBW_FLAG_IN
         mov     byte [edx+command_block_wrapper.Command+0], SCSI_REQUEST_SENSE
-        mov     byte [edx+command_block_wrapper.Command+4], sense_data.sizeof
+        mov     byte [edx+command_block_wrapper.Command+4], sizeof.sense_data
         ret     8
 endp
 ; so allow them to proceed also.
         cmp     cx, 0x5005
         jz      .known
 ; 1c. If the device is unknown, print a message and go to 11c.
         mov     esi, unkdevice
-        call    SysMsgBoardStr
+        invoke  SysMsgBoardStr
         jmp     .nothing
 ; 1d. If the device uses known command set, print a message and continue
 ; configuring.
 .known:
         push    esi
         mov     esi, okdevice
-        call    SysMsgBoardStr
+        invoke  SysMsgBoardStr
         pop     esi
 ; 2. Allocate memory for internal device data.
 ; 2a. Call the kernel.
-        mov     eax, usb_device_data.sizeof
+        mov     eax, sizeof.usb_device_data
-        call    Kmalloc
+        invoke  Kmalloc
 ; 2b. Check return value.
         test    eax, eax
         jnz     @f
 ; 2c. If failed, say a message and go to 11c.
         mov     esi, nomemory
-        call    SysMsgBoardStr
+        invoke  SysMsgBoardStr
         jmp     .nothing
 @@:
 ; 2d. If succeeded, zero the contents and continue configuring.
         xchg    ebx, eax        ; ebx will point to usb_device_data
         xor     eax, eax
 ; 2i. Initialize requests queue.
         lea     eax, [ebx+usb_device_data.RequestsQueue]
         mov     [eax+request_queue_item.Next], eax
         mov     [eax+request_queue_item.Prev], eax
         lea     ecx, [ebx+usb_device_data.QueueLock]
-        call    MutexInit
+        invoke  MutexInit
 ; Bulk-only mass storage devices use one OUT bulk endpoint for sending
 ; command/data and one IN bulk endpoint for receiving data/status.
 ; Look for those endpoints.
 ; 3. Get the upper bound of all descriptors' data.
         mov     edx, [.config]  ; configuration descriptor
 ; the loop.
         cmp     byte [esi+endpoint_descr.bDescriptorType], ENDPOINT_DESCR_TYPE
         jnz     .lookep
 ; 5. Check that the descriptor contains all required data and all data are
 ; readable. The opposite is an error.
-        cmp     byte [esi+endpoint_descr.bLength], endpoint_descr.sizeof
+        cmp     byte [esi+endpoint_descr.bLength], sizeof.endpoint_descr
         jb      .errorep
-        lea     ecx, [esi+endpoint_descr.sizeof]
+        lea     ecx, [esi+sizeof.endpoint_descr]
         cmp     ecx, edx
         ja      .errorep
 ; 6. Check that the endpoint is bulk endpoint. The opposite is an error.
         mov     cl, [esi+endpoint_descr.bmAttributes]
         and     cl, 3
 ; 9b. Load parameters from the descriptor.
         movzx   ecx, [esi+endpoint_descr.bEndpointAddress]
         movzx   edx, [esi+endpoint_descr.wMaxPacketSize]
         movzx   eax, [esi+endpoint_descr.bInterval]     ; not used for USB1, may be important for USB2
 ; 9c. Call the kernel.
-        stdcall USBOpenPipe, [ebx+usb_device_data.ConfigPipe], ecx, edx, BULK_PIPE, eax
+        invoke  USBOpenPipe, [ebx+usb_device_data.ConfigPipe], ecx, edx, BULK_PIPE, eax
 ; 9d. Restore registers.
         pop     edx ecx
 ; 9e. Check result. If failed, go to 11b.
         test    eax, eax
         jz      .free
 ; 11a. Print a message.
         DEBUGF 1,'K : error: invalid endpoint descriptor\n'
 .free:
 ; 11b. Free the allocated usb_device_data.
         xchg    eax, ebx
-        call    Kfree
+        invoke  Kfree
 .nothing:
 ; 11c. Return an error.
         xor     eax, eax
         jmp     .return
 .created:
         mov     byte [eax+6], 1         ; transfer 1 byte
         lea     ecx, [ebx+usb_device_data.MaxLUN]
 if DUMP_PACKETS
         DEBUGF 1,'K : GETMAXLUN: %x %x %x %x %x %x %x %x\n',[eax]:2,[eax+1]:2,[eax+2]:2,[eax+3]:2,[eax+4]:2,[eax+5]:2,[eax+6]:2,[eax+7]:2
 end if
-        stdcall USBControlTransferAsync, [ebx+usb_device_data.ConfigPipe], eax, ecx, 1, known_lun_callback, ebx, 0
+        invoke  USBControlTransferAsync, [ebx+usb_device_data.ConfigPipe], eax, ecx, 1, known_lun_callback, ebx, 0
 ; 13. Return with pointer to device data as returned value.
         xchg    eax, ebx
 .return:
         pop     esi ebx
         ret     12
 @@:
 ; 2. Allocate the memory for logical devices.
         mov     eax, [ebx+usb_device_data.MaxLUN]
         inc     eax
         DEBUGF 1,'K : %d logical unit(s)\n',eax
-        imul    eax, usb_unit_data.sizeof
+        imul    eax, sizeof.usb_unit_data
         push    ebx
-        call    Kmalloc
+        invoke  Kmalloc
         pop     ebx
 ; If failed, print a message and do nothing.
         test    eax, eax
         jnz     @f
         mov     esi, nomemory
-        call    SysMsgBoardStr
+        invoke  SysMsgBoardStr
         pop     esi ebx
         ret     20
 @@:
         mov     [ebx+usb_device_data.LogicalDevices], eax
 ; 3. Initialize logical devices and initiate TEST_UNIT_READY request.
         mov     [esi+usb_unit_data.MediaPresent], al
         mov     [esi+usb_unit_data.DiskDevice], eax
         mov     [esi+usb_unit_data.SectorSize], eax
         mov     [esi+usb_unit_data.UnitReadyAttempts], eax
         push    ecx
-        call    GetTimerTicks
+        invoke  GetTimerTicks
         mov     [esi+usb_unit_data.TimerTicks], eax
         stdcall queue_request, ebx, test_unit_ready_req, 0, test_unit_ready_callback, esi
         pop     ecx
         inc     ecx
-        add     esi, usb_unit_data.sizeof
+        add     esi, sizeof.usb_unit_data
         cmp     ecx, [ebx+usb_device_data.MaxLUN]
         jbe     .looplun
 ; 4. Return.
         pop     esi ebx
         ret     20
 ; edx = first argument = pointer to usb_device_data.Command,
 ; second argument = custom data given to queue_request.
 proc inquiry_req
         mov     eax, [esp+8]
         mov     al, [eax+usb_unit_data.LUN]
-        mov     [edx+command_block_wrapper.Length], inquiry_data.sizeof
+        mov     [edx+command_block_wrapper.Length], sizeof.inquiry_data
         mov     [edx+command_block_wrapper.Flags], CBW_FLAG_IN
         mov     [edx+command_block_wrapper.LUN], al
         mov     byte [edx+command_block_wrapper.Command+0], SCSI_INQUIRY
-        mov     byte [edx+command_block_wrapper.Command+4], inquiry_data.sizeof
+        mov     byte [edx+command_block_wrapper.Command+4], sizeof.inquiry_data
         ret     8
 endp
 ; Called when SCSI INQUIRY request is completed.
         mov     edx, [esp+8]
         push    ebx ecx esi edi
         movi    ebx, 1
         mov     ecx, new_disk_thread
         ; edx = parameter
-        call    CreateThread
+        invoke  CreateThread
         pop     edi esi ecx ebx
         cmp     eax, -1
         jnz     .nothing
 ; on error, reverse step 3
         lock dec [ecx+usb_device_data.NumReferences]
         ret     8
 .fail:
 ; 4. The command has failed. Print a message and do nothing.
         push    esi
         mov     esi, inquiry_fail
-        call    SysMsgBoardStr
+        invoke  SysMsgBoardStr
         pop     esi
         ret     8
 endp
         jnz     .fail
 ; 2. The command has completed successfully,
 ; possibly after some repetitions. Print a debug message showing
 ; number and time of those. Remember that media is ready and go to 4.
         DEBUGF 1,'K : media is ready\n'
-        call    GetTimerTicks
+        invoke  GetTimerTicks
         sub     eax, [edx+usb_unit_data.TimerTicks]
         DEBUGF 1,'K : %d attempts, %d ticks\n',[edx+usb_unit_data.UnitReadyAttempts],eax
         inc     [edx+usb_unit_data.MediaPresent]
         jmp     .inquiry
 .fail:
         inc     [edx+usb_unit_data.UnitReadyAttempts]
         cmp     [edx+usb_unit_data.UnitReadyAttempts], 3
         jz      @f
         push    ecx edx esi
         movi    esi, 10
-        call    Sleep
+        invoke  Sleep
         pop     esi edx ecx
         stdcall queue_request, ecx, test_unit_ready_req, 0, test_unit_ready_callback, edx
         ret     8
 @@:
         DEBUGF 1,'K : media not ready\n'
 ; We are ready to notify the kernel about a new disk device.
         mov     esi, [.param]
 ; 1. Generate name.
 ; 1a. Find a free index.
         mov     ecx, free_numbers_lock
-        call    MutexLock
+        invoke  MutexLock
         xor     eax, eax
 @@:
         bsf     edx, [free_numbers+eax]
         jnz     @f
         add     eax, 4
         cmp     eax, 4*4
         jnz     @b
-        call    MutexUnlock
+        invoke  MutexUnlock
         push    esi
         mov     esi, noindex
-        call    SysMsgBoardStr
+        invoke  SysMsgBoardStr
         pop     esi
         jmp     .drop_reference
 @@:
 ; 1b. Mark the index as busy.
         btr     [free_numbers+eax], edx
         lea     eax, [eax*8+edx]
         push    eax
-        call    MutexUnlock
+        invoke  MutexUnlock
         pop     eax
 ; 1c. Generate a name of the form "usbhd" in the stack.
         mov     dword [esp], 'usbh'
         lea     edi, [esp+5]
         mov     byte [edi-1], 'd'
 ; 3d. Store the index in usb_unit_data to free it later.
         mov     [esi+usb_unit_data.DiskIndex], cl
 ; 4. Notify the kernel about a new disk.
 ; 4a. Add a disk.
 ;       stdcall queue_request, ecx, read_capacity_req, eax, read_capacity_callback, eax
-        stdcall DiskAdd, disk_functions, edx, esi, 0
+        invoke  DiskAdd, disk_functions, edx, esi, 0
         mov     ebx, eax
 ; 4b. If it failed, release the index and do nothing.
         test    eax, eax
         jz      .free_index
 ; 4c. Notify the kernel that a media is present.
-        stdcall DiskMediaChanged, eax, 1
+        invoke  DiskMediaChanged, eax, 1
 ; 5. Lock the requests queue, check that device is not disconnected,
 ; store the disk handle, unlock the requests queue.
         mov     ecx, [esi+usb_unit_data.Parent]
         add     ecx, usb_device_data.QueueLock
-        call    MutexLock
+        invoke  MutexLock
         cmp     byte [ecx+usb_device_data.DeviceDisconnected-usb_device_data.QueueLock], 0
         jnz     .disconnected
         mov     [esi+usb_unit_data.DiskDevice], ebx
-        call    MutexUnlock
+        invoke  MutexUnlock
         jmp     .exit
 .disconnected:
-        call    MutexUnlock
+        invoke  MutexUnlock
         stdcall disk_close, ebx
         jmp     .exit
 .free_index:
         mov     ecx, free_numbers_lock
-        call    MutexLock
+        invoke  MutexLock
         movzx   eax, [esi+usb_unit_data.DiskIndex]
         bts     [free_numbers], eax
-        call    MutexUnlock
+        invoke  MutexUnlock
 .drop_reference:
         mov     esi, [esi+usb_unit_data.Parent]
         lock dec [esi+usb_device_data.NumReferences]
         jnz     .exit
         mov     eax, [esi+usb_device_data.LogicalDevices]
-        call    Kfree
+        invoke  Kfree
         xchg    eax, esi
-        call    Kfree
+        invoke  Kfree
 .exit:
         or      eax, -1
         int     0x40
 endp
         dd      ?       ; return address
 .device dd      ?
 end virtual
 ; 1. Say a message.
         mov     esi, disconnectmsg
-        call    SysMsgBoardStr
+        invoke  SysMsgBoardStr
 ; 2. Lock the requests queue, set .DeviceDisconnected to 1,
 ; unlock the requests queue.
 ; Locking is required for synchronization with queue_request:
 ; all USB callbacks are executed in the same thread and are
 ; synchronized automatically, but queue_request can be running
 ; been started, has checked that device is not yet disconnected,
 ; then DeviceDisconnected completes and all handles become invalid,
 ; then queue_request tries to use them.
         mov     esi, [.device]
         lea     ecx, [esi+usb_device_data.QueueLock]
-        call    MutexLock
+        invoke  MutexLock
         mov     [esi+usb_device_data.DeviceDisconnected], 1
-        call    MutexUnlock
+        invoke  MutexUnlock
 ; 3. Drop one reference to the structure and check whether
 ; that was the last reference.
         lock dec [esi+usb_device_data.NumReferences]
         jz      .free
 ; 4. If not, there are some additional references due to disk devices;
         inc     ebx
 .diskdel:
         mov     eax, [esi+usb_unit_data.DiskDevice]
         test    eax, eax
         jz      @f
-        stdcall DiskDel, eax
+        invoke  DiskDel, eax
 @@:
-        add     esi, usb_unit_data.sizeof
+        add     esi, sizeof.usb_unit_data
         dec     ebx
         jnz     .diskdel
 ; In this case, some operations with those disks are still possible,
 ; so we can't do anything more now. disk_close will take care of the rest.
 .return:
 ; 5. If there are no disk devices, free all resources which were allocated.
 .free:
         mov     eax, [esi+usb_device_data.LogicalDevices]
         test    eax, eax
         jz      @f
-        call    Kfree
+        invoke  Kfree
 @@:
         xchg    eax, esi
-        call    Kfree
+        invoke  Kfree
         jmp     .return
 endp
 ; Disk functions.
         dd      ?       ; return address
 .userdata       dd      ?
 end virtual
         mov     esi, [.userdata]
         mov     ecx, free_numbers_lock
-        call    MutexLock
+        invoke  MutexLock
         movzx   eax, [esi+usb_unit_data.DiskIndex]
         bts     [free_numbers], eax
-        call    MutexUnlock
+        invoke  MutexUnlock
         mov     esi, [esi+usb_unit_data.Parent]
         lock dec [esi+usb_device_data.NumReferences]
         jnz     .nothing
         mov     eax, [esi+usb_device_data.LogicalDevices]
-        call    Kfree
+        invoke  Kfree
         xchg    eax, esi
-        call    Kfree
+        invoke  Kfree
 .nothing:
         pop     esi ebx
         ret     4
 endp
 proc disk_querymedia stdcall uses ebx esi edi, \
         userdata:dword, mediainfo:dword
 ; 1. Create event for waiting.
         xor     esi, esi
         xor     ecx, ecx
-        call    CreateEvent
+        invoke  CreateEvent
         test    eax, eax
         jz      .generic_fail
         push    eax
         push    edx
         push    ecx
         mov     edx, esp
         stdcall queue_request, ecx, read_capacity_req, edx, read_capacity_callback, edx
 ; 3. Wait for event. This destroys it.
         mov     eax, [.event]
         mov     ebx, [.event_code]
-        call    WaitEvent
+        invoke  WaitEvent
 ; 4. Get the status and results.
         pop     ecx
         bswap   ecx     ; .LastLBA
         pop     edx
         bswap   edx     ; .SectorSize
         push    ebx esi edi
         mov     eax, [ecx+disk_querymedia.event-disk_querymedia.locals]
         mov     ebx, [ecx+disk_querymedia.event_code-disk_querymedia.locals]
         xor     edx, edx
         xor     esi, esi
-        call    RaiseEvent
+        invoke  RaiseEvent
         pop     edi esi ebx
         ret     8
 endp
         cmp     dword [startsector+4], 0
         jnz     .generic_fail
 ; 4. Create event for waiting.
         xor     esi, esi
         xor     ecx, ecx
-        call    CreateEvent
+        invoke  CreateEvent
         test    eax, eax
         jz      .generic_fail
         push    eax     ; .event
         push    edx     ; .event_code
         push    ecx     ; .status
         mov     ecx, [eax+usb_unit_data.Parent]
         stdcall queue_request, ecx, read_write_req, [buffer], read_write_callback, esp
 ; 6. Wait for event. This destroys it.
         mov     eax, [.event]
         mov     ebx, [.event_code]
-        call    WaitEvent
+        invoke  WaitEvent
 ; 7. Get the status. If the operation has failed, abort.
         pop     eax     ; .status
         pop     ecx ecx ; cleanup .event_code, .event
         pop     ecx     ; .length_cur
         test    eax, eax
 ; 5. Set the event.
         mov     eax, [esi+disk_read_write.event-disk_read_write.locals]
         mov     ebx, [esi+disk_read_write.event_code-disk_read_write.locals]
         xor     edx, edx
         xor     esi, esi
-        call    RaiseEvent
+        invoke  RaiseEvent
 ; 6. Return.
         pop     edi esi ebx
         ret     8
 endp
 inquiry_fail    db      'K : INQUIRY command failed',13,10,0
 ;read_capacity_fail db  'K : READ CAPACITY command failed',13,10,0
 ;read_fail      db      'K : READ command failed',13,10,0
 noindex         db      'K : failed to generate disk name',13,10,0
 ; Exported variable: kernel API version.
-align 4
-version dd      50005h
+align 4
 ; Structure with callback functions.
 usb_functions:
         dd      usb_functions_end - usb_functions
         dd      AddDevice
         dd      disk_write
         dd      0       ; flush
         dd      0       ; adjust_cache_size: use default cache
 disk_functions_end:
+data fixups
+end data
 free_numbers_lock       rd      3
 ; 128 devices should be enough for everybody
 free_numbers    dd      -1, -1, -1, -1
-; for DEBUGF macro
-include_debug_strings

Subversion Repositories Kolibri OS

(root)/drivers/usb/usbstor.asm – Rev 4549 → 5051