WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/bus/usb/uhci.inc

 USB_PID_SETUP = 2Dh
 USB_PID_IN    = 69h
 USB_PID_OUT   = 0E1h
 ; UHCI does not support an interrupt on root hub status change. We must poll
 ; the controller periodically. This is the period in timer ticks (10ms).
-; We use the value 100 ms: it is valid value for USB hub poll rate (1-255 ms),
+; We use the value 100 ticks: it is small enough to be responsive to connect
-; small enough to be responsible to connect events and large enough to not
+; events and large enough to not load CPU too often.
-; load CPU too often.
 UHCI_POLL_INTERVAL = 100
 ; the following constant is an invalid encoding for length fields in
 ; uhci_gtd; it is used to check whether an inactive TD has been
 ; completed (actual length of the transfer is valid) or not processed at all
 ; (actual length of the transfer is UHCI_INVALID_LENGTH).
 ;   specification with some additional fields.
 ; * The hardware uses first two fields (8 bytes). Next two fields are used for
 ;   software book-keeping.
 ; * The hardware requires 16-bytes alignment of the hardware part.
 ;   Since the allocator (usb_allocate_common) allocates memory sequentially
-;   from page start (aligned on 0x1000 bytes), size of the structure must be
+;   from page start (aligned on 0x1000 bytes), block size for the allocator
-;   divisible by 16.
+;   must be divisible by 16; usb1_allocate_endpoint ensures this.
 struct uhci_pipe
 NextQH          dd      ?
 ; 1. First bit (bit 0) is Terminate bit. 1 = there is no next QH.
 ; 2. Next bit (bit 1) is QH/TD select bit. 1 = NextQH points to QH.
 ; 3. Next two bits (bits 2-3) are reserved.
 ; the MaximumLength bitfield encodes maximum packet size,
 ; the Reserved bit 20 is LowSpeedDevice bit.
 ErrorTD         dd      ?
 ; Usually NULL. If nonzero, it is a pointer to descriptor which was error'd
 ; and should be freed sometime in the future (the hardware could still use it).
-SoftwarePart    rd      sizeof.usb_pipe/4
-; Common part for all controllers, described by usb_pipe structure.
 ends
-if sizeof.uhci_pipe mod 16
-.err uhci_pipe must be 16-bytes aligned
-end if
 ; This structure describes the static head of every list of pipes.
 ; The hardware requires 16-bytes alignment of this structure.
 ; All instances of this structure are located sequentially in uhci_controller,
 ; uhci_controller is page-aligned, so it is sufficient to make this structure
 ; * The hardware part consists of first 16 bytes and corresponds to the
 ;   Transfer Descriptor aka TD from UHCI specification.
 ; * The hardware requires 16-bytes alignment of the hardware part, so
 ;   the entire descriptor must be 16-bytes aligned. Since the allocator
 ;   (uhci_allocate_common) allocates memory sequentially from page start
-;   (aligned on 0x1000 bytes), size of the structure must be divisible by 16.
+;   (aligned on 0x1000 bytes), block size for the allocator must be
+;   divisible by 16; usb1_allocate_general_td ensures this.
 struct uhci_gtd
 NextTD          dd      ?
 ; 1. First bit (bit 0) is Terminate bit. 1 = there is no next TD.
 ; 2. Next bit (bit 1) is QH/TD select bit. 1 = NextTD points to QH.
 ;    This bit is always set to 0 in the implementation.
 ; Usually NULL. If the original buffer crosses a page boundary, this is a
 ; pointer to the structure uhci_original_buffer for this request.
 ; bit 0: 1 = short packet is NOT allowed
 ; (before the TD is processed, it is the copy of bit 29 of ControlStatus;
 ;  some controllers modify that bit, so we need a copy in a safe place)
-SoftwarePart    rd      sizeof.usb_gtd/4
-; Software part, common for all controllers.
 ends
-if sizeof.uhci_gtd mod 16
-.err uhci_gtd must be 16-bytes aligned
-end if
 ; UHCI requires that the entire transfer buffer should be on one page.
 ; If the actual buffer crosses page boundary, uhci_alloc_packet
 ; allocates additional memory for buffer for hardware.
 ; This structure describes correspondence between two buffers.
 .tdloop:
 ; 3. For every descriptor, test active flag and check for end-of-queue;
 ; if either of conditions holds, exit from the internal loop.
         cmp     ebx, [esp]
         jz      .tddone
