1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <gelf.h>
30
31 #include <sys/mdb_modapi.h>
32 #include <mdb/mdb_ks.h>
33
34 #include <sys/usb/usba.h>
35 #include <sys/usb/usba/usba_types.h>
36
37 #include <sys/usb/hcd/uhci/uhci.h>
38 #include <sys/usb/hcd/uhci/uhcid.h>
39 #include <sys/usb/hcd/uhci/uhciutil.h>
40
41
42 #define UHCI_TD 0
43 #define UHCI_QH 1
44
45
46 /* Prototypes */
47
48 int uhci_td(uintptr_t, uint_t, int, const mdb_arg_t *);
49 int uhci_qh(uintptr_t, uint_t, int, const mdb_arg_t *);
50 int uhci_td_walk_init(mdb_walk_state_t *);
51 int uhci_td_walk_step(mdb_walk_state_t *);
52 int uhci_qh_walk_init(mdb_walk_state_t *);
53 int uhci_qh_walk_step(mdb_walk_state_t *);
54
55
56 /*
57 * Callback for find_uhci_statep (called back from walk "softstate" in
58 * find_uhci_statep).
59 *
60 * - uhci_instancep is the value of the current pointer in the array of soft
61 * state instance pointers (see i_ddi_soft_state in ddi_impldefs.h)
62 * - local_ss is a pointer to the copy of the i_ddi_soft_state in local space
63 * - cb_arg is a pointer to the cb arg (an instance of state_find_data).
64 *
65 * For the current uchi_state_t*, see if the td address is in its pool.
66 *
67 * Returns WALK_NEXT on success (match not found yet), WALK_ERR on errors.
68 *
69 * WALK_DONE is returned, cb_data.found is set to TRUE, and
70 * *cb_data.fic_uhci_statep is filled in with the contents of the state
71 * struct in core. This forces the walk to terminate.
72 */
73 typedef struct find_instance_struct {
74 void *fic_td_qh; /* td/qh we want uhci instance for */
75 boolean_t fic_td_or_qh; /* which one td_qh points to */
76 boolean_t fic_found;
77 uhci_state_t *fic_uhci_statep; /* buffer uhci_state's written into */
78 } find_instance_cb_t;
79
80 /*ARGSUSED*/
81 static int
82 find_uhci_instance(uintptr_t uhci_instancep, const void *local_ss, void *cb_arg)
83 {
84 int td_pool_size, qh_pool_size;
85 find_instance_cb_t *cb_data = (find_instance_cb_t *)cb_arg;
86 uhci_state_t *uhcip = cb_data->fic_uhci_statep;
87
88
89 if (mdb_vread(cb_data->fic_uhci_statep, sizeof (uhci_state_t),
90 uhci_instancep) == -1) {
91 mdb_warn("failed to read uhci_state at %p", uhci_instancep);
92 return (-1);
93 }
94
95 if (mdb_readsym(&td_pool_size, sizeof (int), "uhci_td_pool_size") ==
96 -1) {
97 mdb_warn("failed to read uhci_td_pool_size");
98 return (-1);
99 }
100
101 if (mdb_readsym(&qh_pool_size, sizeof (int), "uhci_qh_pool_size") ==
102 -1) {
103 mdb_warn("failed to read uhci_td_pool_size");
104 return (-1);
105 }
106
107 /*
108 * See if the addr is within the appropriate pool for this instance.
109 */
110 if ((cb_data->fic_td_or_qh == UHCI_TD &&
111
112 ((uhci_td_t *)cb_data->fic_td_qh >= uhcip->uhci_td_pool_addr &&
113 (uhci_td_t *)cb_data->fic_td_qh <= (uhcip->uhci_td_pool_addr +
114 td_pool_size - sizeof (uhci_td_t)))) ||
115
116 (cb_data->fic_td_or_qh == UHCI_QH &&
117
118 ((queue_head_t *)cb_data->fic_td_qh >= uhcip->uhci_qh_pool_addr &&
119 (queue_head_t *)cb_data->fic_td_qh <= (uhcip->uhci_qh_pool_addr +
120 qh_pool_size - sizeof (queue_head_t))))) {
121
122 /* td/qh address is within pool for this instance of uhci. */
123 cb_data->fic_found = TRUE;
124 return (WALK_DONE);
125 }
126
127 return (WALK_NEXT);
128 }
129
130 /*
131 * Figure out which instance of uhci owns a td/qh.
132 *
133 * - td_qh: a pointer to a uhci td or qh
134 * - td_or_qh: a flag indicating which it is (td/qh),
135 * - uhci_statep, pointer to a uhci_state_t, to be filled in with data from
136 * the found instance of uhci_state_t.
137 *
138 * Only works for Cntl/Interrupt tds/qhs; others are dynamically allocated
139 * and so cannot be found with this method.
140 *
141 * Returns 0 on success (no match found), 1 on success (match found),
142 * -1 on errors.
143 */
144 static int
145 find_uhci_statep(void *td_qh, boolean_t td_or_qh, uhci_state_t *uhci_statep)
146 {
147 find_instance_cb_t cb_data;
148 uintptr_t uhci_ss;
149
150
151 if (uhci_statep == NULL) {
152 mdb_warn("failed to find uhci statep: "
153 "NULL uhci_statep param\n");
154 return (-1);
155 }
156
157 cb_data.fic_td_qh = td_qh;
158 cb_data.fic_td_or_qh = td_or_qh;
159 cb_data.fic_found = FALSE;
160 cb_data.fic_uhci_statep = uhci_statep;
161
162
163 if (mdb_readsym(&uhci_ss, sizeof (uhci_statep),
164 "uhci_statep") == -1) {
165 mdb_warn("failed to read uhci_statep");
166 return (-1);
167 }
168
169
170 /*
171 * Walk all instances of uhci.
172 * The callback func checks if td_qh belongs to a given instance
173 * of uhci.
174 */
175 if (mdb_pwalk("softstate", find_uhci_instance, &cb_data,
176 uhci_ss) != 0) {
177 mdb_warn("failed to walk softstate");
178 return (-1);
179 }
180
181 if (cb_data.fic_found == TRUE) {
182 return (1);
183 }
184
185 return (0);
186 }
187
188 /*
189 * Dump a UHCI TD (transaction descriptor);
190 * or (-d) the chain of TDs starting with the one specified.
191 */
192 int
193 uhci_td(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
194 {
195 uint_t depth_flag = FALSE;
196 uhci_state_t uhci_state, *uhcip = &uhci_state;
197 uhci_td_t td;
198
199
200 if (!(flags & DCMD_ADDRSPEC))
201 return (DCMD_USAGE);
202
203 if (addr & ~QH_LINK_PTR_MASK) {
204 mdb_warn("address must be on a 16-byte boundary.\n");
205 return (DCMD_ERR);
206 }
207
208 if (mdb_getopts(argc, argv,
209 'd', MDB_OPT_SETBITS, TRUE, &depth_flag,
210 NULL) != argc) {
211 return (DCMD_USAGE);
212 }
213
214
215 if (depth_flag) {
216 if (mdb_pwalk_dcmd("uhci_td", "uhci_td", 0, NULL, addr) == -1) {
217 mdb_warn("failed to walk 'uhci_td'");
218 return (DCMD_ERR);
219 }
220 return (DCMD_OK);
221 }
222
223
224 if (find_uhci_statep((void *)addr, UHCI_TD, uhcip) != 1) {
225 mdb_warn("failed to find uhci_statep");
226 return (DCMD_ERR);
227 }
228
229 if (mdb_vread(&td, sizeof (td), addr) != sizeof (td)) {
230 mdb_warn("failed to read td at vaddr %p", addr);
231 return (DCMD_ERR);
232 }
233
234 mdb_printf("\n UHCI td struct at (vaddr) %08x:\n", addr);
235
236 if (!(td.link_ptr & HC_END_OF_LIST) && td.link_ptr != NULL) {
237 mdb_printf(" link_ptr (paddr) : %-8x "
238 "(vaddr) : %p\n",
239 td.link_ptr,
240 /* Note: uhcip needed by TD_VADDR macro */
241 TD_VADDR(td.link_ptr & QH_LINK_PTR_MASK));
242 } else {
243 mdb_printf(" link_ptr (paddr) : %-8x\n",
244 td.link_ptr);
245 }
246 mdb_printf(" td_dword2 : %08x\n", td.dw2);
247 mdb_printf(" td_dword3 : %08x\n", td.dw3);
248 mdb_printf(" buffer_address : %08x\n", td.buffer_address);
249 mdb_printf(" qh_td_prev : %?p "
250 "tw_td_next : %?p\n",
251 td.qh_td_prev, td.tw_td_next);
252 mdb_printf(" outst_td_prev : %?p "
253 "outst_td_next : %?p\n",
254 td.outst_td_prev, td.outst_td_next);
255 mdb_printf(" tw : %?p "
256 "flag : %02x\n", td.tw, td.flag);
257 mdb_printf(" isoc_next : %?p "
258 "isoc_prev : %0x\n", td.isoc_next, td.isoc_prev);
259 mdb_printf(" isoc_pkt_index : %0x "
260 "startingframe: %0x\n", td.isoc_pkt_index, td.starting_frame);
261
262
263 if (td.link_ptr == NULL) {
264 mdb_printf(" --> Link pointer = NULL\n");
265 return (DCMD_ERR);
266 } else {
267
268 /* Inform user if link is to a TD or QH. */
269 if (td.link_ptr & HC_END_OF_LIST) {
270 mdb_printf(" "
271 "--> Link pointer invalid (terminate bit set).\n");
272 } else {
273 if ((td.link_ptr & HC_QUEUE_HEAD) == HC_QUEUE_HEAD) {
274 mdb_printf(" "
275 "--> Link pointer points to a QH.\n");
276 } else {
277 mdb_printf(" "
278 "--> Link pointer points to a TD.\n");
279 }
280 }
281 }
282
283 return (DCMD_OK);
284 }
285
286 /*
287 * Dump a UHCI QH (queue head).
288 * -b walk/dump the chian of QHs starting with the one specified.
289 * -d also dump the chain of TDs starting with the one specified.
290 */
291 int
292 uhci_qh(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
293 {
294 uint_t breadth_flag = FALSE, depth_flag = FALSE;
295 uhci_state_t uhci_state, *uhcip = &uhci_state;
296 queue_head_t qh;
297
298
299 if (!(flags & DCMD_ADDRSPEC))
300 return (DCMD_USAGE);
301
302 if (addr & ~QH_LINK_PTR_MASK) {
303 mdb_warn("address must be on a 16-byte boundary.\n");
304 return (DCMD_ERR);
305 }
306
307 if (mdb_getopts(argc, argv,
308 'b', MDB_OPT_SETBITS, TRUE, &breadth_flag,
309 'd', MDB_OPT_SETBITS, TRUE, &depth_flag,
310 NULL) != argc) {
311 return (DCMD_USAGE);
312 }
313
314
315 if (breadth_flag) {
316 uint_t new_argc = 0;
317 mdb_arg_t new_argv[1];
318
319
320 if (depth_flag) {
321 new_argc = 1;
322 new_argv[0].a_type = MDB_TYPE_STRING;
323 new_argv[0].a_un.a_str = "-d";
324 }
325
326 if ((mdb_pwalk_dcmd("uhci_qh", "uhci_qh", new_argc, new_argv,
327 addr)) != 0) {
328 mdb_warn("failed to walk 'uhci_qh'");
329 return (DCMD_ERR);
330 }
331 return (DCMD_OK);
332 }
333
334
335 if (find_uhci_statep((void *)addr, UHCI_QH, uhcip) != 1) {
336 mdb_warn("failed to find uhci_statep");
337 return (DCMD_ERR);
338 }
339
340
341 if (mdb_vread(&qh, sizeof (qh), addr) != sizeof (qh)) {
342 mdb_warn("failed to read qh at vaddr %p", addr);
343 return (DCMD_ERR);
344 }
345
346 mdb_printf("\n UHCI qh struct at (vaddr) %08x:\n", addr);
347
348 if (!(qh.link_ptr & HC_END_OF_LIST) && qh.link_ptr != NULL) {
349 mdb_printf(" link_ptr (paddr) : %08x "
350 "(vaddr) : %p\n",
351 qh.link_ptr,
352 /* Note: uhcip needed by QH_VADDR macro */
353 QH_VADDR(qh.link_ptr & QH_LINK_PTR_MASK));
354 } else {
355 mdb_printf(
356 " link_ptr (paddr) : %08x\n",
357 qh.link_ptr);
358 }
359
360 if (!(qh.element_ptr & HC_END_OF_LIST) && qh.element_ptr != NULL) {
361 mdb_printf(" element_ptr (paddr) : %08x "
362 "(vaddr) : %p\n",
363 qh.element_ptr,
364 /* Note: uhcip needed by TD_VADDR macro */
365 TD_VADDR(qh.element_ptr & QH_LINK_PTR_MASK));
366 } else {
367 mdb_printf(
368 " element_ptr (paddr) : %08x\n", qh.element_ptr);
369 }
370
371 mdb_printf(" node : %04x "
372 "flag : %04x\n",
373 qh.node, qh.qh_flag);
374 mdb_printf(" prev_qh : %?p "
375 "td_tailp : %?p\n",
376 qh.prev_qh, qh.td_tailp);
377 mdb_printf(" bulk_xfer_isoc_info : %?p\n", qh.bulk_xfer_info);
378
379
380 if (qh.link_ptr == NULL) {
381 mdb_printf(" --> Link pointer = NULL\n");
382 return (DCMD_ERR);
383 } else {
384
385 /* Inform user if next link is a TD or QH. */
386 if (qh.link_ptr & HC_END_OF_LIST) {
387 mdb_printf(" "
388 "--> Link pointer invalid (terminate bit set).\n");
389 } else {
390 if ((qh.link_ptr & HC_QUEUE_HEAD) == HC_QUEUE_HEAD) {
391 mdb_printf(" "
392 "--> Link pointer points to a QH.\n");
393 } else {
394 /* Should never happen. */
395 mdb_warn(" "
396 "--> Link pointer points to a TD.\n");
397 return (DCMD_ERR);
398 }
399 }
400 }
401
402
403 if (qh.element_ptr == NULL) {
404 mdb_printf(" element_ptr = NULL\n");
405 return (DCMD_ERR);
406 } else {
407
408 /* Inform user if next element is a TD or QH. */
409 if (qh.element_ptr & HC_END_OF_LIST) {
410 mdb_printf(" "
411 "-->Element pointer invalid (terminate bit set)."
412 "\n");
413 return (DCMD_OK);
414 } else {
415 if ((qh.element_ptr & HC_QUEUE_HEAD) == HC_QUEUE_HEAD) {
416 mdb_printf(" "
417 "--> Element pointer points to a QH.\n");
418 /* Should never happen in UHCI implementation */
419 return (DCMD_ERR);
420 } else {
421 mdb_printf(" "
422 "--> Element pointer points to a TD.\n");
423 }
424 }
425 }
426
427 /*
428 * If the user specified the -d (depth) option,
429 * dump all TDs linked to this TD via the element_ptr.
430 */
431 if (depth_flag) {
432
433 /* Traverse and display all the TDs in the chain */
434 if (mdb_pwalk_dcmd("uhci_td", "uhci_td", argc, argv,
435 (uintptr_t)(TD_VADDR(qh.element_ptr &
436 QH_LINK_PTR_MASK))) == -1) {
437 mdb_warn("failed to walk 'uhci_td'");
438 return (DCMD_ERR);
439 }
440 }
441
442 return (DCMD_OK);
443 }
444
445 /*
446 * Walk a list of UHCI Transaction Descriptors (td's).
447 * Stop at the end of the list, or if the next element in the list is a
448 * queue head (qh).
449 * User must specify the address of the first td to look at.
450 */
451 int
452 uhci_td_walk_init(mdb_walk_state_t *wsp)
453 {
454 if (wsp->walk_addr == NULL) {
455 return (DCMD_USAGE);
456 }
457
458 wsp->walk_data = mdb_alloc(sizeof (uhci_td_t), UM_SLEEP | UM_GC);
459 wsp->walk_arg = mdb_alloc(sizeof (uhci_state_t), UM_SLEEP | UM_GC);
460
461
462 /*
463 * Read the uhci_state_t for the instance of uhci
464 * using this td address into buf pointed to by walk_arg.
465 */
466 if (find_uhci_statep((void *)wsp->walk_addr, UHCI_TD,
467 wsp->walk_arg) != 1) {
468 mdb_warn("failed to find uhci_statep");
469 return (WALK_ERR);
470 }
471
472 return (WALK_NEXT);
473 }
474
475 /*
476 * At each step, read a TD into our private storage, and then invoke
477 * the callback function. We terminate when we reach a QH, or
478 * link_ptr is NULL.
479 */
480 int
481 uhci_td_walk_step(mdb_walk_state_t *wsp)
482 {
483 int status;
484 uhci_state_t *uhcip = (uhci_state_t *)wsp->walk_arg;
485
486
487 if (mdb_vread(wsp->walk_data, sizeof (uhci_td_t), wsp->walk_addr)
488 == -1) {
489 mdb_warn("failed to read td at %p", wsp->walk_addr);
490 return (WALK_DONE);
491 }
492
493 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
494 wsp->walk_cbdata);
495
496 /* Next td. */
497 wsp->walk_addr = ((uhci_td_t *)wsp->walk_data)->link_ptr;
498
499 /* Check if we're at the last element */
500 if (wsp->walk_addr == NULL || wsp->walk_addr & HC_END_OF_LIST)
501 return (WALK_DONE);
502
503 /* Make sure next element is a TD. If a QH, stop. */
504 if (((((uhci_td_t *)wsp->walk_data)->link_ptr) & HC_QUEUE_HEAD)
505 == HC_QUEUE_HEAD) {
506 return (WALK_DONE);
507 }
508
509 /* Strip terminate etc. bits. */
510 wsp->walk_addr &= QH_LINK_PTR_MASK; /* there is no TD_LINK_PTR_MASK */
511
512 if (wsp->walk_addr == NULL)
513 return (WALK_DONE);
514
515 /*
516 * Convert link_ptr paddr to vaddr
517 * Note: uhcip needed by TD_VADDR macro
518 */
519 wsp->walk_addr = (uintptr_t)TD_VADDR(wsp->walk_addr);
520
521 return (status);
522 }
523
524 /*
525 * Walk a list of UHCI Queue Heads (qh's).
526 * Stop at the end of the list, or if the next element in the list is a
527 * Transaction Descriptor (td).
528 * User must specify the address of the first qh to look at.
529 */
530 int
531 uhci_qh_walk_init(mdb_walk_state_t *wsp)
532 {
533 if (wsp->walk_addr == NULL)
534 return (DCMD_USAGE);
535
536 wsp->walk_data = mdb_alloc(sizeof (queue_head_t), UM_SLEEP | UM_GC);
537 wsp->walk_arg = mdb_alloc(sizeof (uhci_state_t), UM_SLEEP | UM_GC);
538
539
540 /*
541 * Read the uhci_state_t for the instance of uhci
542 * using this td address into buf pointed to by walk_arg.
543 */
544 if (find_uhci_statep((void *)wsp->walk_addr, UHCI_QH,
545 (uhci_state_t *)wsp->walk_arg) != 1) {
546 mdb_warn("failed to find uhci_statep");
547 return (WALK_ERR);
548 }
549
550 return (WALK_NEXT);
551 }
552
553 /*
554 * At each step, read a QH into our private storage, and then invoke
555 * the callback function. We terminate when we reach a QH, or
556 * link_ptr is NULL.
557 */
558 int
559 uhci_qh_walk_step(mdb_walk_state_t *wsp)
560 {
561 int status;
562 uhci_state_t *uhcip = (uhci_state_t *)wsp->walk_arg;
563
564
565 if (wsp->walk_addr == NULL) /* Should never occur */
566 return (WALK_DONE);
567
568 if (mdb_vread(wsp->walk_data, sizeof (queue_head_t), wsp->walk_addr)
569 == -1) {
570 mdb_warn("failure reading qh at %p", wsp->walk_addr);
571 return (WALK_DONE);
572 }
573
574 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
575 wsp->walk_cbdata);
576
577 /* Next QH. */
578 wsp->walk_addr = ((queue_head_t *)wsp->walk_data)->link_ptr;
579
580
581 /* Check if we're at the last element */
582 if (wsp->walk_addr == NULL || wsp->walk_addr & HC_END_OF_LIST) {
583 return (WALK_DONE);
584 }
585
586 /* Make sure next element is a QH. If a TD, stop. */
587 if (! ((((queue_head_t *)wsp->walk_data)->link_ptr) & HC_QUEUE_HEAD)
588 == HC_QUEUE_HEAD) {
589 return (WALK_DONE);
590 }
591
592 /* Strip terminate etc. bits. */
593 wsp->walk_addr &= QH_LINK_PTR_MASK;
594
595 if (wsp->walk_addr == NULL)
596 return (WALK_DONE);
597
598 /*
599 * Convert link_ptr paddr to vaddr
600 * Note: uhcip needed by QH_VADDR macro
601 */
602 wsp->walk_addr = (uintptr_t)QH_VADDR(wsp->walk_addr);
603
604 return (status);
605 }
606
607 /*
608 * MDB module linkage information:
609 *
610 * We declare a list of structures describing our dcmds, and a function
611 * named _mdb_init to return a pointer to our module information.
612 */
613
614 static const mdb_dcmd_t dcmds[] = {
615 { "uhci_td", ": [-d]", "print UHCI TD", uhci_td, NULL },
616 { "uhci_qh", ": [-bd]", "print UHCI QH", uhci_qh, NULL},
617 { NULL }
618 };
619
620
621 static const mdb_walker_t walkers[] = {
622 { "uhci_td", "walk list of UHCI TD structures",
623 uhci_td_walk_init, uhci_td_walk_step, NULL,
624 NULL },
625 { "uhci_qh", "walk list of UHCI QH structures",
626 uhci_qh_walk_init, uhci_qh_walk_step, NULL,
627 NULL },
628 { NULL }
629 };
630
631 static const mdb_modinfo_t modinfo = {
632 MDB_API_VERSION, dcmds, walkers
633 };
634
635
636 const mdb_modinfo_t *
637 _mdb_init(void)
638 {
639 return (&modinfo);
640 }