WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/drivers/usb/urb.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2007-2011. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
struc URB
{
  .fd                       dd  ?
  .bk                       dd  ?
  .dev                      dd  ?    ; pointer to associated device
  .pipe                     dd  ?    ; pipe information
  .status                   dd  ?    ; non-ISO status
  .transfer_flags           dd  ?    ; URB_SHORT_NOT_OK | ...
  .transfer_buffer          dd  ?    ; associated data buffer
  .transfer_dma             dd  ?    ; dma addr for transfer_buffer
  .transfer_buffer_length   dd  ?    ; data buffer length
  .actual_length            dd  ?    ; actual transfer length
  .setup_packet             dd  ?    ; setup packet (control only)
  .setup_dma                dd  ?    ; dma addr for setup_packet
  .start_frame              dd  ?    ; start frame (ISO)
  .number_of_packets        dd  ?    ; number of ISO packets
  .interval                 dd  ?    ; transfer interval
 
  .error_count              dd  ?    ; number of ISO errors
  .context                  dd  ?    ; context for completion
  .complete                 dd  ?    ; (in) completion routine
  .iso_frame_desc:
}
 
virtual at 0
  URB URB
end virtual
 
 
struc REQ        ;usb request
{
  .request_type             db ?
  .request                  db ?
  .value                    dw ?
  .index                    dw ?
  .length                   dw ?
}
 
virtual at 0
  REQ REQ
end virtual
 
align 4
proc usb_control_msg stdcall, dev:dword, pipe:dword, request:dword,\
                         requesttype:dword, value:dword, index:dword,\
                         data:dword, size:dword, timeout:dword
 
           locals
             req    REQ
           endl
 
        lea     eax, [req]
        mov     ecx, [request]
        mov     ebx, [requesttupe]
        mov     edx, [value]
        mov     esi, [index]
        mov     edi, [size]
 
        mov     [eax+REQ.request_type], bl
        mov     [eax+REQ.request], cl
        mov     [eax+REQ.value], dx
        mov     [eax+REQ.index], si
        mov     [eax+REQ.length], di
 
        stdcall usb_internal_control_msg, [dev], [pipe], \
                eax, [data], [size], [timeout]
 
        ret
endp
 
 
; returns status (negative) or length (positive)
static int usb_internal_control_msg(struct usb_device *usb_dev,
                                     unsigned int pipe,
                                     struct usb_ctrlrequest *cmd,
                                     void *data, int len, int timeout)
{
   struct urb *urb;
        int     retv;
        int     length;
 
   urb = usb_alloc_urb(0, GFP_NOIO);
   if (!urb)
      return -ENOMEM;
   usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char *)cmd, data,
                        len, usb_api_blocking_completion, NULL);
 
   retv = usb_start_wait_urb(urb, timeout, &length);
   if (retv < 0)
      return retv;
   else
   return length;
}
 
 
;void usb_fill_control_urb (struct urb *urb,
;                           struct usb_device *dev,
;                           unsigned int pipe,
;                           unsigned char *setup_packet,
;                           void *transfer_buffer,
;                           int buffer_length, 
;                           usb_complete_t complete_fn,
;                           void *context)
;{
;
;   urb->dev = dev;
;   urb->pipe = pipe;
;   urb->setup_packet = setup_packet;
;   urb->transfer_buffer = transfer_buffer;
;   urb->transfer_buffer_length = buffer_length;
;   urb->complete = complete_fn;
;   urb->context = context;
;}
;