-        mov     eax, [ebx+uhci_gtd.ControlStatus-uhci_gtd.SoftwarePart]
+        mov     eax, [ebx+uhci_gtd.ControlStatus-sizeof.uhci_gtd]
         test    eax, 1 shl 23   ; active?
         jnz     .tddone
 ; Release the queue lock while processing one descriptor:
 ; callback function could (and often would) schedule another transfer.
         push    ecx
 ;       DEBUGF 1,'K : finalized TD:\n'
 ;       DEBUGF 1,'K : %x %x %x %x\n',[ebx-20],[ebx-16],[ebx-12],[ebx-8]
 ;       DEBUGF 1,'K : %x %x %x %x\n',[ebx-4],[ebx],[ebx+4],[ebx+8]
 ; 2. If this is IN transfer into special buffer, copy the data
 ; to target location.
-        mov     edx, [ebx+uhci_gtd.OrigBufferInfo-uhci_gtd.SoftwarePart]
+        mov     edx, [ebx+uhci_gtd.OrigBufferInfo-sizeof.uhci_gtd]
         and     edx, not 1      ; clear lsb (used for another goal)
         jz      .nocopy
-        cmp     byte [ebx+uhci_gtd.Token-uhci_gtd.SoftwarePart], USB_PID_IN
+        cmp     byte [ebx+uhci_gtd.Token-sizeof.uhci_gtd], USB_PID_IN
         jnz     .nocopy
 ; Note: we assume that pointer to buffer is valid in the memory space of
 ; the USB thread. This means that buffer must reside in kernel memory
 ; (shared by all processes).
         push    esi edi
         mov     esi, [edx+uhci_original_buffer.UsedBuffer]
         mov     edi, [edx+uhci_original_buffer.OrigBuffer]
-        mov     ecx, [ebx+uhci_gtd.ControlStatus-uhci_gtd.SoftwarePart]
+        mov     ecx, [ebx+uhci_gtd.ControlStatus-sizeof.uhci_gtd]
         inc     ecx
         and     ecx, 7FFh
         mov     edx, ecx
         shr     ecx, 2
         and     edx, 3
         rep movsb
         pop     edi esi
 .nocopy:
 ; 3. Calculate actual number of bytes transferred.
 ; 3a. Read the state.
-        mov     eax, [ebx+uhci_gtd.ControlStatus-uhci_gtd.SoftwarePart]
+        mov     eax, [ebx+uhci_gtd.ControlStatus-sizeof.uhci_gtd]
-        mov     ecx, [ebx+uhci_gtd.Token-uhci_gtd.SoftwarePart]
+        mov     ecx, [ebx+uhci_gtd.Token-sizeof.uhci_gtd]
 ; 3b. Get number of bytes processed.
         lea     edx, [eax+1]
         and     edx, 7FFh
 ; 3c. Subtract number of bytes in this packet.
         add     ecx, 1 shl 21
 ; because the caller disallowed short packets or because the packet is not
 ; the last one in the corresponding transfer).
         xor     ecx, ecx
         test    eax, 1 shl 22
         jnz     .error
-        test    byte [ebx+uhci_gtd.OrigBufferInfo-uhci_gtd.SoftwarePart], 1
+        test    byte [ebx+uhci_gtd.OrigBufferInfo-sizeof.uhci_gtd], 1
         jz      .notify
         cmp     edx, [ebx+usb_gtd.Length]
         jz      .notify
 .error:
 ; 5. There was an error while processing this packet.
 ; The hardware has stopped processing the queue.
         DEBUGF 1,'K : TD failed:\n'
-if uhci_gtd.SoftwarePart <> 20
+if sizeof.uhci_gtd <> 20
 .err modify offsets for debug output
 end if
         DEBUGF 1,'K : %x %x %x %x\n',[ebx-20],[ebx-16],[ebx-12],[ebx-8]
         DEBUGF 1,'K : %x %x %x %x\n',[ebx-4],[ebx],[ebx+4],[ebx+8]
 ; 5a. Save the status and length.
         push    edx
         push    eax
         mov     eax, [ebx+usb_gtd.Pipe]
-        DEBUGF 1,'K : pipe: %x %x\n',[eax+0-uhci_pipe.SoftwarePart],[eax+4-uhci_pipe.SoftwarePart]
+        DEBUGF 1,'K : pipe: %x %x\n',[eax+0-sizeof.uhci_pipe],[eax+4-sizeof.uhci_pipe]
 ; 5b. Store the current TD as an error packet.
 ; If an error packet is already stored for this pipe,
 ; it is definitely not used already, so free the old packet.
