source: mainline/uspace/drv/vhc/connhost.c@ 423e8c81

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

Removal of remote parts of old API

The control transfer callbacks for each part of the transfer
(i.e. for setup, data and status) were completely removed.
  • Property mode set to 100644
File size: 10.2 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
40#include "vhcd.h"
41#include "conn.h"
42#include "hc.h"
43
44
45typedef struct {
46 usb_direction_t direction;
47 usbhc_iface_transfer_out_callback_t out_callback;
48 usbhc_iface_transfer_in_callback_t in_callback;
49 device_t *dev;
50 size_t reported_size;
51 void *arg;
52} transfer_info_t;
53
54typedef struct {
55 usb_direction_t direction;
56 usb_target_t target;
57 usbhc_iface_transfer_out_callback_t out_callback;
58 usbhc_iface_transfer_in_callback_t in_callback;
59 device_t *dev;
60 void *arg;
61 void *data_buffer;
62 size_t data_buffer_size;
63} control_transfer_info_t;
64
65static void universal_callback(void *buffer, size_t size,
66 int outcome, void *arg)
67{
68 transfer_info_t *transfer = (transfer_info_t *) arg;
69
70 if (transfer->reported_size != (size_t) -1) {
71 size = transfer->reported_size;
72 }
73
74 switch (transfer->direction) {
75 case USB_DIRECTION_IN:
76 transfer->in_callback(transfer->dev,
77 outcome, size,
78 transfer->arg);
79 break;
80 case USB_DIRECTION_OUT:
81 transfer->out_callback(transfer->dev,
82 outcome,
83 transfer->arg);
84 break;
85 default:
86 assert(false && "unreachable");
87 break;
88 }
89
90 free(transfer);
91}
92
93static transfer_info_t *create_transfer_info(device_t *dev,
94 usb_direction_t direction, void *arg)
95{
96 transfer_info_t *transfer = malloc(sizeof(transfer_info_t));
97
98 transfer->direction = direction;
99 transfer->in_callback = NULL;
100 transfer->out_callback = NULL;
101 transfer->arg = arg;
102 transfer->dev = dev;
103 transfer->reported_size = (size_t) -1;
104
105 return transfer;
106}
107
108static void control_abort_prematurely(control_transfer_info_t *transfer,
109 size_t size, int outcome)
110{
111 switch (transfer->direction) {
112 case USB_DIRECTION_IN:
113 transfer->in_callback(transfer->dev,
114 outcome, size,
115 transfer->arg);
116 break;
117 case USB_DIRECTION_OUT:
118 transfer->out_callback(transfer->dev,
119 outcome,
120 transfer->arg);
121 break;
122 default:
123 assert(false && "unreachable");
124 break;
125 }
126}
127
128static void control_callback_two(void *buffer, size_t size,
129 int outcome, void *arg)
130{
131 control_transfer_info_t *ctrl_transfer = (control_transfer_info_t *) arg;
132
133 if (outcome != EOK) {
134 control_abort_prematurely(ctrl_transfer, outcome, size);
135 free(ctrl_transfer);
136 return;
137 }
138
139 transfer_info_t *transfer = create_transfer_info(ctrl_transfer->dev,
140 ctrl_transfer->direction, ctrl_transfer->arg);
141 transfer->out_callback = ctrl_transfer->out_callback;
142 transfer->in_callback = ctrl_transfer->in_callback;
143 transfer->reported_size = size;
144
145 switch (ctrl_transfer->direction) {
146 case USB_DIRECTION_IN:
147 hc_add_transaction_to_device(false, ctrl_transfer->target,
148 USB_TRANSFER_CONTROL,
149 NULL, 0,
150 universal_callback, transfer);
151 break;
152 case USB_DIRECTION_OUT:
153 hc_add_transaction_from_device(ctrl_transfer->target,
154 USB_TRANSFER_CONTROL,
155 NULL, 0,
156 universal_callback, transfer);
157 break;
158 default:
159 assert(false && "unreachable");
160 break;
161 }
162
163 free(ctrl_transfer);
164}
165
166static void control_callback_one(void *buffer, size_t size,
167 int outcome, void *arg)
168{
169 control_transfer_info_t *transfer = (control_transfer_info_t *) arg;
170
171 if (outcome != EOK) {
172 control_abort_prematurely(transfer, outcome, size);
173 free(transfer);
174 return;
175 }
176
177 switch (transfer->direction) {
178 case USB_DIRECTION_IN:
179 hc_add_transaction_from_device(transfer->target,
180 USB_TRANSFER_CONTROL,
181 transfer->data_buffer, transfer->data_buffer_size,
182 control_callback_two, transfer);
183 break;
184 case USB_DIRECTION_OUT:
185 hc_add_transaction_to_device(false, transfer->target,
186 USB_TRANSFER_CONTROL,
187 transfer->data_buffer, transfer->data_buffer_size,
188 control_callback_two, transfer);
189 break;
190 default:
191 assert(false && "unreachable");
192 break;
193 }
194}
195
196static control_transfer_info_t *create_control_transfer_info(device_t *dev,
197 usb_direction_t direction, usb_target_t target,
198 void *data_buffer, size_t data_buffer_size,
199 void *arg)
200{
201 control_transfer_info_t *transfer
202 = malloc(sizeof(control_transfer_info_t));
203
204 transfer->direction = direction;
205 transfer->target = target;
206 transfer->in_callback = NULL;
207 transfer->out_callback = NULL;
208 transfer->arg = arg;
209 transfer->dev = dev;
210 transfer->data_buffer = data_buffer;
211 transfer->data_buffer_size = data_buffer_size;
212
213 return transfer;
214}
215
216static int enqueue_transfer_out(device_t *dev,
217 usb_target_t target, usb_transfer_type_t transfer_type,
218 void *buffer, size_t size,
219 usbhc_iface_transfer_out_callback_t callback, void *arg)
220{
221 usb_log_debug2("Transfer OUT [%d.%d (%s); %zu].\n",
222 target.address, target.endpoint,
223 usb_str_transfer_type(transfer_type),
224 size);
225
226 transfer_info_t *transfer
227 = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
228 transfer->out_callback = callback;
229
230 hc_add_transaction_to_device(false, target, transfer_type, buffer, size,
231 universal_callback, transfer);
232
233 return EOK;
234}
235
236static int enqueue_transfer_in(device_t *dev,
237 usb_target_t target, usb_transfer_type_t transfer_type,
238 void *buffer, size_t size,
239 usbhc_iface_transfer_in_callback_t callback, void *arg)
240{
241 usb_log_debug2("Transfer IN [%d.%d (%s); %zu].\n",
242 target.address, target.endpoint,
243 usb_str_transfer_type(transfer_type),
244 size);
245
246 transfer_info_t *transfer
247 = create_transfer_info(dev, USB_DIRECTION_IN, arg);
248 transfer->in_callback = callback;
249
250 hc_add_transaction_from_device(target, transfer_type, buffer, size,
251 universal_callback, transfer);
252
253 return EOK;
254}
255
256
257static int interrupt_out(device_t *dev, usb_target_t target,
258 size_t max_packet_size,
259 void *data, size_t size,
260 usbhc_iface_transfer_out_callback_t callback, void *arg)
261{
262 return enqueue_transfer_out(dev, target, USB_TRANSFER_INTERRUPT,
263 data, size,
264 callback, arg);
265}
266
267static int interrupt_in(device_t *dev, usb_target_t target,
268 size_t max_packet_size,
269 void *data, size_t size,
270 usbhc_iface_transfer_in_callback_t callback, void *arg)
271{
272 return enqueue_transfer_in(dev, target, USB_TRANSFER_INTERRUPT,
273 data, size,
274 callback, arg);
275}
276
277static int control_write(device_t *dev, usb_target_t target,
278 size_t max_packet_size,
279 void *setup_packet, size_t setup_packet_size,
280 void *data, size_t data_size,
281 usbhc_iface_transfer_out_callback_t callback, void *arg)
282{
283 control_transfer_info_t *transfer
284 = create_control_transfer_info(dev, USB_DIRECTION_OUT, target,
285 data, data_size, arg);
286 transfer->out_callback = callback;
287
288 hc_add_transaction_to_device(true, target, USB_TRANSFER_CONTROL,
289 setup_packet, setup_packet_size,
290 control_callback_one, transfer);
291
292 return EOK;
293}
294
295static int control_read(device_t *dev, usb_target_t target,
296 size_t max_packet_size,
297 void *setup_packet, size_t setup_packet_size,
298 void *data, size_t data_size,
299 usbhc_iface_transfer_in_callback_t callback, void *arg)
300{
301 control_transfer_info_t *transfer
302 = create_control_transfer_info(dev, USB_DIRECTION_IN, target,
303 data, data_size, arg);
304 transfer->in_callback = callback;
305
306 hc_add_transaction_to_device(true, target, USB_TRANSFER_CONTROL,
307 setup_packet, setup_packet_size,
308 control_callback_one, transfer);
309
310 return EOK;
311}
312
313static usb_address_keeping_t addresses;
314
315
316static int reserve_default_address(device_t *dev, usb_speed_t ignored)
317{
318 usb_address_keeping_reserve_default(&addresses);
319 return EOK;
320}
321
322static int release_default_address(device_t *dev)
323{
324 usb_address_keeping_release_default(&addresses);
325 return EOK;
326}
327
328static int request_address(device_t *dev, usb_speed_t ignored,
329 usb_address_t *address)
330{
331 usb_address_t addr = usb_address_keeping_request(&addresses);
332 if (addr < 0) {
333 return (int)addr;
334 }
335
336 *address = addr;
337 return EOK;
338}
339
340static int release_address(device_t *dev, usb_address_t address)
341{
342 return usb_address_keeping_release(&addresses, address);
343}
344
345static int bind_address(device_t *dev, usb_address_t address,
346 devman_handle_t handle)
347{
348 usb_address_keeping_devman_bind(&addresses, address, handle);
349 return EOK;
350}
351
352static int tell_address(device_t *dev, devman_handle_t handle,
353 usb_address_t *address)
354{
355 usb_address_t addr = usb_address_keeping_find(&addresses, handle);
356 if (addr < 0) {
357 return addr;
358 }
359
360 *address = addr;
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 .tell_address = tell_address,
371
372 .reserve_default_address = reserve_default_address,
373 .release_default_address = release_default_address,
374 .request_address = request_address,
375 .bind_address = bind_address,
376 .release_address = release_address,
377
378 .interrupt_out = interrupt_out,
379 .interrupt_in = interrupt_in,
380
381 .control_write = control_write,
382 .control_read = control_read
383};
384
385/**
386 * @}
387 */
Note: See TracBrowser for help on using the repository browser.