Rev 2434	Rev 2465
-		1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		2	;; ;;
-		3	;; Copyright (C) KolibriOS team 2007-2011. All rights reserved. ;;
-		4	;; Distributed under terms of the GNU General Public License ;;
-		5	;; ;;
-		6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1	struc URB	7
2	{	8	struc URB
3	.fd dd ?	9	{
4	.bk dd ?	10	.fd dd ?
5	.dev dd ? ; pointer to associated device	11	.bk dd ?
6	.pipe dd ? ; pipe information	12	.dev dd ? ; pointer to associated device
7	.status dd ? ; non-ISO status	13	.pipe dd ? ; pipe information
8	.transfer_flags dd ? ; URB_SHORT_NOT_OK \| ...	14	.status dd ? ; non-ISO status
9	.transfer_buffer dd ? ; associated data buffer	15	.transfer_flags dd ? ; URB_SHORT_NOT_OK \| ...
10	.transfer_dma dd ? ; dma addr for transfer_buffer	16	.transfer_buffer dd ? ; associated data buffer
11	.transfer_buffer_length dd ? ; data buffer length	17	.transfer_dma dd ? ; dma addr for transfer_buffer
12	.actual_length dd ? ; actual transfer length	18	.transfer_buffer_length dd ? ; data buffer length
13	.setup_packet dd ? ; setup packet (control only)	19	.actual_length dd ? ; actual transfer length
14	.setup_dma dd ? ; dma addr for setup_packet	20	.setup_packet dd ? ; setup packet (control only)
15	.start_frame dd ? ; start frame (ISO)	21	.setup_dma dd ? ; dma addr for setup_packet
16	.number_of_packets dd ? ; number of ISO packets	22	.start_frame dd ? ; start frame (ISO)
17	.interval dd ? ; transfer interval	23	.number_of_packets dd ? ; number of ISO packets
18		24	.interval dd ? ; transfer interval
19	.error_count dd ? ; number of ISO errors	25
20	.context dd ? ; context for completion	26	.error_count dd ? ; number of ISO errors
21	.complete dd ? ; (in) completion routine	27	.context dd ? ; context for completion
22	.iso_frame_desc:	28	.complete dd ? ; (in) completion routine
23	}	29	.iso_frame_desc:
24		30	}
25	virtual at 0	31
26	URB URB	32	virtual at 0
27	end virtual	33	URB URB
28		34	end virtual
29		35
30	struc REQ ;usb request	36
31	{	37	struc REQ ;usb request
32	.request_type db ?	38	{
33	.request db ?	39	.request_type db ?
34	.value dw ?	40	.request db ?
35	.index dw ?	41	.value dw ?
36	.length dw ?	42	.index dw ?
37	}	43	.length dw ?
38		44	}
39	virtual at 0	45
40	REQ REQ	46	virtual at 0
41	end virtual	47	REQ REQ
42		48	end virtual
43	align 4	49
44	proc usb_control_msg stdcall, dev:dword, pipe:dword, request:dword,\	50	align 4
45	requesttype:dword, value:dword, index:dword,\	51	proc usb_control_msg stdcall, dev:dword, pipe:dword, request:dword,\
46	data:dword, size:dword, timeout:dword	52	requesttype:dword, value:dword, index:dword,\
47		53	data:dword, size:dword, timeout:dword
48	locals	54
49	req REQ	55	locals
50	endl	56	req REQ
51		57	endl
52	lea eax, [req]	58
53	mov ecx, [request]	59	lea eax, [req]
54	mov ebx, [requesttupe]	60	mov ecx, [request]
55	mov edx, [value]	61	mov ebx, [requesttupe]
56	mov esi, [index]	62	mov edx, [value]
57	mov edi, [size]	63	mov esi, [index]
58		64	mov edi, [size]
59	mov [eax+REQ.request_type], bl	65
60	mov [eax+REQ.request], cl	66	mov [eax+REQ.request_type], bl
61	mov [eax+REQ.value], dx	67	mov [eax+REQ.request], cl
62	mov [eax+REQ.index], si	68	mov [eax+REQ.value], dx
63	mov [eax+REQ.length], di	69	mov [eax+REQ.index], si
64		70	mov [eax+REQ.length], di
65	stdcall usb_internal_control_msg, [dev], [pipe], \	71
66	eax, [data], [size], [timeout]	72	stdcall usb_internal_control_msg, [dev], [pipe], \
67		73	eax, [data], [size], [timeout]
68	ret	74
69	endp	75	ret
70		76	endp
71		77
72	; returns status (negative) or length (positive)	78
73	static int usb_internal_control_msg(struct usb_device *usb_dev,	79	; returns status (negative) or length (positive)
74	unsigned int pipe,	80	static int usb_internal_control_msg(struct usb_device *usb_dev,
75	struct usb_ctrlrequest *cmd,	81	unsigned int pipe,
76	void *data, int len, int timeout)	82	struct usb_ctrlrequest *cmd,
77	{	83	void *data, int len, int timeout)
78	struct urb *urb;	84	{
79	int retv;	85	struct urb *urb;
80	int length;	86	int retv;
81		87	int length;
82	urb = usb_alloc_urb(0, GFP_NOIO);	88
83	if (!urb)	89	urb = usb_alloc_urb(0, GFP_NOIO);
84	return -ENOMEM;	90	if (!urb)
85	usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char *)cmd, data,	91	return -ENOMEM;
86	len, usb_api_blocking_completion, NULL);	92	usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char *)cmd, data,
87		93	len, usb_api_blocking_completion, NULL);
88	retv = usb_start_wait_urb(urb, timeout, &length);	94
89	if (retv < 0)	95	retv = usb_start_wait_urb(urb, timeout, &length);
90	return retv;	96	if (retv < 0)
91	else	97	return retv;
92	return length;	98	else
93	}	99	return length;
94		100	}
95		101
96	;void usb_fill_control_urb (struct urb *urb,	102
97	; struct usb_device *dev,	103	;void usb_fill_control_urb (struct urb *urb,
98	; unsigned int pipe,	104	; struct usb_device *dev,
99	; unsigned char *setup_packet,	105	; unsigned int pipe,
100	; void *transfer_buffer,	106	; unsigned char *setup_packet,
101	; int buffer_length,	107	; void *transfer_buffer,
102	; usb_complete_t complete_fn,	108	; int buffer_length,
103	; void *context)	109	; usb_complete_t complete_fn,
104	;{	110	; void *context)
105	;	111	;{
106	; urb->dev = dev;	112	;
107	; urb->pipe = pipe;	113	; urb->dev = dev;
108	; urb->setup_packet = setup_packet;	114	; urb->pipe = pipe;
109	; urb->transfer_buffer = transfer_buffer;	115	; urb->setup_packet = setup_packet;
110	; urb->transfer_buffer_length = buffer_length;	116	; urb->transfer_buffer = transfer_buffer;
111	; urb->complete = complete_fn;	117	; urb->transfer_buffer_length = buffer_length;
112	; urb->context = context;	118	; urb->complete = complete_fn;
113	;}	119	; urb->context = context;
114	;	120	;}
-		121	;

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/drivers/usb/urb.inc – Rev 2434 → 2465