-        mov     eax, [eax+uhci_pipe.ErrorTD-uhci_pipe.SoftwarePart]
+        mov     eax, [eax+uhci_pipe.ErrorTD-sizeof.uhci_pipe]
         test    eax, eax
         jz      @f
         stdcall uhci_free_td, eax
 @@:
         mov     eax, [ebx+usb_gtd.Pipe]
-        mov     [eax+uhci_pipe.ErrorTD-uhci_pipe.SoftwarePart], ebx
+        mov     [eax+uhci_pipe.ErrorTD-sizeof.uhci_pipe], ebx
 ; 5c. Traverse the list of descriptors looking for the final packet
 ; for this transfer.
 ; Free and unlink non-final descriptors, except the current one.
 ; Final descriptor will be freed in step 7.
         call    usb_is_final_packet
 ; as short-packet-is-error to stop controller from further processing
 ; of that stage; we need to restart processing from a TD following the last.
 ; After that, go to step 6 with ecx = 0 (no error).
         cmp     ecx, USB_STATUS_UNDERRUN
         jnz     @f
-        test    byte [ebx+uhci_gtd.OrigBufferInfo-uhci_gtd.SoftwarePart], 1
+        test    byte [ebx+uhci_gtd.OrigBufferInfo-sizeof.uhci_gtd], 1
         jnz     @f
 ; The controller has stopped this queue on the error packet.
 ; Update uhci_pipe.HeadTD to point to the next packet in the queue.
         call    uhci_fix_toggle
         xor     ecx, ecx
 .control:
-        mov     eax, [ebx+uhci_gtd.NextTD-uhci_gtd.SoftwarePart]
+        mov     eax, [ebx+uhci_gtd.NextTD-sizeof.uhci_gtd]
         and     al, not 0xF
         mov     edx, [ebx+usb_gtd.Pipe]
-        mov     [edx+uhci_pipe.HeadTD-uhci_pipe.SoftwarePart], eax
+        mov     [edx+uhci_pipe.HeadTD-sizeof.uhci_pipe], eax
         pop     edx     ; length
         jmp     .notify
 @@:
 ; 5f. Abort the entire transfer.
 ; There are two cases: either there is only one transfer stage
         jnz     .normal
 ; We cannot free ErrorTD yet, it could still be used by the hardware.
         push    ecx
         mov     eax, [ebx+usb_gtd.Pipe]
         push    [ebx+usb_gtd.NextVirt]
-        cmp     ebx, [eax+uhci_pipe.ErrorTD-uhci_pipe.SoftwarePart]
+        cmp     ebx, [eax+uhci_pipe.ErrorTD-sizeof.uhci_pipe]
         jz      @f
         stdcall uhci_free_td, ebx
 @@:
         pop     ebx
         call    usb_unlink_td
 ; support functional stall as well, but this is not recommended.").
         mov     edx, [ebx+usb_gtd.Pipe]
         cmp     [edx+usb_pipe.Type], CONTROL_PIPE
         jz      .control
 ; Bulk/interrupt transfer; halt the queue.
-        mov     eax, [ebx+uhci_gtd.NextTD-uhci_gtd.SoftwarePart]
+        mov     eax, [ebx+uhci_gtd.NextTD-sizeof.uhci_gtd]
         and     al, not 0xF
         inc     eax     ; set Halted bit
-        mov     [edx+uhci_pipe.HeadTD-uhci_pipe.SoftwarePart], eax
+        mov     [edx+uhci_pipe.HeadTD-sizeof.uhci_pipe], eax
         pop     edx     ; restore length saved in step 5a
 .notify:
 ; 6. Either the descriptor in ebx was processed without errors,
 ; or all necessary error actions were taken and ebx points to the last
 ; related descriptor.
 ; 7. Free the current descriptor (if allowed) and return the next one.
 ; 7a. Save pointer to the next descriptor.
         push    [ebx+usb_gtd.NextVirt]
 ; 7b. Free the descriptor, unless it is saved as ErrorTD.
         mov     eax, [ebx+usb_gtd.Pipe]
