source: mainline/uspace/drv/uhci-hcd/batch.c@ 9013ad3

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

enable IOC on control transfers
  • Property mode set to 100644
File size: 12.1 KB
Line 
1/*
2 * Copyright (c) 2011 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 usb
29 * @{
30 */
31/** @file
32 * @brief UHCI driver
33 */
34#include <errno.h>
35
36#include <usb/debug.h>
37
38#include "batch.h"
39#include "transfer_list.h"
40#include "uhci.h"
41#include "utils/malloc32.h"
42
43#define DEFAULT_ERROR_COUNT 3
44
45static int batch_schedule(batch_t *instance);
46
47static void batch_call_in(batch_t *instance);
48static void batch_call_out(batch_t *instance);
49static void batch_call_in_and_dispose(batch_t *instance);
50static void batch_call_out_and_dispose(batch_t *instance);
51
52
53batch_t * batch_get(device_t *dev, usb_target_t target,
54 usb_transfer_type_t transfer_type, size_t max_packet_size,
55 dev_speed_t speed, char *buffer, size_t size,
56 char* setup_buffer, size_t setup_size,
57 usbhc_iface_transfer_in_callback_t func_in,
58 usbhc_iface_transfer_out_callback_t func_out, void *arg)
59{
60 assert(func_in == NULL || func_out == NULL);
61 assert(func_in != NULL || func_out != NULL);
62
63 batch_t *instance = malloc(sizeof(batch_t));
64 if (instance == NULL) {
65 usb_log_error("Failed to allocate batch instance.\n");
66 return NULL;
67 }
68
69 instance->qh = queue_head_get();
70 if (instance->qh == NULL) {
71 usb_log_error("Failed to allocate queue head.\n");
72 free(instance);
73 return NULL;
74 }
75
76 instance->packets = (size + max_packet_size - 1) / max_packet_size;
77 if (transfer_type == USB_TRANSFER_CONTROL) {
78 instance->packets += 2;
79 }
80
81 instance->tds = malloc32(sizeof(transfer_descriptor_t) * instance->packets);
82 if (instance->tds == NULL) {
83 usb_log_error("Failed to allocate transfer descriptors.\n");
84 queue_head_dispose(instance->qh);
85 free(instance);
86 return NULL;
87 }
88 bzero(instance->tds, sizeof(transfer_descriptor_t) * instance->packets);
89
90 const size_t transport_size = max_packet_size * instance->packets;
91
92 instance->transport_buffer =
93 (size > 0) ? malloc32(transport_size) : NULL;
94 if ((size > 0) && (instance->transport_buffer == NULL)) {
95 usb_log_error("Failed to allocate device accessible buffer.\n");
96 queue_head_dispose(instance->qh);
97 free32(instance->tds);
98 free(instance);
99 return NULL;
100 }
101
102 instance->setup_buffer = setup_buffer ? malloc32(setup_size) : NULL;
103 if ((setup_size > 0) && (instance->setup_buffer == NULL)) {
104 usb_log_error("Failed to allocate device accessible setup buffer.\n");
105 queue_head_dispose(instance->qh);
106 free32(instance->tds);
107 free32(instance->transport_buffer);
108 free(instance);
109 return NULL;
110 }
111 if (instance->setup_buffer) {
112 memcpy(instance->setup_buffer, setup_buffer, setup_size);
113 }
114
115 instance->max_packet_size = max_packet_size;
116
117 link_initialize(&instance->link);
118
119 instance->target = target;
120 instance->transfer_type = transfer_type;
121
122 if (func_out)
123 instance->callback_out = func_out;
124 if (func_in)
125 instance->callback_in = func_in;
126
127 instance->buffer = buffer;
128 instance->buffer_size = size;
129 instance->setup_size = setup_size;
130 instance->dev = dev;
131 instance->arg = arg;
132 instance->speed = speed;
133
134 queue_head_element_td(instance->qh, addr_to_phys(instance->tds));
135 return instance;
136}
137/*----------------------------------------------------------------------------*/
138bool batch_is_complete(batch_t *instance)
139{
140 assert(instance);
141 usb_log_debug("Checking(%p) %d packet for completion.\n",
142 instance, instance->packets);
143 instance->transfered_size = 0;
144 size_t i = 0;
145 for (;i < instance->packets; ++i) {
146 if (transfer_descriptor_is_active(&instance->tds[i])) {
147 return false;
148 }
149 instance->error = transfer_descriptor_status(&instance->tds[i]);
150 if (instance->error != EOK) {
151 if (i > 0)
152 instance->transfered_size -= instance->setup_size;
153 return true;
154 }
155 instance->transfered_size +=
156 transfer_descriptor_actual_size(&instance->tds[i]);
157 }
158 /* This is just an ugly trick to support the old API */
159 instance->transfered_size -= instance->setup_size;
160 return true;
161}
162/*----------------------------------------------------------------------------*/
163void batch_control_write(batch_t *instance)
164{
165 assert(instance);
166
167 /* we are data out, we are supposed to provide data */
168 memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
169
170 int toggle = 0;
171 /* setup stage */
172 transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
173 instance->setup_size, toggle, false, instance->target,
174 USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
175
176 /* data stage */
177 size_t i = 1;
178 for (;i < instance->packets - 1; ++i) {
179 char *data =
180 instance->transport_buffer + ((i - 1) * instance->max_packet_size);
181 toggle = 1 - toggle;
182
183 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
184 instance->max_packet_size, toggle++, false, instance->target,
185 USB_PID_OUT, data, &instance->tds[i + 1]);
186 }
187
188 /* status stage */
189 i = instance->packets - 1;
190 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
191 0, 1, false, instance->target, USB_PID_IN, NULL, NULL);
192
193 instance->tds[i].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
194
195 instance->next_step = batch_call_out_and_dispose;
196 batch_schedule(instance);
197}
198/*----------------------------------------------------------------------------*/
199void batch_control_read(batch_t *instance)
200{
201 assert(instance);
202
203 int toggle = 0;
204 /* setup stage */
205 transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
206 instance->setup_size, toggle, false, instance->target,
207 USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
208
209 /* data stage */
210 size_t i = 1;
211 for (;i < instance->packets - 1; ++i) {
212 char *data =
213 instance->transport_buffer + ((i - 1) * instance->max_packet_size);
214 toggle = 1 - toggle;
215
216 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
217 instance->max_packet_size, toggle, false, instance->target,
218 USB_PID_IN, data, &instance->tds[i + 1]);
219 }
220
221 /* status stage */
222 i = instance->packets - 1;
223 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
224 0, 1, false, instance->target, USB_PID_OUT, NULL, NULL);
225
226 instance->tds[i].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
227
228 instance->next_step = batch_call_in_and_dispose;
229 batch_schedule(instance);
230}
231/*----------------------------------------------------------------------------*/
232void batch_interrupt_in(batch_t *instance)
233{
234 assert(instance);
235
236 int toggle = 1;
237 size_t i = 0;
238 for (;i < instance->packets; ++i) {
239 char *data =
240 instance->transport_buffer + (i * instance->max_packet_size);
241 transfer_descriptor_t *next = (i + 1) < instance->packets ?
242 &instance->tds[i + 1] : NULL;
243 toggle = 1 - toggle;
244
245 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
246 instance->max_packet_size, toggle, false, instance->target,
247 USB_PID_IN, data, next);
248 }
249
250 instance->next_step = batch_call_in_and_dispose;
251 batch_schedule(instance);
252}
253/*----------------------------------------------------------------------------*/
254void batch_interrupt_out(batch_t *instance)
255{
256 assert(instance);
257
258 memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
259
260 int toggle = 1;
261 size_t i = 0;
262 for (;i < instance->packets; ++i) {
263 char *data =
264 instance->transport_buffer + (i * instance->max_packet_size);
265 transfer_descriptor_t *next = (i + 1) < instance->packets ?
266 &instance->tds[i + 1] : NULL;
267 toggle = 1 - toggle;
268
269 transfer_descriptor_init(&instance->tds[i], DEFAULT_ERROR_COUNT,
270 instance->max_packet_size, toggle++, false, instance->target,
271 USB_PID_OUT, data, next);
272 }
273
274 instance->next_step = batch_call_out_and_dispose;
275 batch_schedule(instance);
276}
277/*----------------------------------------------------------------------------*/
278void batch_call_in(batch_t *instance)
279{
280 assert(instance);
281 assert(instance->callback_in);
282
283 memcpy(instance->buffer, instance->transport_buffer, instance->buffer_size);
284
285 int err = instance->error;
286 usb_log_info("Callback IN(%d): %d, %zu.\n", instance->transfer_type,
287 err, instance->transfered_size);
288
289 instance->callback_in(instance->dev,
290 err, instance->transfered_size,
291 instance->arg);
292}
293/*----------------------------------------------------------------------------*/
294void batch_call_out(batch_t *instance)
295{
296 assert(instance);
297 assert(instance->callback_out);
298
299 int err = instance->error;
300 usb_log_info("Callback OUT(%d): %d.\n", instance->transfer_type, err);
301 instance->callback_out(instance->dev,
302 err, instance->arg);
303}
304/*----------------------------------------------------------------------------*/
305void batch_call_in_and_dispose(batch_t *instance)
306{
307 assert(instance);
308 batch_call_in(instance);
309 usb_log_debug("Disposing batch: %p.\n", instance);
310 free32(instance->tds);
311 free32(instance->qh);
312 free32(instance->setup_buffer);
313 free32(instance->transport_buffer);
314 free(instance);
315}
316/*----------------------------------------------------------------------------*/
317void batch_call_out_and_dispose(batch_t *instance)
318{
319 assert(instance);
320 batch_call_out(instance);
321 usb_log_debug("Disposing batch: %p.\n", instance);
322 free32(instance->tds);
323 free32(instance->qh);
324 free32(instance->setup_buffer);
325 free32(instance->transport_buffer);
326 free(instance);
327}
328/*----------------------------------------------------------------------------*/
329int batch_schedule(batch_t *instance)
330{
331 assert(instance);
332 uhci_t *hc = dev_to_uhci(instance->dev);
333 assert(hc);
334 return uhci_schedule(hc, instance);
335}
336/*----------------------------------------------------------------------------*/
337/* DEPRECATED FUNCTIONS NEEDED BY THE OLD API */
338void batch_control_setup_old(batch_t *instance)
339{
340 assert(instance);
341 instance->packets = 1;
342
343 /* setup stage */
344 transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
345 instance->setup_size, 0, false, instance->target,
346 USB_PID_SETUP, instance->setup_buffer, NULL);
347
348 instance->next_step = batch_call_out_and_dispose;
349 batch_schedule(instance);
350}
351/*----------------------------------------------------------------------------*/
352void batch_control_write_data_old(batch_t *instance)
353{
354 assert(instance);
355 instance->packets -= 2;
356 batch_interrupt_out(instance);
357}
358/*----------------------------------------------------------------------------*/
359void batch_control_read_data_old(batch_t *instance)
360{
361 assert(instance);
362 instance->packets -= 2;
363 batch_interrupt_in(instance);
364}
365/*----------------------------------------------------------------------------*/
366void batch_control_write_status_old(batch_t *instance)
367{
368 assert(instance);
369 instance->packets = 1;
370 transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
371 0, 1, false, instance->target, USB_PID_IN, NULL, NULL);
372 instance->next_step = batch_call_in_and_dispose;
373 batch_schedule(instance);
374}
375/*----------------------------------------------------------------------------*/
376void batch_control_read_status_old(batch_t *instance)
377{
378 assert(instance);
379 instance->packets = 1;
380 transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
381 0, 1, false, instance->target, USB_PID_OUT, NULL, NULL);
382 instance->next_step = batch_call_out_and_dispose;
383 batch_schedule(instance);
384}
385/**
386 * @}
387 */
Note: See TracBrowser for help on using the repository browser.