source: mainline/uspace/drv/bus/usb/xhci/commands.c@ 1433ecda

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 1433ecda was ae3a941, checked in by Ondřej Hlavatý <aearsis@…>, 7 years ago

usb: cstyle
  • Property mode set to 100644
File size: 22.2 KB
Line 
1/*
2 * Copyright (c) 2018 Jaroslav Jindrak, Ondrej Hlavaty, Petr Manek, Michal Staruch, Jan Hrach
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 drvusbxhci
30 * @{
31 */
32/** @file
33 * @brief Command sending functions.
34 */
35
36#include <errno.h>
37#include <str_error.h>
38#include <usb/debug.h>
39#include "commands.h"
40#include "debug.h"
41#include "hc.h"
42#include "hw_struct/context.h"
43#include "hw_struct/trb.h"
44
45#define TRB_SET_TSP(trb, tsp) (trb).control |= host2xhci(32, (((tsp) & 0x1) << 9))
46#define TRB_SET_TYPE(trb, type) (trb).control |= host2xhci(32, (type) << 10)
47#define TRB_SET_DC(trb, dc) (trb).control |= host2xhci(32, (dc) << 9)
48#define TRB_SET_EP(trb, ep) (trb).control |= host2xhci(32, ((ep) & 0x5) << 16)
49#define TRB_SET_STREAM(trb, st) (trb).control |= host2xhci(32, ((st) & 0xFFFF) << 16)
50#define TRB_SET_SUSP(trb, susp) (trb).control |= host2xhci(32, ((susp) & 0x1) << 23)
51#define TRB_SET_SLOT(trb, slot) (trb).control |= host2xhci(32, (slot) << 24)
52#define TRB_SET_DEV_SPEED(trb, speed) (trb).control |= host2xhci(32, (speed & 0xF) << 16)
53#define TRB_SET_DEQUEUE_PTR(trb, dptr) (trb).parameter |= host2xhci(64, (dptr))
54#define TRB_SET_ICTX(trb, phys) (trb).parameter |= host2xhci(64, (phys) & (~0xF))
55
56#define TRB_GET_CODE(trb) XHCI_DWORD_EXTRACT((trb).status, 31, 24)
57#define TRB_GET_SLOT(trb) XHCI_DWORD_EXTRACT((trb).control, 31, 24)
58#define TRB_GET_PHYS(trb) (XHCI_QWORD_EXTRACT((trb).parameter, 63, 4) << 4)
59
60/* Control functions */
61
62static xhci_cmd_ring_t *get_cmd_ring(xhci_hc_t *hc)
63{
64 assert(hc);
65 return &hc->cr;
66}
67
68/**
69 * Initialize the command subsystem. Allocates the comand ring.
70 *
71 * Does not configure the CR pointer to the hardware, because the xHC will be
72 * reset before starting.
73 */
74errno_t xhci_init_commands(xhci_hc_t *hc)
75{
76 xhci_cmd_ring_t *cr = get_cmd_ring(hc);
77 errno_t err;
78
79 if ((err = xhci_trb_ring_init(&cr->trb_ring, 0)))
80 return err;
81
82 fibril_mutex_initialize(&cr->guard);
83 fibril_condvar_initialize(&cr->state_cv);
84 fibril_condvar_initialize(&cr->stopped_cv);
85
86 list_initialize(&cr->cmd_list);
87
88 return EOK;
89}
90
91/**
92 * Finish the command subsystem. Stops the hardware from running commands, then
93 * deallocates the ring.
94 */
95void xhci_fini_commands(xhci_hc_t *hc)
96{
97 assert(hc);
98 xhci_stop_command_ring(hc);
99
100 xhci_cmd_ring_t *cr = get_cmd_ring(hc);
101
102 fibril_mutex_lock(&cr->guard);
103 xhci_trb_ring_fini(&cr->trb_ring);
104 fibril_mutex_unlock(&cr->guard);
105}
106
107/**
108 * Initialize a command structure for the given command.
109 */
110void xhci_cmd_init(xhci_cmd_t *cmd, xhci_cmd_type_t type)
111{
112 memset(cmd, 0, sizeof(*cmd));
113
114 link_initialize(&cmd->_header.link);
115
116 fibril_mutex_initialize(&cmd->_header.completed_mtx);
117 fibril_condvar_initialize(&cmd->_header.completed_cv);
118
119 cmd->_header.cmd = type;
120}
121
122/**
123 * Finish the command structure. Some command invocation includes allocating
124 * a context structure. To have the convenience in calling commands, this
125 * method deallocates all resources.
126 */
127void xhci_cmd_fini(xhci_cmd_t *cmd)
128{
129 list_remove(&cmd->_header.link);
130
131 dma_buffer_free(&cmd->input_ctx);
132 dma_buffer_free(&cmd->bandwidth_ctx);
133
134 if (cmd->_header.async) {
135 free(cmd);
136 }
137}
138
139/**
140 * Find a command issued by TRB at @c phys inside the command list.
141 *
142 * Call with guard locked only.
143 */
144static inline xhci_cmd_t *find_command(xhci_hc_t *hc, uint64_t phys)
145{
146 xhci_cmd_ring_t *cr = get_cmd_ring(hc);
147 assert(fibril_mutex_is_locked(&cr->guard));
148
149 link_t *cmd_link = list_first(&cr->cmd_list);
150
151 while (cmd_link != NULL) {
152 xhci_cmd_t *cmd = list_get_instance(cmd_link, xhci_cmd_t,
153 _header.link);
154
155 if (cmd->_header.trb_phys == phys)
156 break;
157
158 cmd_link = list_next(cmd_link, &cr->cmd_list);
159 }
160
161 return cmd_link
162 ? list_get_instance(cmd_link, xhci_cmd_t, _header.link)
163 : NULL;
164}
165
166static void cr_set_state(xhci_cmd_ring_t *cr, xhci_cr_state_t state)
167{
168 assert(fibril_mutex_is_locked(&cr->guard));
169
170 cr->state = state;
171 if (state == XHCI_CR_STATE_OPEN || state == XHCI_CR_STATE_CLOSED)
172 fibril_condvar_broadcast(&cr->state_cv);
173}
174
175static errno_t wait_for_ring_open(xhci_cmd_ring_t *cr)
176{
177 assert(fibril_mutex_is_locked(&cr->guard));
178
179 while (true) {
180 switch (cr->state) {
181 case XHCI_CR_STATE_CHANGING:
182 case XHCI_CR_STATE_FULL:
183 fibril_condvar_wait(&cr->state_cv, &cr->guard);
184 break;
185 case XHCI_CR_STATE_OPEN:
186 return EOK;
187 case XHCI_CR_STATE_CLOSED:
188 return ENAK;
189 }
190 }
191}
192
193/**
194 * Enqueue a command on the TRB ring. Ring the doorbell to initiate processing.
195 * Register the command as waiting for completion inside the command list.
196 */
197static inline errno_t enqueue_command(xhci_hc_t *hc, xhci_cmd_t *cmd)
198{
199 xhci_cmd_ring_t *cr = get_cmd_ring(hc);
200 assert(cmd);
201
202 fibril_mutex_lock(&cr->guard);
203
204 if (wait_for_ring_open(cr)) {
205 fibril_mutex_unlock(&cr->guard);
206 return ENAK;
207 }
208
209 usb_log_debug("Sending command %s",
210 xhci_trb_str_type(TRB_TYPE(cmd->_header.trb)));
211
212 list_append(&cmd->_header.link, &cr->cmd_list);
213
214 errno_t err = EOK;
215 while (err == EOK) {
216 err = xhci_trb_ring_enqueue(&cr->trb_ring,
217 &cmd->_header.trb, &cmd->_header.trb_phys);
218 if (err != EAGAIN)
219 break;
220
221 cr_set_state(cr, XHCI_CR_STATE_FULL);
222 err = wait_for_ring_open(cr);
223 }
224
225 if (err == EOK)
226 hc_ring_doorbell(hc, 0, 0);
227
228 fibril_mutex_unlock(&cr->guard);
229
230 return err;
231}
232
233/**
234 * Stop the command ring. Stop processing commands, block issuing new ones.
235 * Wait until hardware acknowledges it is stopped.
236 */
237void xhci_stop_command_ring(xhci_hc_t *hc)
238{
239 xhci_cmd_ring_t *cr = get_cmd_ring(hc);
240
241 fibril_mutex_lock(&cr->guard);
242
243 // Prevent others from starting CR again.
244 cr_set_state(cr, XHCI_CR_STATE_CLOSED);
245
246 XHCI_REG_SET(hc->op_regs, XHCI_OP_CS, 1);
247
248 while (XHCI_REG_RD(hc->op_regs, XHCI_OP_CRR))
249 fibril_condvar_wait(&cr->stopped_cv, &cr->guard);
250
251 fibril_mutex_unlock(&cr->guard);
252}
253
254/**
255 * Mark the command ring as stopped. NAK new commands, abort running, do not
256 * touch the HC as it's probably broken.
257 */
258void xhci_nuke_command_ring(xhci_hc_t *hc)
259{
260 xhci_cmd_ring_t *cr = get_cmd_ring(hc);
261 fibril_mutex_lock(&cr->guard);
262 // Prevent others from starting CR again.
263 cr_set_state(cr, XHCI_CR_STATE_CLOSED);
264
265 XHCI_REG_SET(hc->op_regs, XHCI_OP_CS, 1);
266 fibril_mutex_unlock(&cr->guard);
267}
268
269/**
270 * Mark the command ring as working again.
271 */
272void xhci_start_command_ring(xhci_hc_t *hc)
273{
274 xhci_cmd_ring_t *cr = get_cmd_ring(hc);
275 fibril_mutex_lock(&cr->guard);
276 // Prevent others from starting CR again.
277 cr_set_state(cr, XHCI_CR_STATE_OPEN);
278 fibril_mutex_unlock(&cr->guard);
279}
280
281/**
282 * Abort currently processed command. Note that it is only aborted when the
283 * command is "blocking" - see section 4.6.1.2 of xHCI spec.
284 */
285static void abort_command_ring(xhci_hc_t *hc)
286{
287 XHCI_REG_SET(hc->op_regs, XHCI_OP_CA, 1);
288}
289
290static const char *trb_codes [] = {
291#define TRBC(t) [XHCI_TRBC_##t] = #t
292 TRBC(INVALID),
293 TRBC(SUCCESS),
294 TRBC(DATA_BUFFER_ERROR),
295 TRBC(BABBLE_DETECTED_ERROR),
296 TRBC(USB_TRANSACTION_ERROR),
297 TRBC(TRB_ERROR),
298 TRBC(STALL_ERROR),
299 TRBC(RESOURCE_ERROR),
300 TRBC(BANDWIDTH_ERROR),
301 TRBC(NO_SLOTS_ERROR),
302 TRBC(INVALID_STREAM_ERROR),
303 TRBC(SLOT_NOT_ENABLED_ERROR),
304 TRBC(EP_NOT_ENABLED_ERROR),
305 TRBC(SHORT_PACKET),
306 TRBC(RING_UNDERRUN),
307 TRBC(RING_OVERRUN),
308 TRBC(VF_EVENT_RING_FULL),
309 TRBC(PARAMETER_ERROR),
310 TRBC(BANDWIDTH_OVERRUN_ERROR),
311 TRBC(CONTEXT_STATE_ERROR),
312 TRBC(NO_PING_RESPONSE_ERROR),
313 TRBC(EVENT_RING_FULL_ERROR),
314 TRBC(INCOMPATIBLE_DEVICE_ERROR),
315 TRBC(MISSED_SERVICE_ERROR),
316 TRBC(COMMAND_RING_STOPPED),
317 TRBC(COMMAND_ABORTED),
318 TRBC(STOPPED),
319 TRBC(STOPPED_LENGTH_INVALID),
320 TRBC(STOPPED_SHORT_PACKET),
321 TRBC(MAX_EXIT_LATENCY_TOO_LARGE_ERROR),
322 [30] = "<reserved>",
323 TRBC(ISOCH_BUFFER_OVERRUN),
324 TRBC(EVENT_LOST_ERROR),
325 TRBC(UNDEFINED_ERROR),
326 TRBC(INVALID_STREAM_ID_ERROR),
327 TRBC(SECONDARY_BANDWIDTH_ERROR),
328 TRBC(SPLIT_TRANSACTION_ERROR),
329 [XHCI_TRBC_MAX] = NULL
330#undef TRBC
331};
332
333/**
334 * Report an error according to command completion code.
335 */
336static void report_error(int code)
337{
338 if (code < XHCI_TRBC_MAX && trb_codes[code] != NULL)
339 usb_log_error("Command resulted in error: %s.", trb_codes[code]);
340 else
341 usb_log_error("Command resulted in reserved or "
342 "vendor specific error.");
343}
344
345/**
346 * Handle a command completion. Feed the fibril waiting for result.
347 *
348 * @param trb The COMMAND_COMPLETION TRB found in event ring.
349 */
350errno_t xhci_handle_command_completion(xhci_hc_t *hc, xhci_trb_t *trb)
351{
352 xhci_cmd_ring_t *cr = get_cmd_ring(hc);
353 assert(trb);
354
355 fibril_mutex_lock(&cr->guard);
356
357 int code = TRB_GET_CODE(*trb);
358
359 if (code == XHCI_TRBC_COMMAND_RING_STOPPED) {
360 /* This can either mean that the ring is being stopped, or
361 * a command was aborted. In either way, wake threads waiting
362 * on stopped_cv.
363 *
364 * Note that we need to hold mutex, because we must be sure the
365 * requesting thread is waiting inside the CV.
366 */
367 usb_log_debug("Command ring stopped.");
368 fibril_condvar_broadcast(&cr->stopped_cv);
369 fibril_mutex_unlock(&cr->guard);
370 return EOK;
371 }
372
373 const uint64_t phys = TRB_GET_PHYS(*trb);
374 xhci_trb_ring_update_dequeue(&cr->trb_ring, phys);
375
376 if (cr->state == XHCI_CR_STATE_FULL)
377 cr_set_state(cr, XHCI_CR_STATE_OPEN);
378
379 xhci_cmd_t *command = find_command(hc, phys);
380 if (command == NULL) {
381 usb_log_error("No command struct for completion event found.");
382
383 if (code != XHCI_TRBC_SUCCESS)
384 report_error(code);
385
386 return EOK;
387 }
388
389 list_remove(&command->_header.link);
390
391 /* Semantics of NO_OP_CMD is that success is marked as a TRB error. */
392 if (command->_header.cmd == XHCI_CMD_NO_OP && code == XHCI_TRBC_TRB_ERROR)
393 code = XHCI_TRBC_SUCCESS;
394
395 command->status = code;
396 command->slot_id = TRB_GET_SLOT(*trb);
397
398 usb_log_debug("Completed command %s",
399 xhci_trb_str_type(TRB_TYPE(command->_header.trb)));
400
401 if (code != XHCI_TRBC_SUCCESS) {
402 report_error(code);
403 xhci_dump_trb(&command->_header.trb);
404 }
405
406 fibril_mutex_unlock(&cr->guard);
407
408 fibril_mutex_lock(&command->_header.completed_mtx);
409 command->_header.completed = true;
410 fibril_condvar_broadcast(&command->_header.completed_cv);
411 fibril_mutex_unlock(&command->_header.completed_mtx);
412
413 if (command->_header.async) {
414 /* Free the command and other DS upon completion. */
415 xhci_cmd_fini(command);
416 }
417
418 return EOK;
419}
420
421/* Command-issuing functions */
422
423static errno_t no_op_cmd(xhci_hc_t *hc, xhci_cmd_t *cmd)
424{
425 assert(hc);
426
427 xhci_trb_clean(&cmd->_header.trb);
428
429 TRB_SET_TYPE(cmd->_header.trb, XHCI_TRB_TYPE_NO_OP_CMD);
430
431 return enqueue_command(hc, cmd);
432}
433
434static errno_t enable_slot_cmd(xhci_hc_t *hc, xhci_cmd_t *cmd)
435{
436 assert(hc);
437
438 xhci_trb_clean(&cmd->_header.trb);
439
440 TRB_SET_TYPE(cmd->_header.trb, XHCI_TRB_TYPE_ENABLE_SLOT_CMD);
441 cmd->_header.trb.control |=
442 host2xhci(32, XHCI_REG_RD(hc->xecp, XHCI_EC_SP_SLOT_TYPE) << 16);
443
444 return enqueue_command(hc, cmd);
445}
446
447static errno_t disable_slot_cmd(xhci_hc_t *hc, xhci_cmd_t *cmd)
448{
449 assert(hc);
450 assert(cmd);
451
452 xhci_trb_clean(&cmd->_header.trb);
453
454 TRB_SET_TYPE(cmd->_header.trb, XHCI_TRB_TYPE_DISABLE_SLOT_CMD);
455 TRB_SET_SLOT(cmd->_header.trb, cmd->slot_id);
456
457 return enqueue_command(hc, cmd);
458}
459
460static errno_t address_device_cmd(xhci_hc_t *hc, xhci_cmd_t *cmd)
461{
462 assert(hc);
463 assert(cmd);
464 assert(dma_buffer_is_set(&cmd->input_ctx));
465
466 /**
467 * TODO: Requirements for this command:
468 * dcbaa[slot_id] is properly sized and initialized
469 * ictx has valids slot context and endpoint 0, all
470 * other should be ignored at this point (see section 4.6.5).
471 */
472
473 xhci_trb_clean(&cmd->_header.trb);
474
475 const uintptr_t phys = dma_buffer_phys_base(&cmd->input_ctx);
476 TRB_SET_ICTX(cmd->_header.trb, phys);
477
478 /**
479 * Note: According to section 6.4.3.4, we can set the 9th bit
480 * of the control field of the trb (BSR) to 1 and then the xHC
481 * will not issue the SET_ADDRESS request to the USB device.
482 * This can be used to provide compatibility with legacy USB devices
483 * that require their device descriptor to be read before such request.
484 */
485 TRB_SET_TYPE(cmd->_header.trb, XHCI_TRB_TYPE_ADDRESS_DEVICE_CMD);
486 TRB_SET_SLOT(cmd->_header.trb, cmd->slot_id);
487
488 return enqueue_command(hc, cmd);
489}
490
491static errno_t configure_endpoint_cmd(xhci_hc_t *hc, xhci_cmd_t *cmd)
492{
493 assert(hc);
494 assert(cmd);
495
496 xhci_trb_clean(&cmd->_header.trb);
497
498 if (!cmd->deconfigure) {
499 /* If the DC flag is on, input context is not evaluated. */
500 assert(dma_buffer_is_set(&cmd->input_ctx));
501
502 const uintptr_t phys = dma_buffer_phys_base(&cmd->input_ctx);
503 TRB_SET_ICTX(cmd->_header.trb, phys);
504 }
505
506 TRB_SET_TYPE(cmd->_header.trb, XHCI_TRB_TYPE_CONFIGURE_ENDPOINT_CMD);
507 TRB_SET_SLOT(cmd->_header.trb, cmd->slot_id);
508 TRB_SET_DC(cmd->_header.trb, cmd->deconfigure);
509
510 return enqueue_command(hc, cmd);
511}
512
513static errno_t evaluate_context_cmd(xhci_hc_t *hc, xhci_cmd_t *cmd)
514{
515 assert(hc);
516 assert(cmd);
517 assert(dma_buffer_is_set(&cmd->input_ctx));
518
519 /**
520 * Note: All Drop Context flags of the input context shall be 0,
521 * all Add Context flags shall be initialize to indicate IDs
522 * of the contexts affected by the command.
523 * Refer to sections 6.2.2.3 and 6.3.3.3 for further info.
524 */
525 xhci_trb_clean(&cmd->_header.trb);
526
527 const uintptr_t phys = dma_buffer_phys_base(&cmd->input_ctx);
528 TRB_SET_ICTX(cmd->_header.trb, phys);
529
530 TRB_SET_TYPE(cmd->_header.trb, XHCI_TRB_TYPE_EVALUATE_CONTEXT_CMD);
531 TRB_SET_SLOT(cmd->_header.trb, cmd->slot_id);
532
533 return enqueue_command(hc, cmd);
534}
535
536static errno_t reset_endpoint_cmd(xhci_hc_t *hc, xhci_cmd_t *cmd)
537{
538 assert(hc);
539 assert(cmd);
540
541 xhci_trb_clean(&cmd->_header.trb);
542
543 TRB_SET_TYPE(cmd->_header.trb, XHCI_TRB_TYPE_RESET_ENDPOINT_CMD);
544 TRB_SET_TSP(cmd->_header.trb, cmd->tsp);
545 TRB_SET_EP(cmd->_header.trb, cmd->endpoint_id);
546 TRB_SET_SLOT(cmd->_header.trb, cmd->slot_id);
547
548 return enqueue_command(hc, cmd);
549}
550
551static errno_t stop_endpoint_cmd(xhci_hc_t *hc, xhci_cmd_t *cmd)
552{
553 assert(hc);
554 assert(cmd);
555
556 xhci_trb_clean(&cmd->_header.trb);
557
558 TRB_SET_TYPE(cmd->_header.trb, XHCI_TRB_TYPE_STOP_ENDPOINT_CMD);
559 TRB_SET_EP(cmd->_header.trb, cmd->endpoint_id);
560 TRB_SET_SUSP(cmd->_header.trb, cmd->susp);
561 TRB_SET_SLOT(cmd->_header.trb, cmd->slot_id);
562
563 return enqueue_command(hc, cmd);
564}
565
566static errno_t set_tr_dequeue_pointer_cmd(xhci_hc_t *hc, xhci_cmd_t *cmd)
567{
568 assert(hc);
569 assert(cmd);
570
571 xhci_trb_clean(&cmd->_header.trb);
572
573 TRB_SET_TYPE(cmd->_header.trb, XHCI_TRB_TYPE_SET_TR_DEQUEUE_POINTER_CMD);
574 TRB_SET_EP(cmd->_header.trb, cmd->endpoint_id);
575 TRB_SET_STREAM(cmd->_header.trb, cmd->stream_id);
576 TRB_SET_SLOT(cmd->_header.trb, cmd->slot_id);
577 TRB_SET_DEQUEUE_PTR(cmd->_header.trb, cmd->dequeue_ptr);
578
579 return enqueue_command(hc, cmd);
580}
581
582static errno_t reset_device_cmd(xhci_hc_t *hc, xhci_cmd_t *cmd)
583{
584 assert(hc);
585 assert(cmd);
586
587 xhci_trb_clean(&cmd->_header.trb);
588
589 TRB_SET_TYPE(cmd->_header.trb, XHCI_TRB_TYPE_RESET_DEVICE_CMD);
590 TRB_SET_SLOT(cmd->_header.trb, cmd->slot_id);
591
592 return enqueue_command(hc, cmd);
593}
594
595static errno_t get_port_bandwidth_cmd(xhci_hc_t *hc, xhci_cmd_t *cmd)
596{
597 assert(hc);
598 assert(cmd);
599
600 xhci_trb_clean(&cmd->_header.trb);
601
602 const uintptr_t phys = dma_buffer_phys_base(&cmd->input_ctx);
603 TRB_SET_ICTX(cmd->_header.trb, phys);
604
605 TRB_SET_TYPE(cmd->_header.trb, XHCI_TRB_TYPE_GET_PORT_BANDWIDTH_CMD);
606 TRB_SET_SLOT(cmd->_header.trb, cmd->slot_id);
607 TRB_SET_DEV_SPEED(cmd->_header.trb, cmd->device_speed);
608
609 return enqueue_command(hc, cmd);
610}
611
612/* The table of command-issuing functions. */
613
614typedef errno_t (*cmd_handler) (xhci_hc_t *hc, xhci_cmd_t *cmd);
615
616static cmd_handler cmd_handlers [] = {
617 [XHCI_CMD_ENABLE_SLOT] = enable_slot_cmd,
618 [XHCI_CMD_DISABLE_SLOT] = disable_slot_cmd,
619 [XHCI_CMD_ADDRESS_DEVICE] = address_device_cmd,
620 [XHCI_CMD_CONFIGURE_ENDPOINT] = configure_endpoint_cmd,
621 [XHCI_CMD_EVALUATE_CONTEXT] = evaluate_context_cmd,
622 [XHCI_CMD_RESET_ENDPOINT] = reset_endpoint_cmd,
623 [XHCI_CMD_STOP_ENDPOINT] = stop_endpoint_cmd,
624 [XHCI_CMD_SET_TR_DEQUEUE_POINTER] = set_tr_dequeue_pointer_cmd,
625 [XHCI_CMD_RESET_DEVICE] = reset_device_cmd,
626 [XHCI_CMD_FORCE_EVENT] = NULL,
627 [XHCI_CMD_NEGOTIATE_BANDWIDTH] = NULL,
628 [XHCI_CMD_SET_LATENCY_TOLERANCE_VALUE] = NULL,
629 [XHCI_CMD_GET_PORT_BANDWIDTH] = get_port_bandwidth_cmd,
630 [XHCI_CMD_FORCE_HEADER] = NULL,
631 [XHCI_CMD_NO_OP] = no_op_cmd
632};
633
634/**
635 * Try to abort currently processed command. This is tricky, because
636 * calling fibril is not necessarily the one which issued the blocked command.
637 * Also, the trickiness intensifies by the fact that stopping a CR is denoted by
638 * event, which is again handled in different fibril. but, once we go to sleep
639 * on waiting for that event, another fibril may wake up and try to abort the
640 * blocked command.
641 *
642 * So, we mark the command ring as being restarted, wait for it to stop, and
643 * then start it again. If there was a blocked command, it will be satisfied by
644 * COMMAND_ABORTED event.
645 */
646static errno_t try_abort_current_command(xhci_hc_t *hc)
647{
648 xhci_cmd_ring_t *cr = get_cmd_ring(hc);
649
650 fibril_mutex_lock(&cr->guard);
651
652 if (cr->state == XHCI_CR_STATE_CLOSED) {
653 fibril_mutex_unlock(&cr->guard);
654 return ENAK;
655 }
656
657 if (cr->state == XHCI_CR_STATE_CHANGING) {
658 fibril_mutex_unlock(&cr->guard);
659 return EOK;
660 }
661
662 usb_log_error("Timeout while waiting for command: "
663 "aborting current command.");
664
665 cr_set_state(cr, XHCI_CR_STATE_CHANGING);
666
667 abort_command_ring(hc);
668
669 fibril_condvar_wait_timeout(&cr->stopped_cv, &cr->guard,
670 XHCI_CR_ABORT_TIMEOUT);
671
672 if (XHCI_REG_RD(hc->op_regs, XHCI_OP_CRR)) {
673 /* 4.6.1.2, implementation note
674 * Assume there are larger problems with HC and
675 * reset it.
676 */
677 usb_log_error("Command didn't abort.");
678
679 cr_set_state(cr, XHCI_CR_STATE_CLOSED);
680
681 // TODO: Reset HC completely.
682 // Don't forget to somehow complete all commands with error.
683
684 fibril_mutex_unlock(&cr->guard);
685 return ENAK;
686 }
687
688 cr_set_state(cr, XHCI_CR_STATE_OPEN);
689
690 fibril_mutex_unlock(&cr->guard);
691
692 usb_log_error("Command ring stopped. Starting again.");
693 hc_ring_doorbell(hc, 0, 0);
694
695 return EOK;
696}
697
698/**
699 * Wait, until the command is completed. The completion is triggered by
700 * COMMAND_COMPLETION event. As we do not want to rely on HW completing the
701 * command in timely manner, we timeout. Note that we can't just return an
702 * error after the timeout pass - it may be other command blocking the ring,
703 * and ours can be completed afterwards. Therefore, it is not guaranteed that
704 * this function will return in XHCI_COMMAND_TIMEOUT. It will continue waiting
705 * until COMMAND_COMPLETION event arrives.
706 */
707static errno_t wait_for_cmd_completion(xhci_hc_t *hc, xhci_cmd_t *cmd)
708{
709 errno_t rv = EOK;
710
711 if (fibril_get_id() == hc->event_handler) {
712 usb_log_error("Deadlock detected in waiting for command.");
713 abort();
714 }
715
716 fibril_mutex_lock(&cmd->_header.completed_mtx);
717 while (!cmd->_header.completed) {
718
719 rv = fibril_condvar_wait_timeout(&cmd->_header.completed_cv,
720 &cmd->_header.completed_mtx, XHCI_COMMAND_TIMEOUT);
721
722 /* The waiting timed out. Current command (not necessarily
723 * ours) is probably blocked.
724 */
725 if (!cmd->_header.completed && rv == ETIMEOUT) {
726 fibril_mutex_unlock(&cmd->_header.completed_mtx);
727
728 rv = try_abort_current_command(hc);
729 if (rv)
730 return rv;
731
732 fibril_mutex_lock(&cmd->_header.completed_mtx);
733 }
734 }
735 fibril_mutex_unlock(&cmd->_header.completed_mtx);
736
737 return rv;
738}
739
740/**
741 * Issue command and block the current fibril until it is completed or timeout
742 * expires. Nothing is deallocated. Caller should always execute `xhci_cmd_fini`.
743 */
744errno_t xhci_cmd_sync(xhci_hc_t *hc, xhci_cmd_t *cmd)
745{
746 assert(hc);
747 assert(cmd);
748
749 errno_t err;
750
751 if (!cmd_handlers[cmd->_header.cmd]) {
752 /* Handler not implemented. */
753 return ENOTSUP;
754 }
755
756 if ((err = cmd_handlers[cmd->_header.cmd](hc, cmd))) {
757 /* Command could not be issued. */
758 return err;
759 }
760
761 if ((err = wait_for_cmd_completion(hc, cmd))) {
762 /* Command failed. */
763 return err;
764 }
765
766 switch (cmd->status) {
767 case XHCI_TRBC_SUCCESS:
768 return EOK;
769 case XHCI_TRBC_USB_TRANSACTION_ERROR:
770 return ESTALL;
771 case XHCI_TRBC_RESOURCE_ERROR:
772 case XHCI_TRBC_BANDWIDTH_ERROR:
773 case XHCI_TRBC_NO_SLOTS_ERROR:
774 return ELIMIT;
775 case XHCI_TRBC_SLOT_NOT_ENABLED_ERROR:
776 return ENOENT;
777 default:
778 return EINVAL;
779 }
780}
781
782/**
783 * Does the same thing as `xhci_cmd_sync` and executes `xhci_cmd_fini`. This
784 * is a useful shorthand for issuing commands without out parameters.
785 */
786errno_t xhci_cmd_sync_fini(xhci_hc_t *hc, xhci_cmd_t *cmd)
787{
788 const errno_t err = xhci_cmd_sync(hc, cmd);
789 xhci_cmd_fini(cmd);
790
791 return err;
792}
793
794/**
795 * Does the same thing as `xhci_cmd_sync_fini` without blocking the current
796 * fibril. The command is copied to stack memory and `fini` is called upon its completion.
797 */
798errno_t xhci_cmd_async_fini(xhci_hc_t *hc, xhci_cmd_t *stack_cmd)
799{
800 assert(hc);
801 assert(stack_cmd);
802
803 /* Save the command for later. */
804 xhci_cmd_t *heap_cmd = (xhci_cmd_t *) malloc(sizeof(xhci_cmd_t));
805 if (!heap_cmd) {
806 return ENOMEM;
807 }
808
809 /* TODO: Is this good for the mutex and the condvar? */
810 memcpy(heap_cmd, stack_cmd, sizeof(xhci_cmd_t));
811 heap_cmd->_header.async = true;
812
813 /* Issue the command. */
814 errno_t err;
815
816 if (!cmd_handlers[heap_cmd->_header.cmd]) {
817 /* Handler not implemented. */
818 err = ENOTSUP;
819 goto err_heap_cmd;
820 }
821
822 if ((err = cmd_handlers[heap_cmd->_header.cmd](hc, heap_cmd))) {
823 /* Command could not be issued. */
824 goto err_heap_cmd;
825 }
826
827 return EOK;
828
829err_heap_cmd:
830 free(heap_cmd);
831 return err;
832}
833
834/**
835 * @}
836 */
Note: See TracBrowser for help on using the repository browser.