-        cmp     [eax+uhci_pipe.ErrorTD-uhci_pipe.SoftwarePart], ebx
+        cmp     [eax+uhci_pipe.ErrorTD-sizeof.uhci_pipe], ebx
         jz      @f
         stdcall uhci_free_td, ebx
 @@:
 ; 7c. Restore pointer to the next descriptor and return.
         pop     ebx
         cmp     [ecx+usb_pipe.Type], CONTROL_PIPE
         jz      .nothing
 ; 2. The hardware expects next packet with toggle = (ErrorTD.toggle xor 1),
 ; the current value in next packet is (ebx.toggle xor 1).
 ; Nothing to do if ErrorTD.toggle == ebx.toggle.
-        mov     eax, [ecx+uhci_pipe.ErrorTD-uhci_pipe.SoftwarePart]
+        mov     eax, [ecx+uhci_pipe.ErrorTD-sizeof.uhci_pipe]
-        mov     eax, [eax+uhci_gtd.Token-uhci_gtd.SoftwarePart]
+        mov     eax, [eax+uhci_gtd.Token-sizeof.uhci_gtd]
-        xor     eax, [ebx+uhci_gtd.Token-uhci_gtd.SoftwarePart]
+        xor     eax, [ebx+uhci_gtd.Token-sizeof.uhci_gtd]
         test    eax, 1 shl 19
         jz      .nothing
 ; 3. Lock the transfer queue.
         add     ecx, usb_pipe.Lock
         call    mutex_lock
 ; 4. Flip the toggle bit in all packets from ebx.NextVirt to ecx.LastTD
 ; (inclusive).
         mov     eax, [ebx+usb_gtd.NextVirt]
 .loop:
-        xor     byte [eax+uhci_gtd.Token-uhci_gtd.SoftwarePart+2], 1 shl (19-16)
+        xor     byte [eax+uhci_gtd.Token-sizeof.uhci_gtd+2], 1 shl (19-16)
         cmp     eax, [ecx+usb_pipe.LastTD-usb_pipe.Lock]
         mov     eax, [eax+usb_gtd.NextVirt]
         jnz     .loop
 ; 5. Flip the toggle bit in uhci_pipe structure.
-        xor     byte [ecx+uhci_pipe.Token-uhci_pipe.SoftwarePart-usb_pipe.Lock+2], 1 shl (19-16)
+        xor     byte [ecx+uhci_pipe.Token-sizeof.uhci_pipe-usb_pipe.Lock+2], 1 shl (19-16)
-        or      dword [ecx+uhci_pipe.Token-uhci_pipe.SoftwarePart-usb_pipe.Lock], eax
+        or      dword [ecx+uhci_pipe.Token-sizeof.uhci_pipe-usb_pipe.Lock], eax
 ; 6. Unlock the transfer queue.
         call    mutex_unlock
 .nothing:
         ret
 endp
 ; This procedure is called from usb_set_address_callback
 ; and stores USB device address in the uhci_pipe structure.
 ; in: esi -> usb_controller, ebx -> usb_pipe, cl = address
 proc uhci_set_device_address
-        mov     byte [ebx+uhci_pipe.Token+1-uhci_pipe.SoftwarePart], cl
+        mov     byte [ebx+uhci_pipe.Token+1-sizeof.uhci_pipe], cl
         call    usb_subscription_done
         ret
 endp
 ; This procedure returns USB device address from the uhci_pipe structure.
 ; in: esi -> usb_controller, ebx -> usb_pipe
 ; out: eax = endpoint address
 proc uhci_get_device_address
-        mov     al, byte [ebx+uhci_pipe.Token+1-uhci_pipe.SoftwarePart]
+        mov     al, byte [ebx+uhci_pipe.Token+1-sizeof.uhci_pipe]
         and     eax, 7Fh
         ret
 ; stores the packet size in uhci_pipe structure.
 ; in: esi -> usb_controller, ebx -> usb_pipe, ecx = packet size
 proc uhci_set_endpoint_packet_size
         dec     ecx
         shl     ecx, 21
-        and     [ebx+uhci_pipe.Token-uhci_pipe.SoftwarePart], (1 shl 21) - 1
+        and     [ebx+uhci_pipe.Token-sizeof.uhci_pipe], (1 shl 21) - 1
-        or      [ebx+uhci_pipe.Token-uhci_pipe.SoftwarePart], ecx
+        or      [ebx+uhci_pipe.Token-sizeof.uhci_pipe], ecx
 ; uhci_pipe.Token field is purely for software bookkeeping and does not affect
 ; the hardware; thus, we can continue initialization immediately.
         call    usb_subscription_done
         ret
 endp
 .maxpacket      dd      ?
 .type           dd      ?
 .interval       dd      ?
 end virtual
 ; 1. Initialize ErrorTD to zero.
