Lines Matching refs:ph_data
117 usba_pipe_handle_data_t *ph_data = NULL;
122 ph_data = ph_impl->usba_ph_data;
126 return (ph_data);
131 usba_get_pipe_handle(usba_pipe_handle_data_t *ph_data)
135 if (ph_data) {
136 mutex_enter(&ph_data->p_mutex);
137 ASSERT(ph_data->p_req_count >= 0);
138 ph = (usb_pipe_handle_t)ph_data->p_ph_impl;
139 mutex_exit(&ph_data->p_mutex);
148 * must release ph_data when done. Increment the ref count ensures that
149 * the ph_data will not be freed underneath us.
155 usba_pipe_handle_data_t *ph_data = NULL;
164 ph_data = ph_impl->usba_ph_data;
181 return (ph_data);
214 * get pipe state from ph_data
217 usba_get_ph_state(usba_pipe_handle_data_t *ph_data)
219 usba_ph_impl_t *ph_impl = ph_data->p_ph_impl;
222 ASSERT(mutex_owned(&ph_data->p_mutex));
232 * get ref_count from ph_data
235 usba_get_ph_ref_count(usba_pipe_handle_data_t *ph_data)
237 usba_ph_impl_t *ph_impl = ph_data->p_ph_impl;
253 usba_pipe_new_state(usba_pipe_handle_data_t *ph_data, usb_pipe_state_t state)
255 usba_ph_impl_t *ph_impl = ph_data->p_ph_impl;
257 ASSERT(mutex_owned(&ph_data->p_mutex));
260 ASSERT(ph_data->p_req_count >= 0);
265 "ph_data=0x%p old=%s new=%s ref=%d req=%d",
266 (void *)ph_data, usb_str_pipe_state(ph_impl->usba_ph_state),
268 ph_impl->usba_ph_ref_count, ph_data->p_req_count);
296 * Note: The caller must do a hold on ph_data
315 usba_pipe_handle_data_t *ph_data = ph_impl->usba_ph_data;
350 } else if (usba_async_ph_req(ph_data,
374 * Note: caller must have done a hold on ph_data
439 usba_pipe_handle_data_t *ph_data = ph_impl->usba_ph_data;
448 mutex_init(&ph_data->p_mutex, NULL, MUTEX_DRIVER, iblock_cookie);
451 mutex_enter(&ph_data->p_mutex);
468 ph_data->p_taskq = taskq_create(tq_name,
480 if (ph_data->p_spec_flag & USBA_PH_FLAG_TQ_SHARE) {
512 ph_data->p_dip = dip;
513 ph_data->p_usba_device = usba_device;
514 ph_data->p_ep = *ep;
515 ph_data->p_ph_impl = ph_impl;
518 ph_data->p_spec_flag |= USBA_PH_FLAG_USE_SOFT_INTR;
536 ph_data->p_ep.wMaxPacketSize, maxpktsize);
538 ph_data->p_ep.wMaxPacketSize = maxpktsize;
544 ph_impl->usba_ph_ep = ph_data->p_ep;
545 ph_impl->usba_ph_policy = ph_data->p_policy = *pipe_policy;
548 usba_init_list(&ph_data->p_queue, (usb_opaque_t)ph_data, iblock_cookie);
549 usba_init_list(&ph_data->p_cb_queue, (usb_opaque_t)ph_data,
552 mutex_exit(&ph_data->p_mutex);
566 usba_destroy_pipe_handle(usba_pipe_handle_data_t *ph_data)
568 usba_ph_impl_t *ph_impl = ph_data->p_ph_impl;
573 "usba_destroy_pipe_handle: ph_data=0x%p", (void *)ph_data);
575 mutex_enter(&ph_data->p_mutex);
581 (ph_data->p_req_count == 0)) {
585 mutex_exit(&ph_data->p_mutex);
588 mutex_enter(&ph_data->p_mutex);
601 if (ph_data->p_taskq) {
602 mutex_exit(&ph_data->p_mutex);
604 if (taskq_member(ph_data->p_taskq, curthread)) {
610 usba_taskq_destroy, ph_data->p_taskq, TQ_SLEEP);
612 taskq_destroy(ph_data->p_taskq);
615 mutex_exit(&ph_data->p_mutex);
619 usba_device = ph_data->p_usba_device;
620 mutex_enter(&ph_data->p_mutex);
621 if (ph_data->p_spec_flag & USBA_PH_FLAG_TQ_SHARE) {
622 int iface = usb_get_if_number(ph_data->p_dip);
629 ph_data->p_spec_flag &= ~USBA_PH_FLAG_TQ_SHARE;
644 mutex_exit(&ph_data->p_mutex);
648 "usba_destroy_pipe_handle: destroying ph_data=0x%p",
649 (void *)ph_data);
651 usba_destroy_list(&ph_data->p_queue);
652 usba_destroy_list(&ph_data->p_cb_queue);
655 mutex_destroy(&ph_data->p_mutex);
657 kmem_free(ph_data, sizeof (usba_pipe_handle_data_t));
666 usba_drain_cbs(usba_pipe_handle_data_t *ph_data, usb_cb_flags_t cb_flags,
671 usba_ph_impl_t *ph_impl = ph_data->p_ph_impl;
675 ASSERT(mutex_owned(&ph_data->p_mutex));
679 "usba_drain_cbs: ph_data=0x%p ref=%d req=%d cb=0x%x cr=%d",
680 (void *)ph_data, ph_impl->usba_ph_ref_count, ph_data->p_req_count,
682 ASSERT(ph_data->p_req_count >= 0);
685 if (ph_data->p_dip) {
686 if (USBA_IS_DEFAULT_PIPE(ph_data)) {
698 usba_rm_first_pvt_from_list(&ph_data->p_queue)) != NULL) {
699 mutex_exit(&ph_data->p_mutex);
701 mutex_enter(&ph_data->p_mutex);
710 (ph_data->p_req_count >
711 usba_list_entry_count(&ph_data->p_queue));
713 mutex_exit(&ph_data->p_mutex);
715 mutex_enter(&ph_data->p_mutex);
720 "usba_drain_cbs done: ph_data=0x%p ref=%d req=%d",
721 (void *)ph_data, ph_impl->usba_ph_ref_count, ph_data->p_req_count);
779 usba_pipe_handle_data_t *ph_data;
850 if ((ph_data = kmem_zalloc(size, kmflag)) == NULL) {
867 kmem_free(ph_data, size);
872 ph_impl->usba_ph_data = ph_data;
878 mutex_enter(&ph_data->p_mutex);
879 ph_data->p_spec_flag |= USBA_PH_FLAG_TQ_SHARE;
880 mutex_exit(&ph_data->p_mutex);
893 ph_data = ph_impl->usba_ph_data;
898 if ((rval = usba_device->usb_hcdi_ops->usba_hcdi_pipe_open(ph_data,
900 usba_destroy_pipe_handle(ph_data);
907 mutex_enter(&ph_data->p_mutex);
908 usba_pipe_new_state(ph_data, USB_PIPE_STATE_IDLE);
909 mutex_exit(&ph_data->p_mutex);
914 (void *)ph_impl, (void *)ph_data);
965 usba_pipe_handle_data_t *ph_data;
1009 if ((ph_data = usba_hold_ph_data(pipe_handle)) == NULL) {
1022 mutex_enter(&ph_data->p_mutex);
1024 if (USBA_IS_DEFAULT_PIPE(ph_data) &&
1028 mutex_exit(&ph_data->p_mutex);
1044 mutex_exit(&ph_data->p_mutex);
1057 usba_pipe_handle_data_t *ph_data = usba_get_ph_data(
1070 "usba_pipe_sync_close: dip=0x%p ph_data=0x%p state=%d ref=%d",
1071 (void *)dip, (void *)ph_data, ph_impl->usba_ph_state,
1078 if ((ph_data == NULL) ||
1094 mutex_enter(&ph_data->p_mutex);
1097 attribute = ph_data->p_ep.bmAttributes & USB_EP_ATTR_MASK;
1098 dir = ph_data->p_ep.bEndpointAddress & USB_EP_DIR_MASK;
1100 usba_device = ph_data->p_usba_device;
1111 if ((ph_data->p_req_count == 0) &&
1122 } else if ((ph_data->p_req_count == 0) &&
1129 mutex_exit(&ph_data->p_mutex);
1131 mutex_enter(&ph_data->p_mutex);
1137 mutex_exit(&ph_data->p_mutex);
1146 (void) usba_device->usb_hcdi_ops->usba_hcdi_pipe_reset(ph_data,
1149 mutex_enter(&ph_data->p_mutex);
1150 draining_succeeded = usba_drain_cbs(ph_data, USB_CB_RESET_PIPE,
1154 mutex_exit(&ph_data->p_mutex);
1160 if (usba_device->usb_hcdi_ops->usba_hcdi_pipe_close(ph_data,
1167 usba_destroy_pipe_handle(ph_data);
1180 usba_pipe_handle_data_t *ph_data = usba_hold_ph_data(pipe_handle);
1185 if (ph_data == NULL) {
1189 if (USBA_IS_DEFAULT_PIPE(ph_data)) {
1190 usba_release_ph_data(ph_data->p_ph_impl);
1195 mutex_enter(&ph_data->p_mutex);
1196 ph_data->p_client_private = data;
1197 mutex_exit(&ph_data->p_mutex);
1199 usba_release_ph_data(ph_data->p_ph_impl);
1212 usba_pipe_handle_data_t *ph_data = usba_hold_ph_data(pipe_handle);
1218 if (ph_data == NULL) {
1223 mutex_enter(&ph_data->p_mutex);
1224 data = ph_data->p_client_private;
1225 mutex_exit(&ph_data->p_mutex);
1227 usba_release_ph_data(ph_data->p_ph_impl);
1255 usba_pipe_handle_data_t *ph_data = usba_hold_ph_data(pipe_handle);
1264 if ((dip == NULL) || (ph_data == NULL)) {
1293 mutex_enter(&ph_data->p_mutex);
1296 if (USBA_IS_DEFAULT_PIPE(ph_data)) {
1300 mutex_exit(&ph_data->p_mutex);
1315 mutex_exit(&ph_data->p_mutex);
1331 usba_pipe_handle_data_t *ph_data = usba_get_ph_data((usb_pipe_handle_t)
1336 "usba_pipe_sync_reset: dip=0x%p ph_data=0x%p uf=0x%x",
1337 (void *)dip, (void *)ph_data, usb_flags);
1339 mutex_enter(&ph_data->p_mutex);
1340 usba_device = ph_data->p_usba_device;
1341 mutex_exit(&ph_data->p_mutex);
1343 rval = usba_device->usb_hcdi_ops->usba_hcdi_pipe_reset(ph_data,
1345 mutex_enter(&ph_data->p_mutex);
1350 draining_succeeded = usba_drain_cbs(ph_data, USB_CB_RESET_PIPE,
1356 usba_pipe_new_state(ph_data, USB_PIPE_STATE_IDLE);
1357 mutex_exit(&ph_data->p_mutex);
1363 usba_start_next_req(ph_data);
1378 usba_pipe_handle_data_t *ph_data = usba_get_ph_data(pipe_handle);
1384 "usba_pipe_clear: ph_data=0x%p", (void *)ph_data);
1386 if (ph_data == NULL) {
1391 mutex_enter(&ph_data->p_mutex);
1392 if (USBA_PIPE_CLOSING(usba_get_ph_state(ph_data))) {
1393 mutex_exit(&ph_data->p_mutex);
1397 usba_device = ph_data->p_usba_device;
1398 mutex_exit(&ph_data->p_mutex);
1400 (void) usba_device->usb_hcdi_ops->usba_hcdi_pipe_reset(ph_data,
1403 mutex_enter(&ph_data->p_mutex);
1404 if (ph_data->p_dip) {
1405 if (USBA_IS_DEFAULT_PIPE(ph_data)) {
1417 usba_rm_first_pvt_from_list(&ph_data->p_queue)) != NULL) {
1418 mutex_exit(&ph_data->p_mutex);
1421 mutex_enter(&ph_data->p_mutex);
1425 usba_pipe_new_state(ph_data, USB_PIPE_STATE_IDLE);
1426 mutex_exit(&ph_data->p_mutex);
1470 usba_pipe_handle_data_t *ph_data = usba_hold_ph_data(pipe_handle);
1473 "usb_pipe_drain_reqs: dip=0x%p ph_data=0x%p tm=%d uf=0x%x",
1474 (void *)dip, (void *)ph_data, time, usb_flags);
1476 if (ph_data == NULL) {
1520 usba_pipe_handle_data_t *ph_data = usba_get_ph_data((usb_pipe_handle_t)
1526 mutex_enter(&ph_data->p_mutex);
1530 "dip=0x%p ph_data=0x%p timeout=%d ref=%d req=%d",
1531 (void *)dip, (void *)ph_data, timeout,
1532 usba_get_ph_ref_count(ph_data),
1533 ph_data->p_req_count);
1535 ASSERT(ph_data->p_req_count >= 0);
1545 if (USBA_IS_DEFAULT_PIPE(ph_data)) {
1549 ph_data->p_active_cntrl_req_wrp;
1556 mutex_enter(&ph_data->p_queue.list_mutex);
1557 next = ph_data->p_queue.next;
1573 mutex_exit(&ph_data->p_queue.list_mutex);
1582 count, (void *)ph_data->p_active_cntrl_req_wrp);
1584 mutex_exit(&ph_data->p_mutex);
1586 mutex_enter(&ph_data->p_mutex);
1589 mutex_enter(&ph_data->p_ph_impl->usba_ph_mutex);
1591 ASSERT(ph_data->p_req_count >= 0);
1592 if (ph_data->p_req_count ||
1593 (ph_data->p_ph_impl->usba_ph_ref_count > 1)) {
1594 mutex_exit(&ph_data->p_ph_impl->usba_ph_mutex);
1595 mutex_exit(&ph_data->p_mutex);
1597 mutex_enter(&ph_data->p_mutex);
1598 mutex_enter(&ph_data->p_ph_impl->usba_ph_mutex);
1603 mutex_exit(&ph_data->p_ph_impl->usba_ph_mutex);
1608 i, (void *)ph_data->p_active_cntrl_req_wrp, ph_data->p_req_count);
1610 mutex_exit(&ph_data->p_mutex);