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 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * USBA: Solaris USB Architecture support
28 *
29 * hcdi.c contains the code for client driver callbacks. A host controller
30 * driver registers/unregisters with usba through usba_hcdi_register/unregister.
31 *
32 * When the transfer has finished, the host controller driver will call into
33 * usba with the result. The call is usba_hcdi_cb().
34 *
35 * The callback queue is maintained in FIFO order. usba_hcdi_cb
36 * adds to the queue, and hcdi_cb_thread takes the callbacks off the queue
37 * and executes them.
38 */
39 #define USBA_FRAMEWORK
40 #include <sys/usb/usba/usba_impl.h>
41 #include <sys/usb/usba/hcdi_impl.h>
42 #include <sys/kstat.h>
43 #include <sys/ddi_impldefs.h>
44
45 /* function prototypes, XXXX use hcdi_ prefix? */
46 static void usba_hcdi_create_stats(usba_hcdi_t *, int);
47 static void usba_hcdi_update_error_stats(usba_hcdi_t *, usb_cr_t);
48 static void usba_hcdi_destroy_stats(usba_hcdi_t *);
49
50 /* internal functions */
51 static uint_t hcdi_soft_intr(caddr_t arg1, caddr_t arg2);
52
53 static void hcdi_cb_thread(void *);
54 static void hcdi_shared_cb_thread(void *);
55 static void hcdi_do_cb(usba_pipe_handle_data_t *, usba_req_wrapper_t *,
56 usba_hcdi_t *);
57 static void hcdi_autoclearing(usba_req_wrapper_t *);
58
59 /* private function from USBAI */
60 void usba_pipe_clear(usb_pipe_handle_t);
61
62 /* for debug messages */
63 uint_t hcdi_errmask = (uint_t)DPRINT_MASK_ALL;
64 uint_t hcdi_errlevel = USB_LOG_L4;
65 uint_t hcdi_instance_debug = (uint_t)-1;
66
67 void
68 usba_hcdi_initialization()
69 {
70 }
71
72
73 void
74 usba_hcdi_destroy()
75 {
76 }
77
78
79 /*
80 * store hcdi structure in the dip
81 */
82 void
83 usba_hcdi_set_hcdi(dev_info_t *dip, usba_hcdi_t *hcdi)
84 {
85 ddi_set_driver_private(dip, hcdi);
86 }
87
88
89 /*
90 * retrieve hcdi structure from the dip
91 */
92 usba_hcdi_t *
93 usba_hcdi_get_hcdi(dev_info_t *dip)
94 {
95 return (ddi_get_driver_private(dip));
96 }
97
98 /*
99 * Called by an HCD to attach an instance of the driver
100 * make this instance known to USBA
101 * the HCD should initialize usba_hcdi structure prior
102 * to calling this interface
103 */
104 int
105 usba_hcdi_register(usba_hcdi_register_args_t *args, uint_t flags)
106 {
107 char *datap;
108 uint_t soft_prip;
109 usba_hcdi_t *hcdi = kmem_zalloc(sizeof (usba_hcdi_t), KM_SLEEP);
110
111 if (args->usba_hcdi_register_version != HCDI_REGISTER_VERS_0) {
112 kmem_free(hcdi, sizeof (usba_hcdi_t));
113
114 return (USB_FAILURE);
115 }
116
117 hcdi->hcdi_dip = args->usba_hcdi_register_dip;
118
119 /*
120 * Create a log_handle
121 */
122 hcdi->hcdi_log_handle = usb_alloc_log_hdl(hcdi->hcdi_dip, NULL,
123 &hcdi_errlevel, &hcdi_errmask, &hcdi_instance_debug,
124 0);
125
126 USB_DPRINTF_L4(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
127 "usba_hcdi_register: %s", ddi_node_name(hcdi->hcdi_dip));
128
129 /*
130 * Initialize the mutex. Use the iblock cookie passed in
131 * by the host controller driver.
132 */
133 mutex_init(&hcdi->hcdi_mutex, NULL, MUTEX_DRIVER,
134 args->usba_hcdi_register_iblock_cookie);
135
136 /* add soft interrupt */
137 if (ddi_intr_add_softint(hcdi->hcdi_dip, &hcdi->hcdi_softint_hdl,
138 DDI_INTR_SOFTPRI_MAX, hcdi_soft_intr, (caddr_t)hcdi) !=
139 DDI_SUCCESS) {
140 USB_DPRINTF_L2(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
141 "usba_hcd_register: add soft interrupt failed");
142 mutex_destroy(&hcdi->hcdi_mutex);
143 usb_free_log_hdl(hcdi->hcdi_log_handle);
144 kmem_free(hcdi, sizeof (usba_hcdi_t));
145
146 return (USB_FAILURE);
147 }
148
149 if (ddi_intr_get_softint_pri(hcdi->hcdi_softint_hdl, &soft_prip) !=
150 DDI_SUCCESS) {
151 USB_DPRINTF_L2(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
152 "usba_hcd_register: get soft interrupt priority failed");
153 (void) ddi_intr_remove_softint(hcdi->hcdi_softint_hdl);
154 mutex_destroy(&hcdi->hcdi_mutex);
155 usb_free_log_hdl(hcdi->hcdi_log_handle);
156 kmem_free(hcdi, sizeof (usba_hcdi_t));
157
158 return (USB_FAILURE);
159 }
160
161 /*
162 * Priority and iblock_cookie are one and the same
163 * (However, retaining hcdi_soft_iblock_cookie for now
164 * assigning it w/ priority. In future all iblock_cookie
165 * could just go)
166 */
167 hcdi->hcdi_soft_iblock_cookie =
168 (ddi_iblock_cookie_t)(uintptr_t)soft_prip;
169
170 usba_init_list(&hcdi->hcdi_cb_queue, NULL, NULL);
171
172 hcdi->hcdi_dma_attr = args->usba_hcdi_register_dma_attr;
173 hcdi->hcdi_flags = flags;
174 hcdi->hcdi_ops = args->usba_hcdi_register_ops;
175 hcdi->hcdi_iblock_cookie = args->usba_hcdi_register_iblock_cookie;
176 usba_hcdi_create_stats(hcdi, ddi_get_instance(hcdi->hcdi_dip));
177
178 hcdi->hcdi_min_xfer = hcdi->hcdi_dma_attr->dma_attr_minxfer;
179 hcdi->hcdi_min_burst_size =
180 (1<<(ddi_ffs(hcdi->hcdi_dma_attr->dma_attr_burstsizes)-1));
181 hcdi->hcdi_max_burst_size =
182 (1<<(ddi_fls(hcdi->hcdi_dma_attr->dma_attr_burstsizes)-1));
183
184 usba_hcdi_set_hcdi(hcdi->hcdi_dip, hcdi);
185
186 if (ddi_prop_lookup_string(DDI_DEV_T_ANY,
187 hcdi->hcdi_dip,
188 DDI_PROP_DONTPASS, "ugen-default-binding", &datap) ==
189 DDI_PROP_SUCCESS) {
190 if (strcmp(datap, "device") == 0) {
191 hcdi->hcdi_ugen_default_binding =
192 USBA_UGEN_DEVICE_BINDING;
193 } else if (strcmp(datap, "interface") == 0) {
194 hcdi->hcdi_ugen_default_binding =
195 USBA_UGEN_INTERFACE_BINDING;
196 } else if (strcmp(datap, "interface-association") == 0) {
197 hcdi->hcdi_ugen_default_binding =
198 USBA_UGEN_INTERFACE_ASSOCIATION_BINDING;
199 } else {
200 USB_DPRINTF_L2(DPRINT_MASK_HCDI,
201 hcdi->hcdi_log_handle,
202 "illegal value (%s) for "
203 "ugen_default_binding property",
204 datap);
205 }
206 ddi_prop_free(datap);
207 }
208
209 return (USB_SUCCESS);
210 }
211
212
213 /*
214 * Called by an HCD to detach an instance of the driver
215 */
216 /*ARGSUSED*/
217 void
218 usba_hcdi_unregister(dev_info_t *dip)
219 {
220 usba_hcdi_t *hcdi = usba_hcdi_get_hcdi(dip);
221
222 if (hcdi) {
223 USB_DPRINTF_L4(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
224 "usba_hcdi_unregister: %s", ddi_node_name(dip));
225
226 usba_hcdi_set_hcdi(dip, NULL);
227
228 mutex_destroy(&hcdi->hcdi_mutex);
229 usba_hcdi_destroy_stats(hcdi);
230 usb_free_log_hdl(hcdi->hcdi_log_handle);
231
232 /* Destroy the soft interrupt */
233 (void) ddi_intr_remove_softint(hcdi->hcdi_softint_hdl);
234 kmem_free(hcdi, sizeof (usba_hcdi_t));
235 }
236 }
237
238
239 /*
240 * alloc usba_hcdi_ops structure
241 * called from the HCD attach routine
242 */
243 usba_hcdi_ops_t *
244 usba_alloc_hcdi_ops()
245 {
246 usba_hcdi_ops_t *usba_hcdi_ops;
247
248 usba_hcdi_ops = kmem_zalloc(sizeof (usba_hcdi_ops_t), KM_SLEEP);
249
250 return (usba_hcdi_ops);
251 }
252
253
254 /*
255 * dealloc usba_hcdi_ops structure
256 */
257 void
258 usba_free_hcdi_ops(usba_hcdi_ops_t *hcdi_ops)
259 {
260 if (hcdi_ops) {
261 kmem_free(hcdi_ops, sizeof (usba_hcdi_ops_t));
262 }
263 }
264
265
266 /*
267 * Allocate the hotplug kstats structure
268 */
269 void
270 usba_hcdi_create_stats(usba_hcdi_t *hcdi, int instance)
271 {
272 char kstatname[KSTAT_STRLEN];
273 const char *dname = ddi_driver_name(hcdi->hcdi_dip);
274 hcdi_hotplug_stats_t *hsp;
275 hcdi_error_stats_t *esp;
276
277 if (HCDI_HOTPLUG_STATS(hcdi) == NULL) {
278 (void) snprintf(kstatname, KSTAT_STRLEN, "%s%d,hotplug",
279 dname, instance);
280 HCDI_HOTPLUG_STATS(hcdi) = kstat_create("usba", instance,
281 kstatname, "usb_hotplug", KSTAT_TYPE_NAMED,
282 sizeof (hcdi_hotplug_stats_t) / sizeof (kstat_named_t),
283 KSTAT_FLAG_PERSISTENT);
284
285 if (HCDI_HOTPLUG_STATS(hcdi) == NULL) {
286
287 return;
288 }
289
290 hsp = HCDI_HOTPLUG_STATS_DATA(hcdi);
291 kstat_named_init(&hsp->hcdi_hotplug_total_success,
292 "Total Hotplug Successes", KSTAT_DATA_UINT64);
293 kstat_named_init(&hsp->hcdi_hotplug_success,
294 "Hotplug Successes", KSTAT_DATA_UINT64);
295 kstat_named_init(&hsp->hcdi_hotplug_total_failure,
296 "Hotplug Total Failures", KSTAT_DATA_UINT64);
297 kstat_named_init(&hsp->hcdi_hotplug_failure,
298 "Hotplug Failures", KSTAT_DATA_UINT64);
299 kstat_named_init(&hsp->hcdi_device_count,
300 "Device Count", KSTAT_DATA_UINT64);
301
302 HCDI_HOTPLUG_STATS(hcdi)->ks_private = hcdi;
303 HCDI_HOTPLUG_STATS(hcdi)->ks_update = nulldev;
304 kstat_install(HCDI_HOTPLUG_STATS(hcdi));
305 }
306
307 if (HCDI_ERROR_STATS(hcdi) == NULL) {
308 (void) snprintf(kstatname, KSTAT_STRLEN, "%s%d,error",
309 dname, instance);
310 HCDI_ERROR_STATS(hcdi) = kstat_create("usba", instance,
311 kstatname, "usb_errors", KSTAT_TYPE_NAMED,
312 sizeof (hcdi_error_stats_t) / sizeof (kstat_named_t),
313 KSTAT_FLAG_PERSISTENT);
314
315 if (HCDI_ERROR_STATS(hcdi) == NULL) {
316
317 return;
318 }
319
320 esp = HCDI_ERROR_STATS_DATA(hcdi);
321 kstat_named_init(&esp->cc_crc, "CRC Errors", KSTAT_DATA_UINT64);
322 kstat_named_init(&esp->cc_bitstuffing,
323 "Bit Stuffing Violations", KSTAT_DATA_UINT64);
324 kstat_named_init(&esp->cc_data_toggle_mm,
325 "Data Toggle PID Errors", KSTAT_DATA_UINT64);
326 kstat_named_init(&esp->cc_stall,
327 "Endpoint Stalls", KSTAT_DATA_UINT64);
328 kstat_named_init(&esp->cc_dev_not_resp,
329 "Device Not Responding", KSTAT_DATA_UINT64);
330 kstat_named_init(&esp->cc_pid_checkfailure,
331 "PID Check Bit Errors", KSTAT_DATA_UINT64);
332 kstat_named_init(&esp->cc_unexp_pid,
333 "Invalid PID Errors", KSTAT_DATA_UINT64);
334 kstat_named_init(&esp->cc_data_overrun,
335 "Data Overruns", KSTAT_DATA_UINT64);
336 kstat_named_init(&esp->cc_data_underrun,
337 "Data Underruns", KSTAT_DATA_UINT64);
338 kstat_named_init(&esp->cc_buffer_overrun,
339 "Buffer Overruns", KSTAT_DATA_UINT64);
340 kstat_named_init(&esp->cc_buffer_underrun,
341 "Buffer Underruns", KSTAT_DATA_UINT64);
342 kstat_named_init(&esp->cc_timeout,
343 "Command Timed Out", KSTAT_DATA_UINT64);
344 kstat_named_init(&esp->cc_not_accessed,
345 "Not Accessed By Hardware", KSTAT_DATA_UINT64);
346 kstat_named_init(&esp->cc_no_resources,
347 "No Resources", KSTAT_DATA_UINT64);
348 kstat_named_init(&esp->cc_unspecified_err,
349 "Unspecified Error", KSTAT_DATA_UINT64);
350 kstat_named_init(&esp->cc_stopped_polling,
351 "Stopped Polling", KSTAT_DATA_UINT64);
352 kstat_named_init(&esp->cc_pipe_closing,
353 "Pipe Closing", KSTAT_DATA_UINT64);
354 kstat_named_init(&esp->cc_pipe_reset,
355 "Pipe Reset", KSTAT_DATA_UINT64);
356 kstat_named_init(&esp->cc_not_supported,
357 "Command Not Supported", KSTAT_DATA_UINT64);
358 kstat_named_init(&esp->cc_flushed,
359 "Request Flushed", KSTAT_DATA_UINT64);
360
361 HCDI_ERROR_STATS(hcdi)->ks_private = hcdi;
362 HCDI_ERROR_STATS(hcdi)->ks_update = nulldev;
363 kstat_install(HCDI_ERROR_STATS(hcdi));
364 }
365 }
366
367
368 /*
369 * Do actual error stats
370 */
371 void
372 usba_hcdi_update_error_stats(usba_hcdi_t *hcdi, usb_cr_t completion_reason)
373 {
374 if (HCDI_ERROR_STATS(hcdi) == NULL) {
375
376 return;
377 }
378
379 switch (completion_reason) {
380 case USB_CR_OK:
381 break;
382 case USB_CR_CRC:
383 HCDI_ERROR_STATS_DATA(hcdi)->cc_crc.value.ui64++;
384 break;
385 case USB_CR_BITSTUFFING:
386 HCDI_ERROR_STATS_DATA(hcdi)->cc_bitstuffing.value.ui64++;
387 break;
388 case USB_CR_DATA_TOGGLE_MM:
389 HCDI_ERROR_STATS_DATA(hcdi)->cc_data_toggle_mm.value.ui64++;
390 break;
391 case USB_CR_STALL:
392 HCDI_ERROR_STATS_DATA(hcdi)->cc_stall.value.ui64++;
393 break;
394 case USB_CR_DEV_NOT_RESP:
395 HCDI_ERROR_STATS_DATA(hcdi)->cc_dev_not_resp.value.ui64++;
396 break;
397 case USB_CR_PID_CHECKFAILURE:
398 HCDI_ERROR_STATS_DATA(hcdi)->cc_pid_checkfailure.value.ui64++;
399 break;
400 case USB_CR_UNEXP_PID:
401 HCDI_ERROR_STATS_DATA(hcdi)->cc_unexp_pid.value.ui64++;
402 break;
403 case USB_CR_DATA_OVERRUN:
404 HCDI_ERROR_STATS_DATA(hcdi)->cc_data_overrun.value.ui64++;
405 break;
406 case USB_CR_DATA_UNDERRUN:
407 HCDI_ERROR_STATS_DATA(hcdi)->cc_data_underrun.value.ui64++;
408 break;
409 case USB_CR_BUFFER_OVERRUN:
410 HCDI_ERROR_STATS_DATA(hcdi)->cc_buffer_overrun.value.ui64++;
411 break;
412 case USB_CR_BUFFER_UNDERRUN:
413 HCDI_ERROR_STATS_DATA(hcdi)->cc_buffer_underrun.value.ui64++;
414 break;
415 case USB_CR_TIMEOUT:
416 HCDI_ERROR_STATS_DATA(hcdi)->cc_timeout.value.ui64++;
417 break;
418 case USB_CR_NOT_ACCESSED:
419 HCDI_ERROR_STATS_DATA(hcdi)->cc_not_accessed.value.ui64++;
420 break;
421 case USB_CR_NO_RESOURCES:
422 HCDI_ERROR_STATS_DATA(hcdi)->cc_no_resources.value.ui64++;
423 break;
424 case USB_CR_UNSPECIFIED_ERR:
425 HCDI_ERROR_STATS_DATA(hcdi)->cc_unspecified_err.value.ui64++;
426 break;
427 case USB_CR_STOPPED_POLLING:
428 HCDI_ERROR_STATS_DATA(hcdi)->cc_stopped_polling.value.ui64++;
429 break;
430 case USB_CR_PIPE_CLOSING:
431 HCDI_ERROR_STATS_DATA(hcdi)->cc_pipe_closing.value.ui64++;
432 break;
433 case USB_CR_PIPE_RESET:
434 HCDI_ERROR_STATS_DATA(hcdi)->cc_pipe_reset.value.ui64++;
435 break;
436 case USB_CR_NOT_SUPPORTED:
437 HCDI_ERROR_STATS_DATA(hcdi)->cc_not_supported.value.ui64++;
438 break;
439 case USB_CR_FLUSHED:
440 HCDI_ERROR_STATS_DATA(hcdi)->cc_flushed.value.ui64++;
441 break;
442 default:
443 break;
444 }
445 }
446
447
448 /*
449 * Destroy the hotplug kstats structure
450 */
451 static void
452 usba_hcdi_destroy_stats(usba_hcdi_t *hcdi)
453 {
454 if (HCDI_HOTPLUG_STATS(hcdi)) {
455 kstat_delete(HCDI_HOTPLUG_STATS(hcdi));
456 HCDI_HOTPLUG_STATS(hcdi) = NULL;
457 }
458
459 if (HCDI_ERROR_STATS(hcdi)) {
460 kstat_delete(HCDI_ERROR_STATS(hcdi));
461 HCDI_ERROR_STATS(hcdi) = NULL;
462 }
463 }
464
465
466 /*
467 * HCD callback handling
468 */
469 void
470 usba_hcdi_cb(usba_pipe_handle_data_t *ph_data,
471 usb_opaque_t req,
472 usb_cr_t completion_reason)
473 {
474
475 usba_device_t *usba_device = ph_data->p_usba_device;
476 usba_hcdi_t *hcdi = usba_hcdi_get_hcdi(
477 usba_device->usb_root_hub_dip);
478 usba_req_wrapper_t *req_wrp = USBA_REQ2WRP(req);
479 usb_ep_descr_t *eptd = &ph_data->p_ep;
480
481 mutex_enter(&ph_data->p_mutex);
482
483 #ifdef DEBUG
484 mutex_enter(&ph_data->p_ph_impl->usba_ph_mutex);
485
486 USB_DPRINTF_L4(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
487 "usba_hcdi_cb: "
488 "ph_data=0x%p req=0x%p state=%d ref=%d cnt=%d cr=%d",
489 (void *)ph_data, (void *)req, ph_data->p_ph_impl->usba_ph_state,
490 ph_data->p_ph_impl->usba_ph_ref_count, ph_data->p_req_count,
491 completion_reason);
492
493 mutex_exit(&ph_data->p_ph_impl->usba_ph_mutex);
494 #endif
495
496 /* Set the completion reason */
497 switch (eptd->bmAttributes & USB_EP_ATTR_MASK) {
498 case USB_EP_ATTR_CONTROL:
499 ((usb_ctrl_req_t *)req)->
500 ctrl_completion_reason = completion_reason;
501 break;
502 case USB_EP_ATTR_BULK:
503 ((usb_bulk_req_t *)req)->
504 bulk_completion_reason = completion_reason;
505 break;
506 case USB_EP_ATTR_INTR:
507 ((usb_intr_req_t *)req)->
508 intr_completion_reason = completion_reason;
509 break;
510 case USB_EP_ATTR_ISOCH:
511 ((usb_isoc_req_t *)req)->
512 isoc_completion_reason = completion_reason;
513 break;
514 }
515
516 /*
517 * exception callbacks will still go thru a taskq thread
518 * but should occur after the soft interrupt callback
519 * By design of periodic pipes, polling will stop on any
520 * exception
521 */
522 if ((ph_data->p_spec_flag & USBA_PH_FLAG_USE_SOFT_INTR) &&
523 (completion_reason == USB_CR_OK)) {
524 ph_data->p_soft_intr++;
525 mutex_exit(&ph_data->p_mutex);
526
527 usba_add_to_list(&hcdi->hcdi_cb_queue, &req_wrp->wr_queue);
528
529 if (ddi_intr_trigger_softint(hcdi->hcdi_softint_hdl, NULL) !=
530 DDI_SUCCESS)
531 USB_DPRINTF_L2(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
532 "usba_hcdi_cb: ddi_intr_trigger_softint failed");
533
534 return;
535 }
536
537 /*
538 * USBA_PH_FLAG_TQ_SHARE is for bulk and intr requests,
539 * USBA_PH_FLAG_USE_SOFT_INTR is only for isoch,
540 * so there are no conflicts.
541 */
542 if (ph_data->p_spec_flag & USBA_PH_FLAG_TQ_SHARE) {
543 int iface;
544
545 mutex_exit(&ph_data->p_mutex);
546 iface = usb_get_if_number(ph_data->p_dip);
547 if (iface < 0) {
548 /* we own the device, use the first taskq */
549 iface = 0;
550 }
551 if (taskq_dispatch(usba_device->usb_shared_taskq[iface],
552 hcdi_shared_cb_thread, req_wrp, TQ_NOSLEEP) ==
553 NULL) {
554 usba_req_exc_cb(req_wrp,
555 USB_CR_NO_RESOURCES, USB_CB_ASYNC_REQ_FAILED);
556 }
557
558 return;
559 }
560
561 /* Add the callback to the pipehandles callback list */
562 usba_add_to_list(&ph_data->p_cb_queue, &req_wrp->wr_queue);
563
564 /* only dispatch if there is no thread running */
565 if (ph_data->p_thread_id == 0) {
566 if (usba_async_ph_req(ph_data, hcdi_cb_thread,
567 ph_data, USB_FLAGS_NOSLEEP) != USB_SUCCESS) {
568 USB_DPRINTF_L2(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
569 "usba_hcdi_cb: taskq_dispatch failed");
570 if (usba_rm_from_list(&ph_data->p_cb_queue,
571 &req_wrp->wr_queue) == USB_SUCCESS) {
572 mutex_exit(&ph_data->p_mutex);
573 usba_req_exc_cb(req_wrp,
574 USB_CR_NO_RESOURCES,
575 USB_CB_ASYNC_REQ_FAILED);
576
577 return;
578 }
579 } else {
580 ph_data->p_thread_id = (kthread_t *)1;
581 }
582 }
583 mutex_exit(&ph_data->p_mutex);
584 }
585
586
587 /*
588 * thread to perform the callbacks
589 */
590 static void
591 hcdi_cb_thread(void *arg)
592 {
593 usba_pipe_handle_data_t *ph_data =
594 (usba_pipe_handle_data_t *)arg;
595 usba_ph_impl_t *ph_impl = ph_data->p_ph_impl;
596 usba_hcdi_t *hcdi = usba_hcdi_get_hcdi(ph_data->
597 p_usba_device->usb_root_hub_dip);
598 usba_req_wrapper_t *req_wrp;
599
600 mutex_enter(&ph_data->p_mutex);
601 ASSERT(ph_data->p_thread_id == (kthread_t *)1);
602 ph_data->p_thread_id = curthread;
603
604 /*
605 * hold the ph_data. we can't use usba_hold_ph_data() since
606 * it will return NULL if we are closing the pipe which would
607 * then leave all requests stuck in the cb_queue
608 */
609 mutex_enter(&ph_impl->usba_ph_mutex);
610 ph_impl->usba_ph_ref_count++;
611
612 USB_DPRINTF_L4(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
613 "hcdi_cb_thread: ph_data=0x%p ref=%d", (void *)ph_data,
614 ph_impl->usba_ph_ref_count);
615
616 mutex_exit(&ph_impl->usba_ph_mutex);
617
618 /*
619 * wait till soft interrupt callbacks are taken care of
620 */
621 while (ph_data->p_soft_intr) {
622 mutex_exit(&ph_data->p_mutex);
623 delay(1);
624 mutex_enter(&ph_data->p_mutex);
625 }
626
627 while ((req_wrp = (usba_req_wrapper_t *)
628 usba_rm_first_pvt_from_list(&ph_data->p_cb_queue)) != NULL) {
629 hcdi_do_cb(ph_data, req_wrp, hcdi);
630 }
631
632 ph_data->p_thread_id = 0;
633 mutex_exit(&ph_data->p_mutex);
634
635 USB_DPRINTF_L4(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
636 "hcdi_cb_thread done: ph_data=0x%p", (void *)ph_data);
637
638 usba_release_ph_data(ph_impl);
639 }
640
641
642 static void
643 hcdi_do_cb(usba_pipe_handle_data_t *ph_data, usba_req_wrapper_t *req_wrp,
644 usba_hcdi_t *hcdi)
645 {
646 usb_cr_t completion_reason;
647 usb_req_attrs_t attrs = req_wrp->wr_attrs;
648
649 switch (req_wrp->wr_ph_data->p_ep.bmAttributes &
650 USB_EP_ATTR_MASK) {
651 case USB_EP_ATTR_CONTROL:
652 completion_reason =
653 USBA_WRP2CTRL_REQ(req_wrp)->ctrl_completion_reason;
654 break;
655 case USB_EP_ATTR_INTR:
656 completion_reason =
657 USBA_WRP2INTR_REQ(req_wrp)->intr_completion_reason;
658 break;
659 case USB_EP_ATTR_BULK:
660 completion_reason =
661 USBA_WRP2BULK_REQ(req_wrp)->bulk_completion_reason;
662 break;
663 case USB_EP_ATTR_ISOCH:
664 completion_reason =
665 USBA_WRP2ISOC_REQ(req_wrp)->isoc_completion_reason;
666 break;
667 }
668 req_wrp->wr_cr = completion_reason;
669
670 USB_DPRINTF_L4(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
671 "hcdi_do_cb: wrp=0x%p cr=0x%x", (void *)req_wrp, completion_reason);
672
673 /*
674 * Normal callbacks:
675 */
676 if (completion_reason == USB_CR_OK) {
677 mutex_exit(&ph_data->p_mutex);
678 usba_req_normal_cb(req_wrp);
679 mutex_enter(&ph_data->p_mutex);
680 } else {
681 usb_pipe_state_t pipe_state;
682
683 USB_DPRINTF_L4(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
684 "exception callback handling: attrs=0x%x", attrs);
685
686 /*
687 * In exception callback handling, if we were
688 * not able to clear stall, we need to modify
689 * pipe state. Also if auto-clearing is not set
690 * pipe state needs to be modified.
691 */
692 pipe_state = usba_get_ph_state(ph_data);
693
694 if (!USBA_PIPE_CLOSING(pipe_state)) {
695 switch (completion_reason) {
696 case USB_CR_STOPPED_POLLING:
697 if (pipe_state ==
698 USB_PIPE_STATE_ACTIVE) {
699 usba_pipe_new_state(ph_data,
700 USB_PIPE_STATE_IDLE);
701 }
702 break;
703 case USB_CR_NOT_SUPPORTED:
704 usba_pipe_new_state(ph_data,
705 USB_PIPE_STATE_IDLE);
706 break;
707 case USB_CR_PIPE_RESET:
708 case USB_CR_FLUSHED:
709 break;
710 default:
711 usba_pipe_new_state(ph_data,
712 USB_PIPE_STATE_ERROR);
713 break;
714 }
715 }
716
717 pipe_state = usba_get_ph_state(ph_data);
718
719 mutex_exit(&ph_data->p_mutex);
720 if (attrs & USB_ATTRS_PIPE_RESET) {
721 if ((completion_reason != USB_CR_PIPE_RESET) &&
722 (pipe_state == USB_PIPE_STATE_ERROR)) {
723
724 hcdi_autoclearing(req_wrp);
725 }
726 }
727
728 usba_req_exc_cb(req_wrp, 0, 0);
729 mutex_enter(&ph_data->p_mutex);
730 }
731
732 /* Update the hcdi error kstats */
733 if (completion_reason) {
734 mutex_enter(&hcdi->hcdi_mutex);
735 usba_hcdi_update_error_stats(hcdi, completion_reason);
736 mutex_exit(&hcdi->hcdi_mutex);
737 }
738
739 /*
740 * Once the callback is finished, release the pipe handle
741 * we start the next request first to avoid that the
742 * pipe gets closed while starting the next request
743 */
744 mutex_exit(&ph_data->p_mutex);
745 usba_start_next_req(ph_data);
746
747 mutex_enter(&ph_data->p_mutex);
748 }
749
750
751 /*
752 * thread to perform callbacks on the shared queue
753 */
754 static void
755 hcdi_shared_cb_thread(void *arg)
756 {
757 usba_req_wrapper_t *req_wrp = (usba_req_wrapper_t *)arg;
758 usba_pipe_handle_data_t *ph_data = req_wrp->wr_ph_data;
759 usba_ph_impl_t *ph_impl = ph_data->p_ph_impl;
760 usba_hcdi_t *hcdi = usba_hcdi_get_hcdi(ph_data->
761 p_usba_device->usb_root_hub_dip);
762 /*
763 * hold the ph_data. we can't use usba_hold_ph_data() since
764 * it will return NULL if we are closing the pipe which would
765 * then leave all requests stuck in the cb_queue
766 */
767 mutex_enter(&ph_impl->usba_ph_mutex);
768 ph_impl->usba_ph_ref_count++;
769
770 USB_DPRINTF_L4(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
771 "hcdi_shared_cb_thread: ph_data=0x%p ref=%d req=0x%p",
772 (void *)ph_data, ph_impl->usba_ph_ref_count, (void *)req_wrp);
773 mutex_exit(&ph_impl->usba_ph_mutex);
774
775 /* do the callback */
776 mutex_enter(&ph_data->p_mutex);
777 hcdi_do_cb(ph_data, req_wrp, hcdi);
778 mutex_exit(&ph_data->p_mutex);
779
780 USB_DPRINTF_L4(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
781 "hcdi_cb_thread done: ph_data=0x%p", (void *)ph_data);
782
783 usba_release_ph_data(ph_impl);
784 }
785
786
787 /*
788 * soft interrupt handler
789 */
790 /*ARGSUSED*/
791 static uint_t
792 hcdi_soft_intr(caddr_t arg1, caddr_t arg2)
793 {
794 usba_hcdi_t *hcdi = (void *)arg1;
795 usba_req_wrapper_t *req_wrp;
796 int count = 0;
797
798 while ((req_wrp = (usba_req_wrapper_t *)
799 usba_rm_first_pvt_from_list(&hcdi->hcdi_cb_queue)) != NULL) {
800 usba_pipe_handle_data_t *ph_data = req_wrp->wr_ph_data;
801 usba_ph_impl_t *ph_impl = ph_data->p_ph_impl;
802
803 /* hold the pipe */
804 mutex_enter(&ph_impl->usba_ph_mutex);
805 ph_impl->usba_ph_ref_count++;
806 mutex_exit(&ph_impl->usba_ph_mutex);
807
808 /* do the callback */
809 usba_req_normal_cb(req_wrp);
810
811 /* decrement the soft interrupt count */
812 mutex_enter(&ph_data->p_mutex);
813 ph_data->p_soft_intr--;
814 mutex_exit(&ph_data->p_mutex);
815
816 /* release the pipe */
817 mutex_enter(&ph_impl->usba_ph_mutex);
818 ph_impl->usba_ph_ref_count--;
819 mutex_exit(&ph_impl->usba_ph_mutex);
820
821 count++;
822 }
823
824 return (count == 0 ? DDI_INTR_UNCLAIMED : DDI_INTR_CLAIMED);
825 }
826
827
828 /*
829 * hcdi_autoclearing:
830 * This function is called under the taskq context. It
831 * resets the pipe, and clears the stall, if necessary
832 */
833 static void
834 hcdi_autoclearing(usba_req_wrapper_t *req_wrp)
835 {
836 usb_cr_t cr = req_wrp->wr_cr;
837 usb_pipe_handle_t pipe_handle, def_pipe_handle;
838 usb_cr_t completion_reason;
839 usb_cb_flags_t cb_flags;
840 int rval;
841 usba_device_t *usba_device =
842 req_wrp->wr_ph_data->p_usba_device;
843 usba_hcdi_t *hcdi = usba_hcdi_get_hcdi(
844 usba_device->usb_root_hub_dip);
845 usb_req_attrs_t attrs = req_wrp->wr_attrs;
846
847 USB_DPRINTF_L4(DPRINT_MASK_HCDI, hcdi->hcdi_log_handle,
848 "hcdi_autoclearing: wrp=0x%p", (void *)req_wrp);
849
850 pipe_handle = usba_get_pipe_handle(req_wrp->wr_ph_data);
851 def_pipe_handle = usba_get_dflt_pipe_handle(req_wrp->wr_ph_data->p_dip);
852
853 /*
854 * first reset the pipe synchronously
855 */
856 if ((attrs & USB_ATTRS_PIPE_RESET) == USB_ATTRS_PIPE_RESET) {
857 usba_pipe_clear(pipe_handle);
858 usba_req_set_cb_flags(req_wrp, USB_CB_RESET_PIPE);
859 }
860
861 ASSERT(def_pipe_handle);
862
863 /* Do not clear if this request was a usb_get_status request */
864 if ((pipe_handle == def_pipe_handle) &&
865 (USBA_WRP2CTRL_REQ(req_wrp)->ctrl_bRequest ==
866 USB_REQ_GET_STATUS)) {
867 USB_DPRINTF_L2(DPRINT_MASK_USBAI, hcdi->hcdi_log_handle,
868 "hcdi_autoclearing: usb_get_status failed, no clearing");
869
870 /* if default pipe and stall no auto clearing */
871 } else if ((pipe_handle == def_pipe_handle) && (cr == USB_CR_STALL)) {
872 USB_DPRINTF_L2(DPRINT_MASK_USBAI, hcdi->hcdi_log_handle,
873 "hcdi_autoclearing: default pipe stalled, no clearing");
874
875 usba_req_set_cb_flags(req_wrp, USB_CB_PROTOCOL_STALL);
876
877 /* else do auto clearing */
878 } else if (((attrs & USB_ATTRS_AUTOCLEARING) ==
879 USB_ATTRS_AUTOCLEARING) && (cr == USB_CR_STALL)) {
880 ushort_t status = 0;
881
882 rval = usb_get_status(req_wrp->wr_dip, def_pipe_handle,
883 USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_RCPT_EP,
884 req_wrp->wr_ph_data->p_ep.bEndpointAddress,
885 &status, USB_FLAGS_SLEEP);
886 if (rval != USB_SUCCESS) {
887 USB_DPRINTF_L2(DPRINT_MASK_USBAI, hcdi->hcdi_log_handle,
888 "get status (STALL) failed: rval=%d", rval);
889
890 usba_pipe_clear(def_pipe_handle);
891 }
892
893 if ((rval != USB_SUCCESS) ||
894 (status & USB_EP_HALT_STATUS)) {
895 usba_req_set_cb_flags(req_wrp, USB_CB_FUNCTIONAL_STALL);
896
897 if ((rval = usb_pipe_sync_ctrl_xfer(
898 req_wrp->wr_dip, def_pipe_handle,
899 USB_DEV_REQ_HOST_TO_DEV |
900 USB_DEV_REQ_RCPT_EP,
901 USB_REQ_CLEAR_FEATURE,
902 0,
903 req_wrp->wr_ph_data->p_ep.bEndpointAddress,
904 0,
905 NULL, 0,
906 &completion_reason,
907 &cb_flags, USB_FLAGS_SLEEP)) != USB_SUCCESS) {
908 USB_DPRINTF_L2(DPRINT_MASK_USBAI,
909 hcdi->hcdi_log_handle,
910 "auto clearing (STALL) failed: "
911 "rval=%d, cr=0x%x cb=0x%x",
912 rval, completion_reason, cb_flags);
913
914 usba_pipe_clear(def_pipe_handle);
915 } else {
916 usba_req_set_cb_flags(req_wrp,
917 USB_CB_STALL_CLEARED);
918 }
919 } else {
920 usba_req_set_cb_flags(req_wrp, USB_CB_PROTOCOL_STALL);
921 }
922 }
923 }
924
925
926 /*
927 * usba_hcdi_get_req_private:
928 * This function is used to get the HCD private field
929 * maintained by USBA. HCD calls this function.
930 *
931 * Arguments:
932 * req - pointer to usb_*_req_t
933 *
934 * Return Values:
935 * wr_hcd_private field from wrapper
936 */
937 usb_opaque_t
938 usba_hcdi_get_req_private(usb_opaque_t req)
939 {
940 usba_req_wrapper_t *wrp = USBA_REQ2WRP(req);
941
942 return (wrp->wr_hcd_private);
943 }
944
945
946 /*
947 * usba_hcdi_set_req_private:
948 * This function is used to set the HCD private field
949 * maintained by USBA. HCD calls this function.
950 *
951 * Arguments:
952 * req - pointer to usb_*_req_t
953 * hcd_private - wr_hcd_private field from wrapper
954 */
955 void
956 usba_hcdi_set_req_private(usb_opaque_t req,
957 usb_opaque_t hcd_private)
958 {
959 usba_req_wrapper_t *wrp = USBA_REQ2WRP(req);
960
961 wrp->wr_hcd_private = hcd_private;
962 }
963
964
965 /* get data toggle information for this endpoint */
966 uchar_t
967 usba_hcdi_get_data_toggle(usba_device_t *usba_device, uint8_t ep_addr)
968 {
969 uchar_t toggle;
970 usba_ph_impl_t *ph_impl;
971 int ep_index;
972
973 ep_index = usb_get_ep_index(ep_addr);
974 mutex_enter(&usba_device->usb_mutex);
975 ph_impl = &usba_device->usb_ph_list[ep_index];
976 mutex_enter(&ph_impl->usba_ph_mutex);
977 toggle = (uchar_t)(ph_impl->usba_ph_flags & USBA_PH_DATA_TOGGLE);
978 mutex_exit(&ph_impl->usba_ph_mutex);
979 mutex_exit(&usba_device->usb_mutex);
980
981 return (toggle);
982 }
983
984
985 /* set data toggle information for this endpoint */
986 void
987 usba_hcdi_set_data_toggle(usba_device_t *usba_device, uint8_t ep_addr,
988 uchar_t toggle)
989 {
990 usba_ph_impl_t *ph_impl;
991 int ep_index;
992
993 ep_index = usb_get_ep_index(ep_addr);
994 mutex_enter(&usba_device->usb_mutex);
995 ph_impl = &usba_device->usb_ph_list[ep_index];
996 mutex_enter(&ph_impl->usba_ph_mutex);
997 ph_impl->usba_ph_flags &= ~USBA_PH_DATA_TOGGLE;
998 ph_impl->usba_ph_flags |= (USBA_PH_DATA_TOGGLE & toggle);
999 mutex_exit(&ph_impl->usba_ph_mutex);
1000 mutex_exit(&usba_device->usb_mutex);
1001 }
1002
1003
1004 /* get pipe_handle_impl ptr for this ep */
1005 usba_pipe_handle_data_t *
1006 usba_hcdi_get_ph_data(usba_device_t *usba_device, uint8_t ep_addr)
1007 {
1008 return (usba_device->usb_ph_list[usb_get_ep_index(ep_addr)].
1009 usba_ph_data);
1010 }