-        and     [edi+uhci_pipe.ErrorTD-uhci_pipe.SoftwarePart], 0
+        and     [edi+uhci_pipe.ErrorTD-sizeof.uhci_pipe], 0
 ; 2. Initialize HeadTD to the physical address of the first TD.
-        push    eax     ; store pointer to the first TD for step ?
+        push    eax     ; store pointer to the first TD for step 4
-        sub     eax, uhci_gtd.SoftwarePart
+        sub     eax, sizeof.uhci_gtd
         call    get_phys_addr
-        mov     [edi+uhci_pipe.HeadTD-uhci_pipe.SoftwarePart], eax
+        mov     [edi+uhci_pipe.HeadTD-sizeof.uhci_pipe], eax
 ; 3. Initialize Token field:
 ; take DeviceAddress and LowSpeedDevice from the parent pipe,
 ; take Endpoint and MaximumLength fields from API arguments,
 ; set PID depending on pipe type and provided pipe direction,
 ; set DataToggle to zero.
-        mov     eax, [ecx+uhci_pipe.Token-uhci_pipe.SoftwarePart]
+        mov     eax, [ecx+uhci_pipe.Token-sizeof.uhci_pipe]
         and     eax, 0x107F00   ; keep DeviceAddress and LowSpeedDevice
         mov     edx, [.endpoint]
         and     edx, 15
         shl     edx, 15
         or      eax, edx
         mov     al, USB_PID_OUT
         test    byte [.endpoint], 80h
         jz      @f
         mov     al, USB_PID_IN
 @@:
-        mov     [edi+uhci_pipe.Token-uhci_pipe.SoftwarePart], eax
+        mov     [edi+uhci_pipe.Token-sizeof.uhci_pipe], eax
 ; 4. Initialize the first TD:
 ; copy Token from uhci_pipe.Token zeroing reserved bit 20,
 ; set ControlStatus for future transfers, bit make it inactive,
-; set bit 0 in NextTD = "no next TD".
+; set bit 0 in NextTD = "no next TD",
+; zero OrigBufferInfo.
         pop     edx     ; restore pointer saved in step 2
-        mov     [edx+uhci_gtd.Token-uhci_gtd.SoftwarePart], eax
+        mov     [edx+uhci_gtd.Token-sizeof.uhci_gtd], eax
-        and     byte [edx+uhci_gtd.Token+2-uhci_gtd.SoftwarePart], not (1 shl (20-16))
+        and     byte [edx+uhci_gtd.Token+2-sizeof.uhci_gtd], not (1 shl (20-16))
         and     eax, 1 shl 20
         shl     eax, 6
         or      eax, UHCI_INVALID_LENGTH + (3 shl 27)
                 ; not processed, inactive, allow 3 errors
+        and     [edx+uhci_gtd.OrigBufferInfo-sizeof.uhci_gtd], 0
-        mov     [edx+uhci_gtd.ControlStatus-uhci_gtd.SoftwarePart], eax
+        mov     [edx+uhci_gtd.ControlStatus-sizeof.uhci_gtd], eax
-        mov     [edx+uhci_gtd.NextTD-uhci_gtd.SoftwarePart], 1
+        mov     [edx+uhci_gtd.NextTD-sizeof.uhci_gtd], 1
 ; 5. Select the corresponding list and insert to the list.
 ; 5a. Use Control list for control pipes, Bulk list for bulk pipes.
         lea     edx, [esi+uhci_controller.ControlED.SoftwarePart-sizeof.uhci_controller]
         cmp     [.type], BULK_PIPE
         jb      .insert ; control pipe
         mov     [ecx+usb_pipe.PrevVirt], edi
         mov     [edx+usb_pipe.NextVirt], edi
 ; 5d. Insert in the hardware list: copy previous NextQH to the new pipe,
 ; store the physical address of the new pipe to previous NextQH.
         mov     ecx, [edx+uhci_static_ep.NextQH-uhci_static_ep.SoftwarePart]
