source: mainline/uspace/drv/vhc/connhost.c@ c20da9f

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

USB interfaces reorganization

The most important change is that getting USB address of a device
is an operation of generic USB interface, not USB-HC interface.
That is needed for proper functionality of a MID driver.

Also added sample implementation of USB interface operations as is
needed by most drivers (sample does not mean unfunctional or partially
implemented here).
They are stored in libusb/ddfiface.h

Updated UHCI, UHCI-RH, hub, VHC drivers to use these sample
implementations.

Updated libusb device recognition routines to route get_address requests
through USB interface.
  • Property mode set to 100644
File size: 10.3 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 device_t *dev;
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 device_t *dev;
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->dev,
78 outcome, size,
79 transfer->arg);
80 break;
81 case USB_DIRECTION_OUT:
82 transfer->out_callback(transfer->dev,
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(device_t *dev,
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->dev = dev;
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->dev,
115 outcome, size,
116 transfer->arg);
117 break;
118 case USB_DIRECTION_OUT:
119 transfer->out_callback(transfer->dev,
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->dev,
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(device_t *dev,
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->dev = dev;
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(device_t *dev,
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(dev, 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(device_t *dev,
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(dev, 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(device_t *dev, usb_target_t target,
259 size_t max_packet_size,
260 void *data, size_t size,
261 usbhc_iface_transfer_out_callback_t callback, void *arg)
262{
263 return enqueue_transfer_out(dev, target, USB_TRANSFER_INTERRUPT,
264 data, size,
265 callback, arg);
266}
267
268static int interrupt_in(device_t *dev, usb_target_t target,
269 size_t max_packet_size,
270 void *data, size_t size,
271 usbhc_iface_transfer_in_callback_t callback, void *arg)
272{
273 return enqueue_transfer_in(dev, target, USB_TRANSFER_INTERRUPT,
274 data, size,
275 callback, arg);
276}
277
278static int control_write(device_t *dev, usb_target_t target,
279 size_t max_packet_size,
280 void *setup_packet, size_t setup_packet_size,
281 void *data, size_t data_size,
282 usbhc_iface_transfer_out_callback_t callback, void *arg)
283{
284 control_transfer_info_t *transfer
285 = create_control_transfer_info(dev, USB_DIRECTION_OUT, target,
286 data, data_size, arg);
287 transfer->out_callback = callback;
288
289 hc_add_transaction_to_device(true, target, USB_TRANSFER_CONTROL,
290 setup_packet, setup_packet_size,
291 control_callback_one, transfer);
292
293 return EOK;
294}
295
296static int control_read(device_t *dev, usb_target_t target,
297 size_t max_packet_size,
298 void *setup_packet, size_t setup_packet_size,
299 void *data, size_t data_size,
300 usbhc_iface_transfer_in_callback_t callback, void *arg)
301{
302 control_transfer_info_t *transfer
303 = create_control_transfer_info(dev, USB_DIRECTION_IN, target,
304 data, data_size, arg);
305 transfer->in_callback = callback;
306
307 hc_add_transaction_to_device(true, target, USB_TRANSFER_CONTROL,
308 setup_packet, setup_packet_size,
309 control_callback_one, transfer);
310
311 return EOK;
312}
313
314static usb_address_keeping_t addresses;
315
316static int tell_address(device_t *dev, devman_handle_t handle,
317 usb_address_t *address)
318{
319 usb_address_t addr = usb_address_keeping_find(&addresses, handle);
320 if (addr < 0) {
321 return addr;
322 }
323
324 *address = addr;
325 return EOK;
326}
327
328static int reserve_default_address(device_t *dev, usb_speed_t ignored)
329{
330 usb_address_keeping_reserve_default(&addresses);
331 return EOK;
332}
333
334static int release_default_address(device_t *dev)
335{
336 usb_address_keeping_release_default(&addresses);
337 return EOK;
338}
339
340static int request_address(device_t *dev, usb_speed_t ignored,
341 usb_address_t *address)
342{
343 usb_address_t addr = usb_address_keeping_request(&addresses);
344 if (addr < 0) {
345 return (int)addr;
346 }
347
348 *address = addr;
349 return EOK;
350}
351
352static int release_address(device_t *dev, usb_address_t address)
353{
354 return usb_address_keeping_release(&addresses, address);
355}
356
357static int bind_address(device_t *dev, usb_address_t address,
358 devman_handle_t handle)
359{
360 usb_address_keeping_devman_bind(&addresses, address, handle);
361 return EOK;
362}
363
364void address_init(void)
365{
366 usb_address_keeping_init(&addresses, 50);
367}
368
369usbhc_iface_t vhc_iface = {
370 .reserve_default_address = reserve_default_address,
371 .release_default_address = release_default_address,
372 .request_address = request_address,
373 .bind_address = bind_address,
374 .release_address = release_address,
375
376 .interrupt_out = interrupt_out,
377 .interrupt_in = interrupt_in,
378
379 .control_write = control_write,
380 .control_read = control_read
381};
382
383usb_iface_t vhc_usb_iface = {
384 .get_hc_handle = usb_iface_get_hc_handle_hc_impl,
385 .get_address = tell_address
386};
387
388
389/**
390 * @}
391 */
Note: See TracBrowser for help on using the repository browser.