xref: /titanic_51/usr/src/cmd/mdb/common/modules/uhci/uhci.c (revision dd51520e127b452179a2ce4ea3bd8dee949f9afe)
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 }
641