-        mov     [edi+uhci_pipe.NextQH-uhci_pipe.SoftwarePart], ecx
+        mov     [edi+uhci_pipe.NextQH-sizeof.uhci_pipe], ecx
-        lea     eax, [edi-uhci_pipe.SoftwarePart]
+        lea     eax, [edi-sizeof.uhci_pipe]
         call    get_phys_addr
         inc     eax
         inc     eax
         mov     [edx+uhci_static_ep.NextQH-uhci_static_ep.SoftwarePart], eax
 ; 6. Return with nonzero eax.
         ret
 endp
 ; This procedure is called when a pipe is closing (either due to API call
 ; or due to disconnect); it unlinks a pipe from the corresponding list.
-if uhci_static_ep.SoftwarePart <> uhci_pipe.SoftwarePart
+if uhci_static_ep.SoftwarePart <> sizeof.uhci_pipe
-.err uhci_unlink_pipe assumes that uhci_static_ep.SoftwarePart == uhci_pipe.SoftwarePart
+.err uhci_unlink_pipe assumes that uhci_static_ep.SoftwarePart == sizeof.uhci_pipe
 end if
 proc uhci_unlink_pipe
         cmp     [ebx+usb_pipe.Type], INTERRUPT_PIPE
         jnz     @f
-        mov     eax, [ebx+uhci_pipe.Token-uhci_pipe.SoftwarePart]
+        mov     eax, [ebx+uhci_pipe.Token-sizeof.uhci_pipe]
         cmp     al, USB_PID_IN
         setz    ch
         bt      eax, 20
         setc    cl
         mov     eax, [ebx+usb_pipe.PrevVirt]
         mov     [edx+usb_pipe.PrevVirt], eax
         mov     [eax+usb_pipe.NextVirt], edx
 ; Note: eax could be either usb_pipe or usb_static_ep;
 ; fortunately, NextQH and SoftwarePart have same offsets in both.
-        mov     edx, [ebx+uhci_pipe.NextQH-uhci_pipe.SoftwarePart]
+        mov     edx, [ebx+uhci_pipe.NextQH-sizeof.uhci_pipe]
-        mov     [eax+uhci_pipe.NextQH-uhci_pipe.SoftwarePart], edx
+        mov     [eax+uhci_pipe.NextQH-sizeof.uhci_pipe], edx
         ret
 endp
 ; Free memory associated with pipe.
 ; For UHCI, this includes usb_pipe structure and ErrorTD, if present.
 proc uhci_free_pipe
         mov     eax, [esp+4]
-        mov     eax, [eax+uhci_pipe.ErrorTD-uhci_pipe.SoftwarePart]
+        mov     eax, [eax+uhci_pipe.ErrorTD-sizeof.uhci_pipe]
         test    eax, eax
         jz      @f
         stdcall uhci_free_td, eax
 @@:
         mov     [origTD], eax
 ; In UHCI one TD describes one packet, transfers should be split into parts
 ; with size <= endpoint max packet size.
 ; 2. Get the maximum packet size for endpoint from uhci_pipe.Token
 ; and generate Token field for TDs.
-        mov     edi, [ebx+uhci_pipe.Token-uhci_pipe.SoftwarePart]
+        mov     edi, [ebx+uhci_pipe.Token-sizeof.uhci_pipe]
         mov     eax, edi
         shr     edi, 21
         inc     edi
 ; zero packet size (it will be set for every packet individually),
 ; zero reserved bit 20,
 ; if one of them will be short, the software intervention is needed
 ; to skip remaining packets; uhci_process_finalized_td will handle this
 ; transparently to the caller.
         test    [flags], 1
         jz      @f
-        and     byte [ecx+uhci_gtd.ControlStatus+3-uhci_gtd.SoftwarePart], not (1 shl (29-24))
+        and     byte [ecx+uhci_gtd.ControlStatus+3-sizeof.uhci_gtd], not (1 shl (29-24))
-        and     byte [ecx+uhci_gtd.OrigBufferInfo-uhci_gtd.SoftwarePart], not 1
+        and     byte [ecx+uhci_gtd.OrigBufferInfo-sizeof.uhci_gtd], not 1
 @@:
 ; 6. Update toggle bit in uhci_pipe structure from current value of [token].
         mov     edx, [token]
-        xor     edx, [ebx+uhci_pipe.Token-uhci_pipe.SoftwarePart]
+        xor     edx, [ebx+uhci_pipe.Token-sizeof.uhci_pipe]
         and     edx, 1 shl 19
