source: mainline/uspace/drv/uhci-hcd/iface.c@ 0aae4a6a

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 0aae4a6a was 0aae4a6a, checked in by Jan Vesely <jano.vesely@…>, 14 years ago

Add usb address and endpoint num to endpoint structure
  • Property mode set to 100644
File size: 17.7 KB
Line 
1/*
2 * Copyright (c) 2011 Vojtech Horky, Jan Vesely
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/** @addtogroup drvusbuhcihc
29 * @{
30 */
31/** @file
32 * @brief UHCI driver hc interface implementation
33 */
34#include <ddf/driver.h>
35#include <errno.h>
36
37#include <usb/debug.h>
38#include <usb/host/endpoint.h>
39
40#include "iface.h"
41#include "hc.h"
42
43/** Reserve default address interface function
44 *
45 * @param[in] fun DDF function that was called.
46 * @param[in] speed Speed to associate with the new default address.
47 * @return Error code.
48 */
49static int reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
50{
51 assert(fun);
52 hc_t *hc = fun_to_hc(fun);
53 assert(hc);
54 usb_log_debug("Default address request with speed %d.\n", speed);
55 usb_device_keeper_reserve_default_address(&hc->manager, speed);
56 return EOK;
57#if 0
58 endpoint_t *ep = malloc(sizeof(endpoint_t));
59 if (ep == NULL)
60 return ENOMEM;
61 const size_t max_packet_size = speed == USB_SPEED_LOW ? 8 : 64;
62 endpoint_init(ep, USB_TRANSFER_CONTROL, speed, max_packet_size);
63 int ret;
64try_retgister:
65 ret = usb_endpoint_manager_register_ep(&hc->ep_manager,
66 USB_ADDRESS_DEFAULT, 0, USB_DIRECTION_BOTH, ep, endpoint_destroy, 0);
67 if (ret == EEXISTS) {
68 async_usleep(1000);
69 goto try_retgister;
70 }
71 if (ret != EOK) {
72 endpoint_destroy(ep);
73 }
74 return ret;
75#endif
76}
77/*----------------------------------------------------------------------------*/
78/** Release default address interface function
79 *
80 * @param[in] fun DDF function that was called.
81 * @return Error code.
82 */
83static int release_default_address(ddf_fun_t *fun)
84{
85 assert(fun);
86 hc_t *hc = fun_to_hc(fun);
87 assert(hc);
88 usb_log_debug("Default address release.\n");
89// return usb_endpoint_manager_unregister_ep(&hc->ep_manager,
90// USB_ADDRESS_DEFAULT, 0, USB_DIRECTION_BOTH);
91 usb_device_keeper_release_default_address(&hc->manager);
92 return EOK;
93}
94/*----------------------------------------------------------------------------*/
95/** Request address interface function
96 *
97 * @param[in] fun DDF function that was called.
98 * @param[in] speed Speed to associate with the new default address.
99 * @param[out] address Place to write a new address.
100 * @return Error code.
101 */
102static int request_address(
103 ddf_fun_t *fun, usb_speed_t speed, usb_address_t *address)
104{
105 assert(fun);
106 hc_t *hc = fun_to_hc(fun);
107 assert(hc);
108 assert(address);
109
110 usb_log_debug("Address request with speed %d.\n", speed);
111 *address = device_keeper_get_free_address(&hc->manager, speed);
112 usb_log_debug("Address request with result: %d.\n", *address);
113 if (*address <= 0)
114 return *address;
115 return EOK;
116}
117/*----------------------------------------------------------------------------*/
118/** Bind address interface function
119 *
120 * @param[in] fun DDF function that was called.
121 * @param[in] address Address of the device
122 * @param[in] handle Devman handle of the device driver.
123 * @return Error code.
124 */
125static int bind_address(
126 ddf_fun_t *fun, usb_address_t address, devman_handle_t handle)
127{
128 assert(fun);
129 hc_t *hc = fun_to_hc(fun);
130 assert(hc);
131 usb_log_debug("Address bind %d-%d.\n", address, handle);
132 usb_device_keeper_bind(&hc->manager, address, handle);
133 return EOK;
134}
135/*----------------------------------------------------------------------------*/
136/** Release address interface function
137 *
138 * @param[in] fun DDF function that was called.
139 * @param[in] address USB address to be released.
140 * @return Error code.
141 */
142static int release_address(ddf_fun_t *fun, usb_address_t address)
143{
144 assert(fun);
145 hc_t *hc = fun_to_hc(fun);
146 assert(hc);
147 usb_log_debug("Address release %d.\n", address);
148 usb_device_keeper_release(&hc->manager, address);
149 return EOK;
150}
151/*----------------------------------------------------------------------------*/
152static int register_endpoint(
153 ddf_fun_t *fun, usb_address_t address, usb_endpoint_t endpoint,
154 usb_transfer_type_t transfer_type, usb_direction_t direction,
155 size_t max_packet_size, unsigned int interval)
156{
157 hc_t *hc = fun_to_hc(fun);
158 assert(hc);
159 const usb_speed_t speed =
160 usb_device_keeper_get_speed(&hc->manager, address);
161 const size_t size =
162 (transfer_type == USB_TRANSFER_INTERRUPT
163 || transfer_type == USB_TRANSFER_ISOCHRONOUS) ?
164 max_packet_size : 0;
165 int ret;
166
167 endpoint_t *ep = malloc(sizeof(endpoint_t));
168 if (ep == NULL)
169 return ENOMEM;
170 ret = endpoint_init(ep, address, endpoint, direction,
171 transfer_type, speed, max_packet_size);
172 if (ret != EOK) {
173 free(ep);
174 return ret;
175 }
176
177 usb_log_debug("Register endpoint %d:%d %s %s(%d) %zu(%zu) %u.\n",
178 address, endpoint, usb_str_transfer_type(transfer_type),
179 usb_str_speed(speed), direction, size, max_packet_size, interval);
180
181 ret = usb_endpoint_manager_register_ep(&hc->ep_manager,
182 address, endpoint, direction, ep, size);
183 if (ret != EOK) {
184 endpoint_destroy(ep);
185 } else {
186 usb_device_keeper_add_ep(&hc->manager, address, ep);
187 }
188 return ret;
189}
190/*----------------------------------------------------------------------------*/
191static int unregister_endpoint(
192 ddf_fun_t *fun, usb_address_t address,
193 usb_endpoint_t endpoint, usb_direction_t direction)
194{
195 hc_t *hc = fun_to_hc(fun);
196 assert(hc);
197 usb_log_debug("Unregister endpoint %d:%d %d.\n",
198 address, endpoint, direction);
199 return usb_endpoint_manager_unregister_ep(&hc->ep_manager, address,
200 endpoint, direction);
201}
202/*----------------------------------------------------------------------------*/
203/** Interrupt out transaction interface function
204 *
205 * @param[in] fun DDF function that was called.
206 * @param[in] target USB device to write to.
207 * @param[in] max_packet_size maximum size of data packet the device accepts
208 * @param[in] data Source of data.
209 * @param[in] size Size of data source.
210 * @param[in] callback Function to call on transaction completion
211 * @param[in] arg Additional for callback function.
212 * @return Error code.
213 */
214static int interrupt_out(
215 ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
216 size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
217{
218 assert(fun);
219 hc_t *hc = fun_to_hc(fun);
220 assert(hc);
221
222 usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
223 target.address, target.endpoint, size, max_packet_size);
224
225 size_t res_bw;
226 endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
227 target.address, target.endpoint, USB_DIRECTION_OUT, &res_bw);
228 if (ep == NULL) {
229 usb_log_error("Endpoint(%d:%d) not registered for INT OUT.\n",
230 target.address, target.endpoint);
231 return ENOENT;
232 }
233 const size_t bw = bandwidth_count_usb11(ep->speed, ep->transfer_type,
234 size, ep->max_packet_size);
235 if (res_bw < bw)
236 {
237 usb_log_error("Endpoint(%d:%d) INT IN needs %zu bw "
238 "but only %zu is reserved.\n",
239 target.address, target.endpoint, bw, res_bw);
240 return ENOENT;
241 }
242 assert(ep->speed ==
243 usb_device_keeper_get_speed(&hc->manager, target.address));
244 assert(ep->max_packet_size == max_packet_size);
245 assert(ep->transfer_type == USB_TRANSFER_INTERRUPT);
246
247 usb_transfer_batch_t *batch =
248 batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
249 ep->speed, data, size, NULL, 0, NULL, callback, arg, ep);
250 if (!batch)
251 return ENOMEM;
252 batch_interrupt_out(batch);
253 const int ret = hc_schedule(hc, batch);
254 if (ret != EOK) {
255 batch_dispose(batch);
256 }
257 return ret;
258}
259/*----------------------------------------------------------------------------*/
260/** Interrupt in transaction interface function
261 *
262 * @param[in] fun DDF function that was called.
263 * @param[in] target USB device to write to.
264 * @param[in] max_packet_size maximum size of data packet the device accepts
265 * @param[out] data Data destination.
266 * @param[in] size Size of data source.
267 * @param[in] callback Function to call on transaction completion
268 * @param[in] arg Additional for callback function.
269 * @return Error code.
270 */
271static int interrupt_in(
272 ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
273 size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
274{
275 assert(fun);
276 hc_t *hc = fun_to_hc(fun);
277 assert(hc);
278
279 usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
280 target.address, target.endpoint, size, max_packet_size);
281
282 size_t res_bw;
283 endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
284 target.address, target.endpoint, USB_DIRECTION_IN, &res_bw);
285 if (ep == NULL) {
286 usb_log_error("Endpoint(%d:%d) not registered for INT IN.\n",
287 target.address, target.endpoint);
288 return ENOENT;
289 }
290 const size_t bw = bandwidth_count_usb11(ep->speed, ep->transfer_type,
291 size, ep->max_packet_size);
292 if (res_bw < bw)
293 {
294 usb_log_error("Endpoint(%d:%d) INT IN needs %zu bw "
295 "but only %zu bw is reserved.\n",
296 target.address, target.endpoint, bw, res_bw);
297 return ENOENT;
298 }
299
300 assert(ep->speed ==
301 usb_device_keeper_get_speed(&hc->manager, target.address));
302 assert(ep->max_packet_size == max_packet_size);
303 assert(ep->transfer_type == USB_TRANSFER_INTERRUPT);
304
305 usb_transfer_batch_t *batch =
306 batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
307 ep->speed, data, size, NULL, 0, callback, NULL, arg, ep);
308 if (!batch)
309 return ENOMEM;
310 batch_interrupt_in(batch);
311 const int ret = hc_schedule(hc, batch);
312 if (ret != EOK) {
313 batch_dispose(batch);
314 }
315 return ret;
316}
317/*----------------------------------------------------------------------------*/
318/** Bulk out transaction interface function
319 *
320 * @param[in] fun DDF function that was called.
321 * @param[in] target USB device to write to.
322 * @param[in] max_packet_size maximum size of data packet the device accepts
323 * @param[in] data Source of data.
324 * @param[in] size Size of data source.
325 * @param[in] callback Function to call on transaction completion
326 * @param[in] arg Additional for callback function.
327 * @return Error code.
328 */
329static int bulk_out(
330 ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
331 size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
332{
333 assert(fun);
334 hc_t *hc = fun_to_hc(fun);
335 assert(hc);
336
337 usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
338 target.address, target.endpoint, size, max_packet_size);
339
340 endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
341 target.address, target.endpoint, USB_DIRECTION_OUT, NULL);
342 if (ep == NULL) {
343 usb_log_error("Endpoint(%d:%d) not registered for BULK OUT.\n",
344 target.address, target.endpoint);
345 return ENOENT;
346 }
347 assert(ep->speed ==
348 usb_device_keeper_get_speed(&hc->manager, target.address));
349 assert(ep->max_packet_size == max_packet_size);
350 assert(ep->transfer_type == USB_TRANSFER_BULK);
351
352 usb_transfer_batch_t *batch =
353 batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
354 ep->speed, data, size, NULL, 0, NULL, callback, arg, ep);
355 if (!batch)
356 return ENOMEM;
357 batch_bulk_out(batch);
358 const int ret = hc_schedule(hc, batch);
359 if (ret != EOK) {
360 batch_dispose(batch);
361 }
362 return ret;
363}
364/*----------------------------------------------------------------------------*/
365/** Bulk in transaction interface function
366 *
367 * @param[in] fun DDF function that was called.
368 * @param[in] target USB device to write to.
369 * @param[in] max_packet_size maximum size of data packet the device accepts
370 * @param[out] data Data destination.
371 * @param[in] size Size of data source.
372 * @param[in] callback Function to call on transaction completion
373 * @param[in] arg Additional for callback function.
374 * @return Error code.
375 */
376static int bulk_in(
377 ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
378 size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
379{
380 assert(fun);
381 hc_t *hc = fun_to_hc(fun);
382 assert(hc);
383 usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
384 target.address, target.endpoint, size, max_packet_size);
385
386 endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
387 target.address, target.endpoint, USB_DIRECTION_IN, NULL);
388 if (ep == NULL) {
389 usb_log_error("Endpoint(%d:%d) not registered for BULK IN.\n",
390 target.address, target.endpoint);
391 return ENOENT;
392 }
393 assert(ep->speed ==
394 usb_device_keeper_get_speed(&hc->manager, target.address));
395 assert(ep->max_packet_size == max_packet_size);
396 assert(ep->transfer_type == USB_TRANSFER_BULK);
397
398 usb_transfer_batch_t *batch =
399 batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
400 ep->speed, data, size, NULL, 0, callback, NULL, arg, ep);
401 if (!batch)
402 return ENOMEM;
403 batch_bulk_in(batch);
404 const int ret = hc_schedule(hc, batch);
405 if (ret != EOK) {
406 batch_dispose(batch);
407 }
408 return ret;
409}
410/*----------------------------------------------------------------------------*/
411/** Control write transaction interface function
412 *
413 * @param[in] fun DDF function that was called.
414 * @param[in] target USB device to write to.
415 * @param[in] max_packet_size maximum size of data packet the device accepts.
416 * @param[in] setup_data Data to send with SETUP transfer.
417 * @param[in] setup_size Size of data to send with SETUP transfer (always 8B).
418 * @param[in] data Source of data.
419 * @param[in] size Size of data source.
420 * @param[in] callback Function to call on transaction completion.
421 * @param[in] arg Additional for callback function.
422 * @return Error code.
423 */
424static int control_write(
425 ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
426 void *setup_data, size_t setup_size, void *data, size_t size,
427 usbhc_iface_transfer_out_callback_t callback, void *arg)
428{
429 assert(fun);
430 hc_t *hc = fun_to_hc(fun);
431 assert(hc);
432 usb_speed_t speed =
433 usb_device_keeper_get_speed(&hc->manager, target.address);
434 usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
435 speed, target.address, target.endpoint, size, max_packet_size);
436 endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
437 target.address, target.endpoint, USB_DIRECTION_BOTH, NULL);
438 if (ep == NULL) {
439 usb_log_warning("Endpoint(%d:%d) not registered for CONTROL.\n",
440 target.address, target.endpoint);
441 }
442
443 if (setup_size != 8)
444 return EINVAL;
445
446 usb_transfer_batch_t *batch =
447 batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
448 data, size, setup_data, setup_size, NULL, callback, arg, ep);
449 if (!batch)
450 return ENOMEM;
451 usb_device_keeper_reset_if_need(&hc->manager, target, setup_data);
452 batch_control_write(batch);
453 const int ret = hc_schedule(hc, batch);
454 if (ret != EOK) {
455 batch_dispose(batch);
456 }
457 return ret;
458}
459/*----------------------------------------------------------------------------*/
460/** Control read transaction interface function
461 *
462 * @param[in] fun DDF function that was called.
463 * @param[in] target USB device to write to.
464 * @param[in] max_packet_size maximum size of data packet the device accepts.
465 * @param[in] setup_data Data to send with SETUP packet.
466 * @param[in] setup_size Size of data to send with SETUP packet (should be 8B).
467 * @param[out] data Source of data.
468 * @param[in] size Size of data source.
469 * @param[in] callback Function to call on transaction completion.
470 * @param[in] arg Additional for callback function.
471 * @return Error code.
472 */
473static int control_read(
474 ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
475 void *setup_data, size_t setup_size, void *data, size_t size,
476 usbhc_iface_transfer_in_callback_t callback, void *arg)
477{
478 assert(fun);
479 hc_t *hc = fun_to_hc(fun);
480 assert(hc);
481 usb_speed_t speed =
482 usb_device_keeper_get_speed(&hc->manager, target.address);
483
484 usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
485 speed, target.address, target.endpoint, size, max_packet_size);
486 endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
487 target.address, target.endpoint, USB_DIRECTION_BOTH, NULL);
488 if (ep == NULL) {
489 usb_log_warning("Endpoint(%d:%d) not registered for CONTROL.\n",
490 target.address, target.endpoint);
491 }
492 usb_transfer_batch_t *batch =
493 batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
494 data, size, setup_data, setup_size, callback, NULL, arg, ep);
495 if (!batch)
496 return ENOMEM;
497 batch_control_read(batch);
498 const int ret = hc_schedule(hc, batch);
499 if (ret != EOK) {
500 batch_dispose(batch);
501 }
502 return ret;
503}
504/*----------------------------------------------------------------------------*/
505usbhc_iface_t hc_iface = {
506 .reserve_default_address = reserve_default_address,
507 .release_default_address = release_default_address,
508 .request_address = request_address,
509 .bind_address = bind_address,
510 .release_address = release_address,
511
512 .register_endpoint = register_endpoint,
513 .unregister_endpoint = unregister_endpoint,
514
515 .interrupt_out = interrupt_out,
516 .interrupt_in = interrupt_in,
517
518 .bulk_out = bulk_out,
519 .bulk_in = bulk_in,
520
521 .control_write = control_write,
522 .control_read = control_read,
523};
524/**
525 * @}
526 */
Note: See TracBrowser for help on using the repository browser.