source: mainline/uspace/drv/vhc/connhost.c@ 7dfc06fa

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 7dfc06fa was 7dfc06fa, checked in by Vojtech Horky <vojtechhorky@…>, 14 years ago

Do not send max packet size with each transfer

See ticket #177, #121 and partly #49.
  • Property mode set to 100644
File size: 10.9 KB
Line 
1/*
2 * Copyright (c) 2010 Vojtech Horky
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup drvusbvhc
30 * @{
31 */
32/** @file
33 * @brief Connection handling of calls from host (implementation).
34 */
35#include <assert.h>
36#include <errno.h>
37#include <usb/usb.h>
38#include <usb/addrkeep.h>
39#include <usb/ddfiface.h>
40
41#include "vhcd.h"
42#include "conn.h"
43#include "hc.h"
44
45
46typedef struct {
47 usb_direction_t direction;
48 usbhc_iface_transfer_out_callback_t out_callback;
49 usbhc_iface_transfer_in_callback_t in_callback;
50 ddf_fun_t *fun;
51 size_t reported_size;
52 void *arg;
53} transfer_info_t;
54
55typedef struct {
56 usb_direction_t direction;
57 usb_target_t target;
58 usbhc_iface_transfer_out_callback_t out_callback;
59 usbhc_iface_transfer_in_callback_t in_callback;
60 ddf_fun_t *fun;
61 void *arg;
62 void *data_buffer;
63 size_t data_buffer_size;
64} control_transfer_info_t;
65
66static void universal_callback(void *buffer, size_t size,
67 int outcome, void *arg)
68{
69 transfer_info_t *transfer = (transfer_info_t *) arg;
70
71 if (transfer->reported_size != (size_t) -1) {
72 size = transfer->reported_size;
73 }
74
75 switch (transfer->direction) {
76 case USB_DIRECTION_IN:
77 transfer->in_callback(transfer->fun,
78 outcome, size,
79 transfer->arg);
80 break;
81 case USB_DIRECTION_OUT:
82 transfer->out_callback(transfer->fun,
83 outcome,
84 transfer->arg);
85 break;
86 default:
87 assert(false && "unreachable");
88 break;
89 }
90
91 free(transfer);
92}
93
94static transfer_info_t *create_transfer_info(ddf_fun_t *fun,
95 usb_direction_t direction, void *arg)
96{
97 transfer_info_t *transfer = malloc(sizeof(transfer_info_t));
98
99 transfer->direction = direction;
100 transfer->in_callback = NULL;
101 transfer->out_callback = NULL;
102 transfer->arg = arg;
103 transfer->fun = fun;
104 transfer->reported_size = (size_t) -1;
105
106 return transfer;
107}
108
109static void control_abort_prematurely(control_transfer_info_t *transfer,
110 size_t size, int outcome)
111{
112 switch (transfer->direction) {
113 case USB_DIRECTION_IN:
114 transfer->in_callback(transfer->fun,
115 outcome, size,
116 transfer->arg);
117 break;
118 case USB_DIRECTION_OUT:
119 transfer->out_callback(transfer->fun,
120 outcome,
121 transfer->arg);
122 break;
123 default:
124 assert(false && "unreachable");
125 break;
126 }
127}
128
129static void control_callback_two(void *buffer, size_t size,
130 int outcome, void *arg)
131{
132 control_transfer_info_t *ctrl_transfer = (control_transfer_info_t *) arg;
133
134 if (outcome != EOK) {
135 control_abort_prematurely(ctrl_transfer, outcome, size);
136 free(ctrl_transfer);
137 return;
138 }
139
140 transfer_info_t *transfer = create_transfer_info(ctrl_transfer->fun,
141 ctrl_transfer->direction, ctrl_transfer->arg);
142 transfer->out_callback = ctrl_transfer->out_callback;
143 transfer->in_callback = ctrl_transfer->in_callback;
144 transfer->reported_size = size;
145
146 switch (ctrl_transfer->direction) {
147 case USB_DIRECTION_IN:
148 hc_add_transaction_to_device(false, ctrl_transfer->target,
149 USB_TRANSFER_CONTROL,
150 NULL, 0,
151 universal_callback, transfer);
152 break;
153 case USB_DIRECTION_OUT:
154 hc_add_transaction_from_device(ctrl_transfer->target,
155 USB_TRANSFER_CONTROL,
156 NULL, 0,
157 universal_callback, transfer);
158 break;
159 default:
160 assert(false && "unreachable");
161 break;
162 }
163
164 free(ctrl_transfer);
165}
166
167static void control_callback_one(void *buffer, size_t size,
168 int outcome, void *arg)
169{
170 control_transfer_info_t *transfer = (control_transfer_info_t *) arg;
171
172 if (outcome != EOK) {
173 control_abort_prematurely(transfer, outcome, size);
174 free(transfer);
175 return;
176 }
177
178 switch (transfer->direction) {
179 case USB_DIRECTION_IN:
180 hc_add_transaction_from_device(transfer->target,
181 USB_TRANSFER_CONTROL,
182 transfer->data_buffer, transfer->data_buffer_size,
183 control_callback_two, transfer);
184 break;
185 case USB_DIRECTION_OUT:
186 hc_add_transaction_to_device(false, transfer->target,
187 USB_TRANSFER_CONTROL,
188 transfer->data_buffer, transfer->data_buffer_size,
189 control_callback_two, transfer);
190 break;
191 default:
192 assert(false && "unreachable");
193 break;
194 }
195}
196
197static control_transfer_info_t *create_control_transfer_info(ddf_fun_t *fun,
198 usb_direction_t direction, usb_target_t target,
199 void *data_buffer, size_t data_buffer_size,
200 void *arg)
201{
202 control_transfer_info_t *transfer
203 = malloc(sizeof(control_transfer_info_t));
204
205 transfer->direction = direction;
206 transfer->target = target;
207 transfer->in_callback = NULL;
208 transfer->out_callback = NULL;
209 transfer->arg = arg;
210 transfer->fun = fun;
211 transfer->data_buffer = data_buffer;
212 transfer->data_buffer_size = data_buffer_size;
213
214 return transfer;
215}
216
217static int enqueue_transfer_out(ddf_fun_t *fun,
218 usb_target_t target, usb_transfer_type_t transfer_type,
219 void *buffer, size_t size,
220 usbhc_iface_transfer_out_callback_t callback, void *arg)
221{
222 usb_log_debug2("Transfer OUT [%d.%d (%s); %zu].\n",
223 target.address, target.endpoint,
224 usb_str_transfer_type(transfer_type),
225 size);
226
227 transfer_info_t *transfer
228 = create_transfer_info(fun, USB_DIRECTION_OUT, arg);
229 transfer->out_callback = callback;
230
231 hc_add_transaction_to_device(false, target, transfer_type, buffer, size,
232 universal_callback, transfer);
233
234 return EOK;
235}
236
237static int enqueue_transfer_in(ddf_fun_t *fun,
238 usb_target_t target, usb_transfer_type_t transfer_type,
239 void *buffer, size_t size,
240 usbhc_iface_transfer_in_callback_t callback, void *arg)
241{
242 usb_log_debug2("Transfer IN [%d.%d (%s); %zu].\n",
243 target.address, target.endpoint,
244 usb_str_transfer_type(transfer_type),
245 size);
246
247 transfer_info_t *transfer
248 = create_transfer_info(fun, USB_DIRECTION_IN, arg);
249 transfer->in_callback = callback;
250
251 hc_add_transaction_from_device(target, transfer_type, buffer, size,
252 universal_callback, transfer);
253
254 return EOK;
255}
256
257
258static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
259 void *data, size_t size,
260 usbhc_iface_transfer_out_callback_t callback, void *arg)
261{
262 return enqueue_transfer_out(fun, target, USB_TRANSFER_INTERRUPT,
263 data, size,
264 callback, arg);
265}
266
267static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
268 void *data, size_t size,
269 usbhc_iface_transfer_in_callback_t callback, void *arg)
270{
271 return enqueue_transfer_in(fun, target, USB_TRANSFER_INTERRUPT,
272 data, size,
273 callback, arg);
274}
275
276static int control_write(ddf_fun_t *fun, usb_target_t target,
277 void *setup_packet, size_t setup_packet_size,
278 void *data, size_t data_size,
279 usbhc_iface_transfer_out_callback_t callback, void *arg)
280{
281 control_transfer_info_t *transfer
282 = create_control_transfer_info(fun, USB_DIRECTION_OUT, target,
283 data, data_size, arg);
284 transfer->out_callback = callback;
285
286 hc_add_transaction_to_device(true, target, USB_TRANSFER_CONTROL,
287 setup_packet, setup_packet_size,
288 control_callback_one, transfer);
289
290 return EOK;
291}
292
293static int control_read(ddf_fun_t *fun, usb_target_t target,
294 void *setup_packet, size_t setup_packet_size,
295 void *data, size_t data_size,
296 usbhc_iface_transfer_in_callback_t callback, void *arg)
297{
298 control_transfer_info_t *transfer
299 = create_control_transfer_info(fun, USB_DIRECTION_IN, target,
300 data, data_size, arg);
301 transfer->in_callback = callback;
302
303 hc_add_transaction_to_device(true, target, USB_TRANSFER_CONTROL,
304 setup_packet, setup_packet_size,
305 control_callback_one, transfer);
306
307 return EOK;
308}
309
310static usb_address_keeping_t addresses;
311
312static int tell_address(ddf_fun_t *fun, devman_handle_t handle,
313 usb_address_t *address)
314{
315 usb_log_debug("tell_address(fun \"%s\", handle %zu)\n",
316 fun->name, (size_t) fun->handle);
317 usb_address_t addr = usb_address_keeping_find(&addresses, handle);
318 if (addr < 0) {
319 return addr;
320 }
321
322 *address = addr;
323 return EOK;
324}
325
326static int reserve_default_address(ddf_fun_t *fun, usb_speed_t ignored)
327{
328 usb_address_keeping_reserve_default(&addresses);
329 return EOK;
330}
331
332static int release_default_address(ddf_fun_t *fun)
333{
334 usb_address_keeping_release_default(&addresses);
335 return EOK;
336}
337
338static int request_address(ddf_fun_t *fun, usb_speed_t ignored,
339 usb_address_t *address)
340{
341 usb_address_t addr = usb_address_keeping_request(&addresses);
342 if (addr < 0) {
343 return (int)addr;
344 }
345
346 *address = addr;
347 return EOK;
348}
349
350static int release_address(ddf_fun_t *fun, usb_address_t address)
351{
352 return usb_address_keeping_release(&addresses, address);
353}
354
355static int bind_address(ddf_fun_t *fun, usb_address_t address,
356 devman_handle_t handle)
357{
358 usb_address_keeping_devman_bind(&addresses, address, handle);
359 return EOK;
360}
361
362static int usb_iface_get_hc_handle_rh_impl(ddf_fun_t *root_hub_fun,
363 devman_handle_t *handle)
364{
365 ddf_fun_t *hc_fun = root_hub_fun->driver_data;
366 assert(hc_fun != NULL);
367
368 *handle = hc_fun->handle;
369
370 usb_log_debug("usb_iface_get_hc_handle_rh_impl returns %zu\n", *handle);
371
372 return EOK;
373}
374
375static int tell_address_rh(ddf_fun_t *root_hub_fun, devman_handle_t handle,
376 usb_address_t *address)
377{
378 ddf_fun_t *hc_fun = root_hub_fun->driver_data;
379 assert(hc_fun != NULL);
380
381 return tell_address(hc_fun, root_hub_fun->handle, address);
382}
383
384void address_init(void)
385{
386 usb_address_keeping_init(&addresses, 50);
387}
388
389usbhc_iface_t vhc_iface = {
390 .reserve_default_address = reserve_default_address,
391 .release_default_address = release_default_address,
392 .request_address = request_address,
393 .bind_address = bind_address,
394 .release_address = release_address,
395
396 .interrupt_out = interrupt_out,
397 .interrupt_in = interrupt_in,
398
399 .control_write = control_write,
400 .control_read = control_read
401};
402
403usb_iface_t vhc_usb_iface = {
404 .get_hc_handle = usb_iface_get_hc_handle_hc_impl,
405 .get_address = tell_address
406};
407
408usb_iface_t rh_usb_iface = {
409 .get_hc_handle = usb_iface_get_hc_handle_rh_impl,
410 .get_address = tell_address_rh
411};
412
413
414/**
415 * @}
416 */
Note: See TracBrowser for help on using the repository browser.