-        xor     [ebx+uhci_pipe.Token-uhci_pipe.SoftwarePart], edx
+        xor     [ebx+uhci_pipe.Token-sizeof.uhci_pipe], edx
 .nothing:
         ret
 .fail:
         mov     edi, uhci_hardware_func
         mov     eax, [td]
         test    edx, -0x1000
         jz      .notempbuf
 ; 1c. We need a temporary buffer. Allocate [packetSize]*2 bytes, so that
 ; there must be [packetSize] bytes on one page,
 ; plus space for a header uhci_original_buffer.
-        push    ebx
         mov     eax, [.packetSize]
         add     eax, eax
         add     eax, sizeof.uhci_original_buffer
         call    malloc
-        pop     ebx
 ; 1d. If failed, return zero.
         test    eax, eax
         jz      .nothing
 ; 1e. Test whether [.packetSize] bytes starting from
 ; eax + sizeof.uhci_original_buffer are in the same page.
         call    usb_init_transfer
 ; 4. Initialize the next TD:
 ; mark it as last one (this will be changed when further packets will be
 ; allocated), copy Token field from uhci_pipe.Token zeroing bit 20,
 ; generate ControlStatus field, mark as Active
-; (for last descriptor, this will be changed by uhci_insert_transfer).
+; (for last descriptor, this will be changed by uhci_insert_transfer),
+; zero OrigBufferInfo (otherwise uhci_free_td would try to free it).
+        and     [eax+uhci_gtd.OrigBufferInfo-sizeof.uhci_gtd], 0
-        mov     [eax+uhci_gtd.NextTD-uhci_gtd.SoftwarePart], 1  ; no next TD
+        mov     [eax+uhci_gtd.NextTD-sizeof.uhci_gtd], 1  ; no next TD
-        mov     edx, [ebx+uhci_pipe.Token-uhci_pipe.SoftwarePart]
+        mov     edx, [ebx+uhci_pipe.Token-sizeof.uhci_pipe]
-        mov     [eax+uhci_gtd.Token-uhci_gtd.SoftwarePart], edx
+        mov     [eax+uhci_gtd.Token-sizeof.uhci_gtd], edx
-        and     byte [eax+uhci_gtd.Token+2-uhci_gtd.SoftwarePart], not (1 shl (20-16))
+        and     byte [eax+uhci_gtd.Token+2-sizeof.uhci_gtd], not (1 shl (20-16))
         and     edx, 1 shl 20
         shl     edx, 6
         or      edx, UHCI_INVALID_LENGTH + (1 shl 23) + (3 shl 27)
                 ; not processed, active, allow 3 errors
-        mov     [eax+uhci_gtd.ControlStatus-uhci_gtd.SoftwarePart], edx
+        mov     [eax+uhci_gtd.ControlStatus-sizeof.uhci_gtd], edx
 ; 5. Initialize remaining fields of the current TD.
 ; 5a. Store pointer to the buffer allocated in step 1 (or zero).
-        pop     [ecx+uhci_gtd.OrigBufferInfo-uhci_gtd.SoftwarePart]
+        pop     [ecx+uhci_gtd.OrigBufferInfo-sizeof.uhci_gtd]
 ; 5b. Store physical address of the next TD.
         push    eax
-        sub     eax, uhci_gtd.SoftwarePart
+        sub     eax, sizeof.uhci_gtd
         call    get_phys_addr
-; use Depth traversal unless this is the first TD in the transfer stage;
+; for Control/Bulk pipes, use Depth traversal unless this is the first TD
+; in the transfer stage;
 ; uhci_insert_transfer will set Depth traversal for the first TD and clear
 ; it in the last TD
+        test    [ebx+usb_pipe.Type], 1
+        jnz     @f
         cmp     ecx, [ebx+usb_pipe.LastTD]
         jz      @f
         or      eax, 4
 @@:
-        mov     [ecx+uhci_gtd.NextTD-uhci_gtd.SoftwarePart], eax
+        mov     [ecx+uhci_gtd.NextTD-sizeof.uhci_gtd], eax
 ; 5c. Store physical address of the buffer: zero if no data present,
 ; the temporary buffer if it was allocated, the given buffer otherwise.
         xor     eax, eax
         cmp     [.packetSize], eax
         jz      .hasphysbuf
         mov     eax, [.buffer]
