xref: /illumos-gate/usr/src/uts/common/io/usb/usba/usbai.c (revision 6f6c7d2b)
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 (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 
26 /*
27  * USBA: Solaris USB Architecture support
28  *
29  * all functions exposed to client drivers  have prefix usb_ while all USBA
30  * internal functions or functions exposed to HCD or hubd only have prefix
31  * usba_
32  *
33  * this file contains initializations, logging/tracing support and PM
34  * support
35  */
36 #define	USBA_FRAMEWORK
37 #include <sys/varargs.h>
38 #include <sys/strsun.h>
39 #include <sys/usb/usba/usba_impl.h>
40 #include <sys/usb/usba/hcdi_impl.h>
41 #include <sys/usb/usba/usba10.h>
42 
43 /*
44  * print buffer protected by mutex for debug stuff. the mutex also
45  * ensures serializing debug messages
46  */
47 static kmutex_t	usba_print_mutex;
48 static char usba_print_buf[USBA_PRINT_BUF_LEN];
49 kmutex_t usbai_mutex;
50 
51 /*
52  * debug stuff
53  */
54 usb_log_handle_t	usbai_log_handle;
55 uint_t			usbai_errlevel = USB_LOG_L4;
56 uint_t			usbai_errmask = (uint_t)-1;
57 
58 #define	USBA_DEBUG_SIZE_EXTRA_ALLOC	8
59 #ifdef	DEBUG
60 #define	USBA_DEBUG_BUF_SIZE \
61 			(0x40000 -  USBA_DEBUG_SIZE_EXTRA_ALLOC)
62 #else
63 #define	USBA_DEBUG_BUF_SIZE \
64 			(0x4000 -  USBA_DEBUG_SIZE_EXTRA_ALLOC)
65 #endif	/* DEBUG */
66 
67 #define	USBA_POWER_STR_SIZE		40
68 
69 int	usba_suppress_dprintf;		/* Suppress debug printing */
70 int	usba_clear_debug_buf_flag;	/* clear debug buf */
71 int	usba_buffer_dprintf = 1;	/* Use a debug print buffer */
72 int	usba_timestamp_dprintf = 0;	/* get time stamps in trace */
73 int	usba_debug_buf_size = USBA_DEBUG_BUF_SIZE;	/* Size of debug buf */
74 int	usba_debug_chatty;		/* L1 msg on console */
75 
76 static char *usba_debug_buf = NULL;	/* The debug buf */
77 static char *usba_buf_sptr, *usba_buf_eptr;
78 static hrtime_t usba_last_timestamp;	/* last time stamp in trace */
79 
80 /* USBA framework initializations */
81 void
82 usba_usbai_initialization()
83 {
84 	usbai_log_handle = usb_alloc_log_hdl(NULL, "usbai", &usbai_errlevel,
85 	    &usbai_errmask, NULL, 0);
86 
87 	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
88 	    "usba_usbai_initialization");
89 
90 	mutex_init(&usba_print_mutex, NULL, MUTEX_DRIVER, NULL);
91 	mutex_init(&usbai_mutex, NULL, MUTEX_DRIVER, NULL);
92 }
93 
94 
95 /* USBA framework destroys */
96 void
97 usba_usbai_destroy()
98 {
99 	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
100 	    "usba_usbai_destroy");
101 
102 	mutex_destroy(&usba_print_mutex);
103 	mutex_destroy(&usbai_mutex);
104 	if (usba_debug_buf) {
105 		kmem_free(usba_debug_buf,
106 		    usba_debug_buf_size + USBA_DEBUG_SIZE_EXTRA_ALLOC);
107 	}
108 
109 	usb_free_log_hdl(usbai_log_handle);
110 }
111 
112 
113 /*
114  * debug, log, and console message handling
115  */
116 usb_log_handle_t
117 usb_alloc_log_hdl(dev_info_t *dip, char *name,
118 	uint_t *errlevel, uint_t *mask, uint_t *instance_filter,
119 	usb_flags_t flags)
120 {
121 	usba_log_handle_impl_t	*hdl;
122 
123 	USBA_CHECK_CONTEXT();
124 	hdl = kmem_zalloc(sizeof (*hdl), KM_SLEEP);
125 
126 	hdl->lh_dip = dip;
127 	if (dip && (name == NULL)) {
128 		hdl->lh_name = (char *)ddi_driver_name(dip);
129 	} else {
130 		hdl->lh_name = name;
131 	}
132 	hdl->lh_errlevel = errlevel;
133 	hdl->lh_mask = mask;
134 	hdl->lh_instance_filter = instance_filter;
135 	hdl->lh_flags = flags;
136 
137 #ifdef __lock_lint
138 	(void) usb_alloc_log_handle(dip, name, errlevel, mask,
139 	    instance_filter, 0, flags);
140 	usb_free_log_handle(NULL);
141 #endif
142 
143 	return ((usb_log_handle_t)hdl);
144 }
145 
146 
147 /*ARGSUSED*/
148 usb_log_handle_t
149 usb_alloc_log_handle(dev_info_t *dip, char *name,
150 	uint_t *errlevel, uint_t *mask, uint_t *instance_filter,
151 	uint_t reserved, usb_flags_t flags)
152 {
153 	return (usb_alloc_log_hdl(dip, name, errlevel, mask,
154 	    instance_filter, flags));
155 }
156 
157 void
158 usb_free_log_handle(usb_log_handle_t handle)
159 {
160 	if (handle) {
161 		kmem_free(handle, sizeof (usba_log_handle_impl_t));
162 	}
163 }
164 
165 void
166 usb_free_log_hdl(usb_log_handle_t handle)
167 {
168 	if (handle) {
169 		kmem_free(handle, sizeof (usba_log_handle_impl_t));
170 	}
171 }
172 
173 
174 static void
175 usba_clear_dprint_buf()
176 {
177 	if (usba_debug_buf) {
178 		usba_buf_sptr = usba_debug_buf;
179 		usba_buf_eptr = usba_debug_buf + usba_debug_buf_size;
180 		bzero(usba_debug_buf, usba_debug_buf_size +
181 		    USBA_DEBUG_SIZE_EXTRA_ALLOC);
182 	}
183 }
184 
185 
186 #ifdef DEBUG
187 char *
188 usba_dbuf_tail(uint_t lines)
189 {
190 	int	count;
191 	char	*r = NULL;
192 
193 	mutex_enter(&usba_print_mutex);
194 	if (usba_debug_buf) {
195 		count = 0;
196 		r = usba_buf_sptr;
197 		while ((count < lines) && (r > usba_debug_buf)) {
198 			if (*r == '\n') {
199 				count++;
200 			}
201 			r--;
202 		}
203 	}
204 	mutex_exit(&usba_print_mutex);
205 
206 	return (r);
207 }
208 #endif	/* DEBUG */
209 
210 
211 static void usb_vprintf(dev_info_t *, int, char *, char *, va_list)
212 	__KVPRINTFLIKE(4);
213 
214 static void
215 usb_vprintf(dev_info_t *dip, int level, char *label, char *fmt, va_list ap)
216 {
217 	size_t len;
218 	int instance;
219 	char driver_name[USBA_DRVNAME_LEN];
220 	char *msg_ptr;
221 
222 	if (usba_suppress_dprintf) {
223 
224 		return;
225 	}
226 
227 	*driver_name = '\0';
228 	mutex_enter(&usba_print_mutex);
229 
230 	/*
231 	 * Check if we have a valid buf size?
232 	 * Suppress logging to usb_buffer if so.
233 	 */
234 	if (usba_debug_buf_size <= 0) {
235 
236 		usba_buffer_dprintf = 0;
237 	}
238 
239 	/*
240 	 * if there is label and dip, use <driver name><instance>:
241 	 * otherwise just use the label
242 	 */
243 	if (dip) {
244 		instance = ddi_get_instance(dip);
245 		(void) snprintf(driver_name, USBA_DRVNAME_LEN,
246 		    "%s%d", ddi_driver_name(dip), instance);
247 	}
248 
249 	if (label == (char *)NULL) {
250 		len = snprintf(usba_print_buf, USBA_PRINT_BUF_LEN, "\t");
251 	} else if (usba_timestamp_dprintf) {
252 		hrtime_t t = gethrtime();
253 		hrtime_t elapsed = (t - usba_last_timestamp)/1000;
254 		usba_last_timestamp = t;
255 
256 		if (dip) {
257 
258 			len = snprintf(usba_print_buf, USBA_PRINT_BUF_LEN,
259 			    "+%lld->%p: %s%d: ", elapsed,
260 			    (void *)curthread, label, instance);
261 		} else {
262 			len = snprintf(usba_print_buf, USBA_PRINT_BUF_LEN,
263 			    "+%lld->%p: %s: ", elapsed,
264 			    (void *)curthread, label);
265 		}
266 	} else {
267 		if (dip) {
268 			len = snprintf(usba_print_buf, USBA_PRINT_BUF_LEN,
269 			    "%s%d:\t", label, instance);
270 		} else {
271 			len = snprintf(usba_print_buf, USBA_PRINT_BUF_LEN,
272 			    "%s:\t", label);
273 		}
274 	}
275 
276 
277 	msg_ptr = usba_print_buf + len;
278 	(void) vsnprintf(msg_ptr, USBA_PRINT_BUF_LEN - len - 2, fmt, ap);
279 
280 	len = min(strlen(usba_print_buf), USBA_PRINT_BUF_LEN - 2);
281 	usba_print_buf[len++] = '\n';
282 	usba_print_buf[len] = '\0';
283 
284 	/*
285 	 * stuff the message in the debug buf
286 	 */
287 	if (usba_buffer_dprintf) {
288 		if (usba_debug_buf == NULL) {
289 			usba_debug_buf = kmem_alloc(
290 			    usba_debug_buf_size + USBA_DEBUG_SIZE_EXTRA_ALLOC,
291 			    KM_SLEEP);
292 			usba_clear_dprint_buf();
293 		} else if (usba_clear_debug_buf_flag) {
294 			usba_clear_dprint_buf();
295 			usba_clear_debug_buf_flag = 0;
296 		}
297 
298 		/*
299 		 * overwrite >>>> that might be over the end of the
300 		 * the buffer
301 		 */
302 		*(usba_debug_buf + usba_debug_buf_size) = '\0';
303 
304 		if ((usba_buf_sptr + len) > usba_buf_eptr) {
305 			size_t left = _PTRDIFF(usba_buf_eptr, usba_buf_sptr);
306 
307 			bcopy(usba_print_buf, usba_buf_sptr, left);
308 			bcopy((caddr_t)usba_print_buf + left,
309 			    usba_debug_buf, len - left);
310 			usba_buf_sptr = usba_debug_buf + len - left;
311 		} else {
312 			bcopy(usba_print_buf, usba_buf_sptr, len);
313 			usba_buf_sptr += len;
314 		}
315 		/* add marker */
316 		(void) sprintf(usba_buf_sptr, ">>>>");
317 	}
318 
319 	/*
320 	 * L4-L2 message may go to the log buf if not logged in usba_debug_buf
321 	 * L1 messages will go to the log buf in non-debug kernels and
322 	 * to console and log buf in debug kernels if usba_debug_chatty
323 	 * has been set
324 	 * L0 messages are warnings and will go to console and log buf and
325 	 * include the pathname, if available
326 	 */
327 
328 	switch (level) {
329 	case USB_LOG_L4:
330 	case USB_LOG_L3:
331 	case USB_LOG_L2:
332 		if (!usba_buffer_dprintf) {
333 			cmn_err(CE_CONT, "^%s", usba_print_buf);
334 		}
335 		break;
336 	case USB_LOG_L1:
337 		if (dip) {
338 			char *pathname = kmem_alloc(MAXPATHLEN, KM_NOSLEEP);
339 			if (pathname) {
340 				cmn_err(CE_CONT,
341 				    usba_debug_chatty ?
342 				    "%s (%s): %s" : "?%s (%s): %s",
343 				    ddi_pathname(dip, pathname),
344 				    driver_name, msg_ptr);
345 				kmem_free(pathname, MAXPATHLEN);
346 			} else {
347 				cmn_err(CE_CONT,
348 				    usba_debug_chatty ?
349 				    "%s" : "?%s", usba_print_buf);
350 			}
351 		} else {
352 			cmn_err(CE_CONT,
353 			    usba_debug_chatty ? "%s" : "?%s",
354 			    usba_print_buf);
355 		}
356 		break;
357 	case USB_LOG_L0:
358 		/* Strip the "\n" added earlier */
359 		if (usba_print_buf[len - 1] == '\n') {
360 			usba_print_buf[len - 1] = '\0';
361 		}
362 		if (msg_ptr[len - 1] == '\n') {
363 			msg_ptr[len - 1] = '\0';
364 		}
365 		if (dip) {
366 			char *pathname = kmem_alloc(MAXPATHLEN, KM_NOSLEEP);
367 			if (pathname) {
368 				cmn_err(CE_WARN, "%s (%s): %s",
369 				    ddi_pathname(dip, pathname),
370 				    driver_name, msg_ptr);
371 				kmem_free(pathname, MAXPATHLEN);
372 			} else {
373 				cmn_err(CE_WARN, usba_print_buf);
374 			}
375 		} else {
376 			cmn_err(CE_WARN, usba_print_buf);
377 		}
378 		break;
379 	}
380 
381 	mutex_exit(&usba_print_mutex);
382 }
383 
384 int
385 usba_vlog(usb_log_handle_t, uint_t, uint_t, char *, va_list)
386 	__KVPRINTFLIKE(4);
387 
388 /* When usba10_calls.c goes away, this function can be made static again. */
389 int
390 usba_vlog(usb_log_handle_t handle, uint_t level, uint_t mask,
391     char *fmt, va_list ap)
392 {
393 	usba_log_handle_impl_t *hdl = (usba_log_handle_impl_t *)handle;
394 	char *label;
395 	uint_t hdl_errlevel, hdl_mask, hdl_instance_filter;
396 
397 	/* if there is no handle, use usba as label */
398 	if (hdl == NULL) {
399 		usb_vprintf(NULL, level, "usba", fmt, ap);
400 
401 		return (USB_SUCCESS);
402 	}
403 
404 	/* look up the filters and set defaults */
405 	if (hdl->lh_errlevel) {
406 		hdl_errlevel = *(hdl->lh_errlevel);
407 	} else {
408 		hdl_errlevel = 0;
409 	}
410 
411 	if (hdl->lh_mask) {
412 		hdl_mask = *(hdl->lh_mask);
413 	} else {
414 		hdl_mask = (uint_t)-1;
415 	}
416 
417 	if (hdl->lh_instance_filter) {
418 		hdl_instance_filter = *(hdl->lh_instance_filter);
419 	} else {
420 		hdl_instance_filter = (uint_t)-1;
421 	}
422 
423 	/* if threshold is lower or mask doesn't match, we are done */
424 	if ((level > hdl_errlevel) || ((mask & hdl_mask) == 0)) {
425 
426 		return (USB_FAILURE);
427 	}
428 
429 	/*
430 	 * if we have a dip, and it is not a warning, check
431 	 * the instance number
432 	 */
433 	if (hdl->lh_dip && (level > USB_LOG_L0)) {
434 		if ((hdl_instance_filter != (uint_t)-1) &&
435 		    (ddi_get_instance(hdl->lh_dip) != hdl_instance_filter)) {
436 
437 			return (USB_FAILURE);
438 		}
439 	}
440 
441 	label = hdl->lh_name;
442 
443 	usb_vprintf(hdl->lh_dip, level, label, fmt, ap);
444 
445 	return (USB_SUCCESS);
446 }
447 
448 
449 void
450 usb_dprintf4(uint_t mask, usb_log_handle_t handle, char *fmt, ...)
451 {
452 	va_list ap;
453 
454 	va_start(ap, fmt);
455 	(void) usba_vlog(handle, USB_LOG_L4, mask, fmt, ap);
456 	va_end(ap);
457 }
458 
459 
460 void
461 usb_dprintf3(uint_t mask, usb_log_handle_t handle, char *fmt, ...)
462 {
463 	va_list ap;
464 
465 	va_start(ap, fmt);
466 	(void) usba_vlog(handle, USB_LOG_L3, mask, fmt, ap);
467 	va_end(ap);
468 }
469 
470 
471 void
472 usb_dprintf2(uint_t mask, usb_log_handle_t handle, char *fmt, ...)
473 {
474 	va_list ap;
475 
476 	va_start(ap, fmt);
477 	(void) usba_vlog(handle, USB_LOG_L2, mask, fmt, ap);
478 	va_end(ap);
479 }
480 
481 
482 void
483 usb_dprintf1(uint_t mask, usb_log_handle_t handle, char *fmt, ...)
484 {
485 	va_list ap;
486 
487 	va_start(ap, fmt);
488 	(void) usba_vlog(handle, USB_LOG_L1, mask, fmt, ap);
489 	va_end(ap);
490 }
491 
492 
493 void
494 usb_dprintf0(uint_t mask, usb_log_handle_t handle, char *fmt, ...)
495 {
496 	va_list ap;
497 
498 	va_start(ap, fmt);
499 	(void) usba_vlog(handle, USB_LOG_L0, mask, fmt, ap);
500 	va_end(ap);
501 }
502 
503 
504 int
505 usb_log(usb_log_handle_t handle, uint_t level, uint_t mask, char *fmt, ...)
506 {
507 	va_list	ap;
508 	int rval;
509 
510 	va_start(ap, fmt);
511 	rval = usba_vlog(handle, level, mask, fmt, ap);
512 	va_end(ap);
513 
514 	return (rval);
515 }
516 
517 
518 /*
519  * Provide a default configuration power descriptor
520  */
521 usba_cfg_pwr_descr_t	default_cfg_power = {
522 	18,	/* bLength */
523 	USBA_DESCR_TYPE_CFG_PWR_1_1, /* bDescriptorType */
524 	0,	/* SelfPowerConsumedD0_l */
525 	0,	/* SelfPowerConsumedD0_h */
526 	0,	/* bPowerSummaryId */
527 	0,	/* bBusPowerSavingD1 */
528 	0,	/* bSelfPowerSavingD1 */
529 	0,	/* bBusPowerSavingD2 */
530 	0,	/* bSelfPowerSavingD2 */
531 	100,	/* bBusPowerSavingD3 */
532 	100,	/* bSelfPowerSavingD3 */
533 	0,	/* TransitionTimeFromD1 */
534 	0,	/* TransitionTimeFromD2 */
535 	10,	/* TransitionTimeFromD3 1 Second */
536 };
537 
538 
539 /*
540  * Provide a default interface power descriptor
541  */
542 usba_if_pwr_descr_t default_if_power = {
543 	15,	/* bLength */
544 	USBA_DESCR_TYPE_IF_PWR_1_1, /* bDescriptorType */
545 	8,	/* bmCapabilitiesFlags */
546 	0,	/* bBusPowerSavingD1 */
547 	0,	/* bSelfPowerSavingD1 */
548 	0,	/* bBusPowerSavingD2 */
549 	0,	/* bSelfPowerSavingD2 */
550 	100,	/* bBusPowerSavingD3 */
551 	100,	/* bSelfPowerSavingD3 */
552 	0,	/* TransitionTimeFromD1 */
553 	0,	/* TransitionTimeFromD2 */
554 	10,	/* TransitionTimeFromD3 1 Second */
555 };
556 
557 
558 static void
559 usba_async_req_raise_power(void *arg)
560 {
561 	usba_pm_req_t *pmrq = (usba_pm_req_t *)arg;
562 	int rval;
563 
564 	/*
565 	 * To eliminate race condition between the call to power entry
566 	 * point and our call to raise power level, we first mark the
567 	 * component busy and later idle
568 	 */
569 	(void) pm_busy_component(pmrq->dip, pmrq->comp);
570 	rval = pm_raise_power(pmrq->dip, pmrq->comp, pmrq->level);
571 	(void) pm_idle_component(pmrq->dip, pmrq->comp);
572 	pmrq->cb(pmrq->arg, rval);
573 
574 	/* We are done with pmrq. Free it now */
575 	kmem_free(pmrq, sizeof (usba_pm_req_t));
576 }
577 
578 
579 /* usb function to perform async pm_request_power_change */
580 int
581 usb_req_raise_power(dev_info_t *dip, int comp, int level,
582 	void (*callback)(void *, int), void *arg, usb_flags_t flags)
583 {
584 	usba_pm_req_t *pmrq;
585 
586 	if (flags & USB_FLAGS_SLEEP) {
587 
588 		return (pm_raise_power(dip, comp, level));
589 	}
590 
591 	if ((pmrq = kmem_alloc(sizeof (usba_pm_req_t), KM_NOSLEEP)) ==
592 	    NULL) {
593 
594 		return (USB_FAILURE);
595 	}
596 
597 	pmrq->dip = dip;
598 	pmrq->comp = comp;
599 	pmrq->level = level;
600 	pmrq->cb = callback;
601 	pmrq->arg = arg;
602 	pmrq->flags = flags;
603 
604 	if (usb_async_req(dip, usba_async_req_raise_power,
605 	    (void *)pmrq, USB_FLAGS_NOSLEEP | USB_FLAGS_NOQUEUE) !=
606 	    USB_SUCCESS) {
607 		kmem_free(pmrq, sizeof (usba_pm_req_t));
608 
609 		return (USB_FAILURE);
610 	}
611 
612 	return (USB_SUCCESS);
613 }
614 
615 
616 static void
617 usba_async_req_lower_power(void *arg)
618 {
619 	usba_pm_req_t *pmrq = (usba_pm_req_t *)arg;
620 	int rval;
621 
622 	/*
623 	 * To eliminate race condition between the call to power entry
624 	 * point and our call to lower power level, we call idle component
625 	 * to push ahead the PM timestamp
626 	 */
627 	(void) pm_idle_component(pmrq->dip, pmrq->comp);
628 	rval = pm_lower_power(pmrq->dip, pmrq->comp, pmrq->level);
629 	pmrq->cb(pmrq->arg, rval);
630 }
631 
632 
633 /* usb function to perform async pm_request_power_change */
634 int
635 usb_req_lower_power(dev_info_t *dip, int comp, int level,
636 	void (*callback)(void *, int), void *arg, usb_flags_t flags)
637 {
638 	usba_pm_req_t *pmrq;
639 
640 	if (flags & USB_FLAGS_SLEEP) {
641 
642 		return (pm_lower_power(dip, comp, level));
643 	}
644 
645 	if ((pmrq = kmem_alloc(sizeof (usba_pm_req_t), KM_NOSLEEP)) ==
646 	    NULL) {
647 
648 		return (USB_FAILURE);
649 	}
650 
651 	pmrq->dip = dip;
652 	pmrq->comp = comp;
653 	pmrq->level = level;
654 	pmrq->cb = callback;
655 	pmrq->arg = arg;
656 	pmrq->flags = flags;
657 
658 	if (usb_async_req(dip, usba_async_req_lower_power,
659 	    (void *)pmrq, USB_FLAGS_NOSLEEP | USB_FLAGS_NOQUEUE) !=
660 	    USB_SUCCESS) {
661 		kmem_free(pmrq, sizeof (usba_pm_req_t));
662 
663 		return (USB_FAILURE);
664 	}
665 
666 	return (USB_SUCCESS);
667 }
668 
669 
670 /* function to see if pm is enabled for this device */
671 /*ARGSUSED*/
672 int
673 usb_is_pm_enabled(dev_info_t *dip)
674 {
675 	/*
676 	 * At this point we should assume that all devices
677 	 * are capable of supporting PM
678 	 */
679 	return (USB_SUCCESS);
680 }
681 
682 
683 /*
684  * usba_handle_device_remote_wakeup:
685  *	internal function to enable/disable remote wakeup in the device
686  *	or interface
687  */
688 static int
689 usba_handle_device_remote_wakeup(dev_info_t *dip, int cmd)
690 {
691 	int		rval;
692 	uint8_t 	bmRequest = USB_DEV_REQ_HOST_TO_DEV;
693 	uchar_t		bRequest;
694 	uint16_t	wIndex = 0;
695 	usb_cr_t	completion_reason = 0;
696 	usb_cb_flags_t	cb_flags;
697 	usb_pipe_handle_t ph;
698 
699 	USB_DPRINTF_L4(DPRINT_MASK_USBA, usbai_log_handle,
700 	    "usba_handle_device_remote_wakeup: dip = 0x%p", (void *)dip);
701 
702 	USBA_CHECK_CONTEXT();
703 
704 	/* get the default pipe */
705 	ph = usba_get_dflt_pipe_handle(dip);
706 
707 	/* do we own the device? */
708 	if (usb_owns_device(dip)) {
709 		bmRequest |= USB_DEV_REQ_RCPT_DEV;
710 	} else {
711 		bmRequest |= USB_DEV_REQ_RCPT_IF;
712 		wIndex = usba_get_ifno(dip);
713 	}
714 	bRequest = ((cmd == USB_REMOTE_WAKEUP_ENABLE) ? USB_REQ_SET_FEATURE :
715 	    USB_REQ_CLEAR_FEATURE);
716 
717 	if ((rval = usb_pipe_sync_ctrl_xfer(dip, ph,
718 	    bmRequest,			/* bmRequest */
719 	    bRequest,			/* bRequest */
720 	    USB_DEV_REMOTE_WAKEUP,	/* wValue */
721 	    wIndex,			/* wIndex */
722 	    0,				/* wLength */
723 	    NULL, 0,
724 	    &completion_reason,
725 	    &cb_flags, USB_FLAGS_SLEEP)) != USB_SUCCESS) {
726 		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
727 		    "Set/ClearFeature (RemoteWakep) failed: "
728 		    "rval = %d, cmd = %d, cr = 0x%x cb = 0x%x",
729 		    rval, cmd, completion_reason, cb_flags);
730 	}
731 
732 	return (rval);
733 }
734 
735 
736 void
737 usb_enable_parent_notification(dev_info_t *dip)
738 {
739 	USBA_CHECK_CONTEXT();
740 	(void) ndi_prop_create_boolean(DDI_DEV_T_NONE, dip,
741 	    "pm-want-child-notification?");
742 }
743 
744 
745 /*
746  * usb_handle_remote_wakeup:
747  *	check if device supports remote wakeup and, if so, enable/disable
748  *	remote wake up in the device depending upon the command
749  */
750 int
751 usb_handle_remote_wakeup(dev_info_t *dip, int cmd)
752 {
753 	usb_cfg_descr_t	cfg_descr;
754 	uchar_t 	*usb_cfg;	/* buf for config descriptor */
755 	size_t		cfg_length;
756 	int		rval;
757 
758 	USBA_CHECK_CONTEXT();
759 
760 	/* Obtain the raw configuration descriptor */
761 	usb_cfg = usb_get_raw_cfg_data(dip, &cfg_length);
762 
763 	/* get configuration descriptor, must succeed */
764 	rval = usb_parse_cfg_descr(usb_cfg, cfg_length,
765 	    &cfg_descr, USB_CFG_DESCR_SIZE);
766 	ASSERT(rval == USB_CFG_DESCR_SIZE);
767 
768 	/*
769 	 * If the device supports remote wakeup, and PM is enabled,
770 	 * we enable remote wakeup in the device
771 	 */
772 	if ((usb_is_pm_enabled(dip) == USB_SUCCESS) &&
773 	    (cfg_descr.bmAttributes & USB_CFG_ATTR_REMOTE_WAKEUP)) {
774 
775 		rval = usba_handle_device_remote_wakeup(dip, cmd);
776 	} else {
777 		rval = USB_FAILURE;
778 	}
779 
780 	return (rval);
781 }
782 
783 
784 /*
785  * usb_create_pm_components:
786  *	map descriptor into  pm properties
787  */
788 int
789 usb_create_pm_components(dev_info_t *dip, uint_t *pwr_states)
790 {
791 	uchar_t 		*usb_cfg;	/* buf for config descriptor */
792 	usb_cfg_descr_t		cfg_descr;
793 	size_t			cfg_length;
794 	usba_cfg_pwr_descr_t	confpwr_descr;
795 	usba_if_pwr_descr_t	ifpwr_descr;
796 	uint8_t 		cfg_attrib;
797 	int			i, lvl, rval;
798 	int			n_prop = 0;
799 	uint8_t 		*ptr;
800 	char			*drvname;
801 	char			str[USBA_POWER_STR_SIZE];
802 	char			*pm_comp[USBA_N_PMCOMP];
803 
804 	USBA_CHECK_CONTEXT();
805 
806 	if (usb_is_pm_enabled(dip) != USB_SUCCESS) {
807 
808 		return (USB_FAILURE);
809 	}
810 
811 	/* Obtain the raw configuration descriptor */
812 	usb_cfg = usb_get_raw_cfg_data(dip, &cfg_length);
813 
814 	/* get configuration descriptor, must succceed */
815 	rval = usb_parse_cfg_descr(usb_cfg, cfg_length,
816 	    &cfg_descr, USB_CFG_DESCR_SIZE);
817 	ASSERT(rval == USB_CFG_DESCR_SIZE);
818 
819 	cfg_attrib = cfg_descr.bmAttributes;
820 	*pwr_states = 0;
821 
822 	/*
823 	 * Now start creating the pm-components strings
824 	 */
825 	drvname = (char *)ddi_driver_name(dip);
826 	(void) snprintf(str, USBA_POWER_STR_SIZE, "NAME= %s%d Power",
827 	    drvname, ddi_get_instance(dip));
828 
829 	pm_comp[n_prop] = kmem_zalloc(strlen(str) + 1, KM_SLEEP);
830 	(void) strcpy(pm_comp[n_prop++], str);
831 
832 	/*
833 	 * if the device is bus powered we look at the bBusPowerSavingDx
834 	 * fields else we look at bSelfPowerSavingDx fields.
835 	 * OS and USB power states are numerically reversed,
836 	 *
837 	 * Here is the mapping :-
838 	 *	OS State	USB State
839 	 *	0		D3	(minimal or no power)
840 	 *	1		D2
841 	 *	2		D1
842 	 *	3		D0	(Full power)
843 	 *
844 	 * if we own the whole device, we look at the config pwr descr
845 	 * else at the interface pwr descr.
846 	 */
847 	if (usb_owns_device(dip)) {
848 		/* Parse the configuration power descriptor */
849 		rval = usba_parse_cfg_pwr_descr(usb_cfg, cfg_length,
850 		    &confpwr_descr, USBA_CFG_PWR_DESCR_SIZE);
851 
852 		if (rval != USBA_CFG_PWR_DESCR_SIZE) {
853 			USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
854 			    "usb_create_pm_components: "
855 			    "usb_parse_cfg_pwr_descr returns length of %d, "
856 			    "expecting %d", rval, USBA_CFG_PWR_DESCR_SIZE);
857 
858 			return (USB_FAILURE);
859 		}
860 
861 		if (cfg_attrib & USB_CFG_ATTR_SELFPWR) {
862 			ptr = &confpwr_descr.bSelfPowerSavingD3;
863 		} else {
864 			ptr = &confpwr_descr.bBusPowerSavingD3;
865 		}
866 	} else {
867 		/* Parse the interface power descriptor */
868 		rval = usba_parse_if_pwr_descr(usb_cfg,
869 		    cfg_length,
870 		    usba_get_ifno(dip),	/* interface index */
871 		    0,			/* XXXX alt interface index */
872 		    &ifpwr_descr,
873 		    USBA_IF_PWR_DESCR_SIZE);
874 
875 		if (rval != USBA_IF_PWR_DESCR_SIZE) {
876 			USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
877 			    "usb_create_pm_components: "
878 			    "usb_parse_if_pwr_descr "
879 			    "returns length of %d, "
880 			    "expecting %d", rval, USBA_CFG_PWR_DESCR_SIZE);
881 
882 			return (USB_FAILURE);
883 		}
884 
885 		if (cfg_attrib & USB_CFG_ATTR_SELFPWR) {
886 			ptr =  &ifpwr_descr.bSelfPowerSavingD3;
887 		} else {
888 			ptr =  &ifpwr_descr.bBusPowerSavingD3;
889 		}
890 	}
891 
892 	/* walk thru levels and create prop level=name strings */
893 	for (lvl = USB_DEV_OS_PWR_0; lvl <= USB_DEV_OS_PWR_3; lvl++) {
894 		if (*ptr || (lvl == USB_DEV_OS_PWR_3)) {
895 			(void) snprintf(str, USBA_POWER_STR_SIZE,
896 			    "%d=USB D%d State",
897 			    lvl, USB_DEV_OS_PWR2USB_PWR(lvl));
898 			pm_comp[n_prop] = kmem_zalloc(strlen(str) + 1,
899 			    KM_SLEEP);
900 			(void) strcpy(pm_comp[n_prop++], str);
901 
902 			*pwr_states |= USB_DEV_PWRMASK(lvl);
903 		}
904 
905 		ptr -= 2; /* skip to the next power state */
906 	}
907 
908 	USB_DPRINTF_L3(DPRINT_MASK_USBAI, usbai_log_handle,
909 	    "usb_create_pm_components: pwr_states: %x", *pwr_states);
910 
911 	/* now create the actual components */
912 	rval = ddi_prop_update_string_array(DDI_DEV_T_NONE, dip,
913 	    "pm-components", pm_comp, n_prop);
914 	if (rval == DDI_PROP_SUCCESS) {
915 		rval = USB_SUCCESS;
916 	} else {
917 		rval = USB_FAILURE;
918 	}
919 
920 	/* display & delete properties */
921 	USB_DPRINTF_L3(DPRINT_MASK_USBAI, usbai_log_handle,
922 	    "usb_create_pm_components: The properties are:");
923 	for (i = 0; i < n_prop; i++) {
924 		USB_DPRINTF_L3(DPRINT_MASK_USBAI, usbai_log_handle,
925 		    "\t%s", pm_comp[i]);
926 		kmem_free(pm_comp[i], strlen(pm_comp[i]) + 1);
927 	}
928 
929 	return (rval);
930 }
931 
932 
933 /*
934  * Generic Functions to set the power level of any usb device
935  *
936  * Since OS and USB power states are numerically reverse,
937  * Here is the mapping :-
938  *	OS State	USB State
939  *	0		D3	(minimal or no power)
940  *	1		D2
941  *	2		D1
942  *	3		D0	(Full power)
943  */
944 
945 /* set device power level to 0 (full power) */
946 /*ARGSUSED*/
947 int
948 usb_set_device_pwrlvl0(dev_info_t *dip)
949 {
950 	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
951 	    "usb_set_device_pwrlvl0 : Not Yet Implemented");
952 
953 	return (USB_SUCCESS);
954 }
955 
956 
957 /* set device power level to 1	*/
958 /*ARGSUSED*/
959 int
960 usb_set_device_pwrlvl1(dev_info_t *dip)
961 {
962 	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
963 	    "usb_set_device_pwrlvl1 : Not Yet Implemented");
964 
965 	return (USB_SUCCESS);
966 }
967 
968 
969 /* set device power level to 2	*/
970 /*ARGSUSED*/
971 int
972 usb_set_device_pwrlvl2(dev_info_t *dip)
973 {
974 	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
975 	    "usb_set_device_pwrlvl2 : Not Yet Implemented");
976 
977 	return (USB_SUCCESS);
978 }
979 
980 
981 /* set device power level to 3	*/
982 /*ARGSUSED*/
983 int
984 usb_set_device_pwrlvl3(dev_info_t *dip)
985 {
986 	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
987 	    "usb_set_device_pwrlvl3 : Not Yet Implemented");
988 
989 	return (USB_SUCCESS);
990 }
991 
992 
993 /*
994  * USB event management
995  */
996 typedef void (*peh_t)(dev_info_t *, ddi_eventcookie_t, void *, void *);
997 
998 
999 /*
1000  * usb_register_hotplug_cbs:
1001  *	Register to get callbacks for hotplug events
1002  */
1003 /*ARGSUSED*/
1004 int
1005 usb_register_hotplug_cbs(dev_info_t *dip,
1006     int (*disconnect_event_handler)(dev_info_t *),
1007     int (*reconnect_event_handler)(dev_info_t *))
1008 {
1009 	usba_device_t		*usba_device;
1010 	usba_evdata_t		*evdata;
1011 
1012 	if ((dip == NULL) || (disconnect_event_handler == NULL) ||
1013 	    (reconnect_event_handler == NULL)) {
1014 		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
1015 		    "usb_register_hotplug_cbs: Bad argument(s)");
1016 
1017 		return (USB_FAILURE);
1018 	}
1019 
1020 	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
1021 	    "usb_register_hotplug_cbs: entry");
1022 
1023 	/*
1024 	 * The event list searches by ddi_get_eventcookie calls below, go
1025 	 * through hubd and so do not apply to host controllers.
1026 	 */
1027 	ASSERT(!usba_is_root_hub(dip));
1028 
1029 	usba_device = usba_get_usba_device(dip);
1030 	evdata = usba_get_evdata(dip);
1031 
1032 	if (usba_device->rm_cookie == NULL) {
1033 		if (ddi_get_eventcookie(dip, DDI_DEVI_REMOVE_EVENT,
1034 		    &usba_device->rm_cookie) != DDI_SUCCESS) {
1035 			USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
1036 			    "usb_register_hotplug_cbs: get rm cookie failed");
1037 
1038 			goto fail;
1039 		}
1040 	}
1041 	if (ddi_add_event_handler(dip, usba_device->rm_cookie,
1042 	    (peh_t)disconnect_event_handler,
1043 	    NULL, &evdata->ev_rm_cb_id) != DDI_SUCCESS) {
1044 		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
1045 		    "usb_register_hotplug_cbs: add disconnect handler failed");
1046 
1047 		goto fail;
1048 	}
1049 
1050 	if (usba_device->ins_cookie == NULL) {
1051 		if (ddi_get_eventcookie(dip, DDI_DEVI_INSERT_EVENT,
1052 		    &usba_device->ins_cookie) != DDI_SUCCESS) {
1053 			USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
1054 			    "usb_register_hotplug_cbs: get ins cookie failed");
1055 
1056 			goto fail;
1057 		}
1058 	}
1059 	if (ddi_add_event_handler(dip, usba_device->ins_cookie,
1060 	    (peh_t)reconnect_event_handler,
1061 	    NULL, &evdata->ev_ins_cb_id) != DDI_SUCCESS) {
1062 		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
1063 		    "usb_register_hotplug_cbs: add reconnect handler failed");
1064 
1065 		goto fail;
1066 	}
1067 
1068 	mutex_enter(&usba_device->usb_mutex);
1069 	usba_device->usb_client_flags[usba_get_ifno(dip)] |=
1070 	    USBA_CLIENT_FLAG_EV_CBS;
1071 	usba_device->usb_client_ev_cb_list->dip = dip;
1072 	mutex_exit(&usba_device->usb_mutex);
1073 
1074 	return (USB_SUCCESS);
1075 
1076 fail:
1077 	usb_unregister_hotplug_cbs(dip);
1078 
1079 	return (USB_FAILURE);
1080 
1081 }
1082 
1083 
1084 /*
1085  * usb_unregister_hotplug_cbs:
1086  *	Unregister hotplug callbacks
1087  */
1088 /*ARGSUSED*/
1089 void
1090 usb_unregister_hotplug_cbs(dev_info_t *dip)
1091 {
1092 	usb_unregister_event_cbs(dip, NULL);
1093 }
1094 
1095 
1096 /*
1097  * usb_register_event_cbs:
1098  *	Register to get callbacks for USB events
1099  */
1100 /*ARGSUSED*/
1101 int
1102 usb_register_event_cbs(dev_info_t *dip, usb_event_t *usb_evdata,
1103 	usb_flags_t flags)
1104 {
1105 	usba_device_t		*usba_device;
1106 	usba_evdata_t		*evdata;
1107 
1108 	if ((dip == NULL) || (usb_evdata == NULL)) {
1109 
1110 		return (USB_FAILURE);
1111 	}
1112 
1113 	/*
1114 	 * The event list searches by ddi_get_eventcookie calls below, go
1115 	 * through hubd and so do not apply to host controllers.
1116 	 */
1117 	ASSERT(!usba_is_root_hub(dip));
1118 
1119 	usba_device = usba_get_usba_device(dip);
1120 	evdata = usba_get_evdata(dip);
1121 
1122 	if (usb_evdata->disconnect_event_handler != NULL) {
1123 		if (usba_device->rm_cookie == NULL) {
1124 			if (ddi_get_eventcookie(dip, DDI_DEVI_REMOVE_EVENT,
1125 			    &usba_device->rm_cookie) != DDI_SUCCESS) {
1126 
1127 				goto fail;
1128 			}
1129 		}
1130 		if (ddi_add_event_handler(dip, usba_device->rm_cookie,
1131 		    (peh_t)usb_evdata->disconnect_event_handler,
1132 		    NULL, &evdata->ev_rm_cb_id) != DDI_SUCCESS) {
1133 
1134 			goto fail;
1135 		}
1136 	}
1137 	if (usb_evdata->reconnect_event_handler != NULL) {
1138 		if (usba_device->ins_cookie == NULL) {
1139 			if (ddi_get_eventcookie(dip, DDI_DEVI_INSERT_EVENT,
1140 			    &usba_device->ins_cookie) != DDI_SUCCESS) {
1141 
1142 				goto fail;
1143 			}
1144 		}
1145 		if (ddi_add_event_handler(dip, usba_device->ins_cookie,
1146 		    (peh_t)usb_evdata->reconnect_event_handler,
1147 		    NULL, &evdata->ev_ins_cb_id) != DDI_SUCCESS) {
1148 
1149 			goto fail;
1150 		}
1151 	}
1152 	if (usb_evdata->post_resume_event_handler != NULL) {
1153 		if (usba_device->resume_cookie == NULL) {
1154 			if (ddi_get_eventcookie(dip, USBA_POST_RESUME_EVENT,
1155 			    &usba_device->resume_cookie) != DDI_SUCCESS) {
1156 
1157 				goto fail;
1158 			}
1159 		}
1160 		if (ddi_add_event_handler(dip, usba_device->resume_cookie,
1161 		    (peh_t)usb_evdata->post_resume_event_handler,
1162 		    NULL, &evdata->ev_resume_cb_id) != DDI_SUCCESS) {
1163 
1164 			goto fail;
1165 		}
1166 	}
1167 	if (usb_evdata->pre_suspend_event_handler != NULL) {
1168 		if (usba_device->suspend_cookie == NULL) {
1169 			if (ddi_get_eventcookie(dip, USBA_PRE_SUSPEND_EVENT,
1170 			    &usba_device->suspend_cookie) != DDI_SUCCESS) {
1171 
1172 				goto fail;
1173 			}
1174 		}
1175 		if (ddi_add_event_handler(dip, usba_device->suspend_cookie,
1176 		    (peh_t)usb_evdata->pre_suspend_event_handler,
1177 		    NULL, &evdata->ev_suspend_cb_id) != DDI_SUCCESS) {
1178 
1179 			goto fail;
1180 		}
1181 	}
1182 
1183 	mutex_enter(&usba_device->usb_mutex);
1184 	usba_device->usb_client_flags[usba_get_ifno(dip)] |=
1185 	    USBA_CLIENT_FLAG_EV_CBS;
1186 	usba_device->usb_client_ev_cb_list->dip = dip;
1187 	usba_device->usb_client_ev_cb_list->ev_data = usb_evdata;
1188 	mutex_exit(&usba_device->usb_mutex);
1189 
1190 	return (USB_SUCCESS);
1191 
1192 fail:
1193 	usb_unregister_event_cbs(dip, usb_evdata);
1194 
1195 	return (USB_FAILURE);
1196 
1197 }
1198 
1199 
1200 /*
1201  * usb_unregister_event_cbs:
1202  *	Unregister all event callbacks
1203  */
1204 /*ARGSUSED*/
1205 void
1206 usb_unregister_event_cbs(dev_info_t *dip, usb_event_t *usb_evdata)
1207 {
1208 	usba_evdata_t		*evdata;
1209 	usba_device_t		*usba_device = usba_get_usba_device(dip);
1210 
1211 	evdata = usba_get_evdata(dip);
1212 
1213 	if (evdata->ev_rm_cb_id != NULL) {
1214 		(void) ddi_remove_event_handler(evdata->ev_rm_cb_id);
1215 		evdata->ev_rm_cb_id = NULL;
1216 	}
1217 
1218 	if (evdata->ev_ins_cb_id != NULL) {
1219 		(void) ddi_remove_event_handler(evdata->ev_ins_cb_id);
1220 		evdata->ev_ins_cb_id = NULL;
1221 	}
1222 
1223 	if (evdata->ev_suspend_cb_id != NULL) {
1224 		(void) ddi_remove_event_handler(evdata->ev_suspend_cb_id);
1225 		evdata->ev_suspend_cb_id = NULL;
1226 	}
1227 
1228 	if (evdata->ev_resume_cb_id != NULL) {
1229 		(void) ddi_remove_event_handler(evdata->ev_resume_cb_id);
1230 		evdata->ev_resume_cb_id = NULL;
1231 	}
1232 
1233 	mutex_enter(&usba_device->usb_mutex);
1234 	usba_device->usb_client_flags[usba_get_ifno(dip)] &=
1235 	    ~USBA_CLIENT_FLAG_EV_CBS;
1236 	mutex_exit(&usba_device->usb_mutex);
1237 }
1238 
1239 int
1240 usb_reset_device(dev_info_t *dip, usb_dev_reset_lvl_t reset_level)
1241 {
1242 	return (usba_hubdi_reset_device(dip, reset_level));
1243 }
1244 
1245 /*
1246  * usb device driver registration
1247  */
1248 int
1249 usb_register_dev_driver(dev_info_t *dip, usb_dev_driver_callback_t cb)
1250 {
1251 	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
1252 	    "usb_register_dev_driver: register the specified driver "
1253 	    "in usba: dip = 0x%p", (void *)dip);
1254 
1255 	if (cb != NULL) {
1256 		usb_cap.dip = dip;
1257 		usb_cap.usba_dev_driver_cb = cb;
1258 
1259 		return (USB_SUCCESS);
1260 	}
1261 
1262 	return (USB_FAILURE);
1263 }
1264 
1265 /*
1266  * usb device driver unregistration
1267  */
1268 void
1269 usb_unregister_dev_driver(dev_info_t *dip)
1270 {
1271 	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
1272 	    "usb_unregister_dev_driver: unregister the registered "
1273 	    "driver: dip =0x%p", (void *)dip);
1274 
1275 	ASSERT(dip == usb_cap.dip);
1276 	usb_cap.dip = NULL;
1277 	usb_cap.usba_dev_driver_cb = NULL;
1278 }
1279