-        mov     edx, [ecx+uhci_gtd.OrigBufferInfo-uhci_gtd.SoftwarePart]
+        mov     edx, [ecx+uhci_gtd.OrigBufferInfo-sizeof.uhci_gtd]
         test    edx, edx
         jz      @f
         mov     eax, [edx+uhci_original_buffer.UsedBuffer]
 @@:
         call    get_phys_addr
 .hasphysbuf:
-        mov     [ecx+uhci_gtd.Buffer-uhci_gtd.SoftwarePart], eax
+        mov     [ecx+uhci_gtd.Buffer-sizeof.uhci_gtd], eax
 ; 5d. For IN transfers, disallow short packets.
 ; This will be overridden, if needed, by uhci_alloc_transfer.
         mov     eax, [.token]
         mov     edx, [.packetSize]
         dec     edx
         cmp     al, USB_PID_IN
         jnz     @f
-        or      byte [ecx+uhci_gtd.ControlStatus+3-uhci_gtd.SoftwarePart], 1 shl (29-24)        ; disallow short packets
+        or      byte [ecx+uhci_gtd.ControlStatus+3-sizeof.uhci_gtd], 1 shl (29-24)        ; disallow short packets
-        or      byte [ecx+uhci_gtd.OrigBufferInfo-uhci_gtd.SoftwarePart], 1
+        or      byte [ecx+uhci_gtd.OrigBufferInfo-sizeof.uhci_gtd], 1
 @@:
 ; 5e. Get Token field: combine [.token] with [.packetSize].
         shl     edx, 21
         or      edx, eax
-        mov     [ecx+uhci_gtd.Token-uhci_gtd.SoftwarePart], edx
+        mov     [ecx+uhci_gtd.Token-sizeof.uhci_gtd], edx
 ; 6. Flip toggle bit in [.token].
         xor     eax, 1 shl 19
         mov     [.token], eax
 ; 7. Return pointer to the next TD.
         pop     eax
 ; and activates the transfer which was previously allocated by
 ; uhci_alloc_transfer.
 ; ecx -> last descriptor for the transfer, ebx -> usb_pipe
 proc uhci_insert_transfer
 ;       DEBUGF 1,'K : uhci_insert_transfer: eax=%x, ecx=%x, [esp+4]=%x\n',eax,ecx,[esp+4]
-        and     byte [eax+uhci_gtd.ControlStatus+2-uhci_gtd.SoftwarePart], not (1 shl (23-16))  ; clear Active bit
+        and     byte [eax+uhci_gtd.ControlStatus+2-sizeof.uhci_gtd], not (1 shl (23-16))  ; clear Active bit
-        or      byte [ecx+uhci_gtd.ControlStatus+3-uhci_gtd.SoftwarePart], 1 shl (24-24)        ; set InterruptOnComplete bit
+        or      byte [ecx+uhci_gtd.ControlStatus+3-sizeof.uhci_gtd], 1 shl (24-24)        ; set InterruptOnComplete bit
         mov     eax, [esp+4]
-        or      byte [eax+uhci_gtd.ControlStatus+2-uhci_gtd.SoftwarePart], 1 shl (23-16)        ; set Active bit
+        or      byte [eax+uhci_gtd.ControlStatus+2-sizeof.uhci_gtd], 1 shl (23-16)        ; set Active bit
+        test    [ebx+usb_pipe.Type], 1
+        jnz     @f
-        or      byte [eax+uhci_gtd.NextTD-uhci_gtd.SoftwarePart], 4     ; set Depth bit
+        or      byte [eax+uhci_gtd.NextTD-sizeof.uhci_gtd], 4     ; set Depth bit
+@@:
         ret
 endp
 ; Free all memory associated with one TD.
 ; For UHCI, this includes memory for uhci_gtd itself
 ; and the temporary buffer, if present.
 proc uhci_free_td
         mov     eax, [esp+4]
-        mov     eax, [eax+uhci_gtd.OrigBufferInfo-uhci_gtd.SoftwarePart]
+        mov     eax, [eax+uhci_gtd.OrigBufferInfo-sizeof.uhci_gtd]
         and     eax, not 1
         jz      .nobuf
         push    ebx
         call    free
         pop     ebx
 .nobuf:
-        sub     dword [esp+4], uhci_gtd.SoftwarePart
+        sub     dword [esp+4], sizeof.uhci_gtd
         jmp     usb_free_common

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/bus/usb/uhci.inc – Rev 3626 → 3725