Lines Matching defs:ecmp
79 static int usbecm_usb_init(usbecm_state_t *ecmp);
80 static int usbecm_mac_init(usbecm_state_t *ecmp);
81 static int usbecm_mac_fini(usbecm_state_t *ecmp);
86 static int usbecm_rx_start(usbecm_state_t *ecmp);
88 static void usbecm_pipe_start_polling(usbecm_state_t *ecmp);
91 static void usbecm_parse_intr_data(usbecm_state_t *ecmp, mblk_t *data);
96 static int usbecm_open_pipes(usbecm_state_t *ecmp);
97 static void usbecm_close_pipes(usbecm_state_t *ecmp);
99 static int usbecm_ctrl_read(usbecm_state_t *ecmp, uchar_t request,
101 static int usbecm_ctrl_write(usbecm_state_t *ecmp, uchar_t request,
103 static int usbecm_send_data(usbecm_state_t *ecmp, mblk_t *data);
104 static int usbecm_send_zero_data(usbecm_state_t *ecmp);
105 static int usbecm_get_statistics(usbecm_state_t *ecmp, uint32_t fs,
108 static int usbecm_create_pm_components(usbecm_state_t *ecmp);
109 static void usbecm_destroy_pm_components(usbecm_state_t *ecmp);
111 static void usbecm_pm_set_busy(usbecm_state_t *ecmp);
112 static void usbecm_pm_set_idle(usbecm_state_t *ecmp);
117 static int usbecm_suspend(usbecm_state_t *ecmp);
118 static int usbecm_resume(usbecm_state_t *ecmp);
119 static int usbecm_restore_device_state(usbecm_state_t *ecmp);
120 static void usbecm_cleanup(usbecm_state_t *ecmp);
153 #define ECM_DS_OP_VALID(op) ((ecmp->ecm_ds_ops) && (ecmp->ecm_ds_ops->op))
247 usbecm_state_t *ecmp = NULL;
254 ecmp = (usbecm_state_t *)ddi_get_soft_state(usbecm_statep,
257 (void) usbecm_resume(ecmp);
268 ecmp = ddi_get_soft_state(usbecm_statep, instance);
270 if (ecmp == NULL) {
276 ecmp->ecm_dip = dip;
278 ecmp->ecm_lh = usb_alloc_log_hdl(ecmp->ecm_dip, "usbecm",
281 if (usbecm_usb_init(ecmp) != USB_SUCCESS) {
282 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
289 if (ecmp->ecm_ds_ops->ecm_ds_init(ecmp) != USB_SUCCESS) {
290 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
297 if (usbecm_mac_init(ecmp) != DDI_SUCCESS) {
298 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
303 ecmp->ecm_init_flags |= USBECM_INIT_MAC;
314 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
321 usbecm_pm_set_busy(ecmp);
325 USB_DPRINTF_L4(PRINT_MASK_ATTA, ecmp->ecm_lh,
331 USB_DPRINTF_L1(PRINT_MASK_ATTA, ecmp->ecm_lh,
334 usbecm_cleanup(ecmp);
352 usbecm_state_t *ecmp = NULL;
356 ecmp = ddi_get_soft_state(usbecm_statep, instance);
357 ASSERT(ecmp != NULL);
359 USB_DPRINTF_L4(PRINT_MASK_ATTA, ecmp->ecm_lh,
368 return (usbecm_suspend(ecmp));
374 usbecm_pm_set_idle(ecmp);
377 if (ecmp->ecm_ds_ops->ecm_ds_fini(ecmp) != USB_SUCCESS) {
378 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
385 if (usbecm_mac_fini(ecmp) != 0) {
390 USB_DPRINTF_L4(PRINT_MASK_ATTA, ecmp->ecm_lh,
393 usbecm_cleanup(ecmp);
410 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
415 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
426 mutex_enter(&ecmp->ecm_mutex);
427 if (ecmp->ecm_stat.es_downspeed) {
428 *val = ecmp->ecm_stat.es_downspeed;
432 mutex_exit(&ecmp->ecm_mutex);
539 mutex_enter(&ecmp->ecm_mutex);
540 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
541 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
544 mutex_exit(&ecmp->ecm_mutex);
548 mutex_exit(&ecmp->ecm_mutex);
550 rval = usbecm_get_statistics(ecmp,
553 mutex_enter(&ecmp->ecm_mutex);
556 *val = ecmp->ecm_stat.es_ierrors;
560 *val = ecmp->ecm_stat.es_oerrors;
564 *val = ecmp->ecm_stat.es_ibytes;
568 *val = ecmp->ecm_stat.es_ipackets;
572 *val = ecmp->ecm_stat.es_obytes;
576 *val = ecmp->ecm_stat.es_opackets;
580 *val = ecmp->ecm_stat.es_multircv;
584 *val = ecmp->ecm_stat.es_multixmt;
588 *val = ecmp->ecm_stat.es_brdcstrcv;
592 *val = ecmp->ecm_stat.es_brdcstxmt;
596 *val = ecmp->ecm_stat.es_macxmt_err;
603 mutex_exit(&ecmp->ecm_mutex);
608 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
627 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
630 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
633 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
634 mutex_enter(&ecmp->ecm_mutex);
635 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
636 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
639 mutex_exit(&ecmp->ecm_mutex);
643 mutex_exit(&ecmp->ecm_mutex);
645 if (usbecm_open_pipes(ecmp) != USB_SUCCESS) {
646 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
653 mutex_enter(&ecmp->ecm_mutex);
654 if (usbecm_rx_start(ecmp) != USB_SUCCESS) {
655 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
657 mutex_exit(&ecmp->ecm_mutex);
662 ecmp->ecm_mac_state = USBECM_MAC_STARTED;
663 mutex_exit(&ecmp->ecm_mutex);
666 rval = usbecm_ctrl_write(ecmp, CDC_ECM_SET_ETH_PKT_FLT,
670 USB_DPRINTF_L3(PRINT_MASK_OPS, ecmp->ecm_lh,
676 if (ecmp->ecm_ds_ops->ecm_ds_start(ecmp) != USB_SUCCESS) {
677 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
684 usb_release_access(ecmp->ecm_ser_acc);
686 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
696 mac_link_update(ecmp->ecm_mh, LINK_STATE_UP);
697 mutex_enter(&ecmp->ecm_mutex);
698 ecmp->ecm_stat.es_linkstate = LINK_STATE_UP;
699 mutex_exit(&ecmp->ecm_mutex);
703 usb_release_access(ecmp->ecm_ser_acc);
714 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
716 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
719 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
721 if (ecmp->ecm_ds_ops->ecm_ds_stop(ecmp) != USB_SUCCESS) {
722 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
727 usbecm_close_pipes(ecmp);
728 usb_release_access(ecmp->ecm_ser_acc);
730 mutex_enter(&ecmp->ecm_mutex);
731 ecmp->ecm_mac_state = USBECM_MAC_STOPPED;
732 mutex_exit(&ecmp->ecm_mutex);
734 mac_link_update(ecmp->ecm_mh, LINK_STATE_DOWN);
735 mutex_enter(&ecmp->ecm_mutex);
736 ecmp->ecm_stat.es_linkstate = LINK_STATE_DOWN;
737 mutex_exit(&ecmp->ecm_mutex);
739 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
750 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
754 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
763 if (bcmp(macaddr, ecmp->ecm_srcaddr, ETHERADDRL) != 0) {
764 USB_DPRINTF_L3(PRINT_MASK_OPS, ecmp->ecm_lh,
770 mutex_enter(&ecmp->ecm_mutex);
771 filter = ecmp->ecm_pkt_flt |= CDC_ECM_PKT_TYPE_DIRECTED;
772 mutex_exit(&ecmp->ecm_mutex);
774 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
775 rval = usbecm_ctrl_write(ecmp, CDC_ECM_SET_ETH_PKT_FLT,
777 usb_release_access(ecmp->ecm_ser_acc);
779 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
793 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
797 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
799 mutex_enter(&ecmp->ecm_mutex);
806 ecmp->ecm_pkt_flt |= CDC_ECM_PKT_TYPE_ALL_MCAST;
808 ecmp->ecm_pkt_flt &= ~CDC_ECM_PKT_TYPE_ALL_MCAST;
810 filter = ecmp->ecm_pkt_flt;
811 mutex_exit(&ecmp->ecm_mutex);
813 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
814 if (ecmp->ecm_compatibility &&
815 (ecmp->ecm_desc.wNumberMCFilters & 0x7F)) {
817 rval = usbecm_ctrl_write(ecmp, CDC_ECM_SET_ETH_PKT_FLT,
819 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
822 usb_release_access(ecmp->ecm_ser_acc);
834 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
838 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
841 mutex_enter(&ecmp->ecm_mutex);
842 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
843 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
845 mutex_exit(&ecmp->ecm_mutex);
852 ecmp->ecm_pkt_flt |= CDC_ECM_PKT_TYPE_PROMISC;
854 ecmp->ecm_pkt_flt &= ~CDC_ECM_PKT_TYPE_PROMISC;
856 filter = ecmp->ecm_pkt_flt;
857 mutex_exit(&ecmp->ecm_mutex);
859 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
860 rval = usbecm_ctrl_write(ecmp, CDC_ECM_SET_ETH_PKT_FLT,
862 usb_release_access(ecmp->ecm_ser_acc);
864 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
882 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
886 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
889 mutex_enter(&ecmp->ecm_mutex);
890 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
891 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
893 mutex_exit(&ecmp->ecm_mutex);
899 mutex_exit(&ecmp->ecm_mutex);
905 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
909 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
911 usb_release_access(ecmp->ecm_ser_acc);
928 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
931 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
941 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
944 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
947 mutex_enter(&ecmp->ecm_mutex);
948 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
949 mutex_exit(&ecmp->ecm_mutex);
953 mutex_exit(&ecmp->ecm_mutex);
964 usbecm_state_t *ecmp = (usbecm_state_t *)arg;
970 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
973 mutex_enter(&ecmp->ecm_mutex);
974 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
975 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
977 mutex_exit(&ecmp->ecm_mutex);
981 mutex_exit(&ecmp->ecm_mutex);
983 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
993 if (usbecm_send_data(ecmp, mp) != DDI_SUCCESS) {
994 USB_DPRINTF_L3(PRINT_MASK_OPS, ecmp->ecm_lh,
998 mutex_enter(&ecmp->ecm_mutex);
999 ecmp->ecm_stat.es_oerrors++;
1000 mutex_exit(&ecmp->ecm_mutex);
1011 mutex_enter(&ecmp->ecm_mutex);
1012 ecmp->ecm_stat.es_opackets++;
1013 ecmp->ecm_stat.es_obytes += MBLKL(mp);
1014 mutex_exit(&ecmp->ecm_mutex);
1019 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1023 usb_release_access(ecmp->ecm_ser_acc);
1038 usbecm_state_t *ecmp = (usbecm_state_t *)req->bulk_client_private;
1041 int max_pkt_size = ecmp->ecm_bulkin_sz;
1048 mutex_enter(&ecmp->ecm_mutex);
1050 USB_DPRINTF_L4(PRINT_MASK_CB, ecmp->ecm_lh,
1051 "usbecm_bulkin_cb: state=%d, len=%d", ecmp->ecm_bulkin_state,
1058 if ((ecmp->ecm_dev_state == USB_DEV_ONLINE) &&
1061 if (ecmp->ecm_rcv_queue == NULL) {
1062 ecmp->ecm_rcv_queue = data;
1064 if ((msgsize(ecmp->ecm_rcv_queue) + data_len)
1071 freemsg(ecmp->ecm_rcv_queue);
1072 ecmp->ecm_rcv_queue = data;
1074 linkb(ecmp->ecm_rcv_queue, data);
1092 (msgsize(ecmp->ecm_rcv_queue) > 0)) {
1093 mp = msgpullup(ecmp->ecm_rcv_queue, -1);
1094 freemsg(ecmp->ecm_rcv_queue);
1095 ecmp->ecm_rcv_queue = NULL;
1097 ecmp->ecm_stat.es_ipackets++;
1098 ecmp->ecm_stat.es_ibytes += msgsize(mp);
1102 ecmp->ecm_stat.es_multircv++;
1104 ecmp->ecm_stat.es_brdcstrcv++;
1109 mutex_exit(&ecmp->ecm_mutex);
1110 mac_rx(ecmp->ecm_mh, NULL, mp);
1111 mutex_enter(&ecmp->ecm_mutex);
1118 ecmp->ecm_stat.es_ierrors++;
1120 mutex_exit(&ecmp->ecm_mutex);
1125 mutex_enter(&ecmp->ecm_mutex);
1126 if (((ecmp->ecm_bulkin_state == USBECM_PIPE_BUSY) ||
1127 (ecmp->ecm_bulkin_state == USBECM_PIPE_IDLE)) &&
1128 (ecmp->ecm_dev_state == USB_DEV_ONLINE)) {
1129 if (usbecm_rx_start(ecmp) != USB_SUCCESS) {
1130 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1132 "ecmp_state = %d", ecmp->ecm_bulkin_state);
1134 } else if (ecmp->ecm_bulkin_state == USBECM_PIPE_BUSY) {
1135 ecmp->ecm_bulkin_state = USBECM_PIPE_IDLE;
1137 mutex_exit(&ecmp->ecm_mutex);
1145 usbecm_rx_start(usbecm_state_t *ecmp)
1151 ASSERT(mutex_owned(&ecmp->ecm_mutex));
1153 DTRACE_PROBE2(usbecm_rx__start, int, ecmp->ecm_xfer_sz,
1154 int, ecmp->ecm_bulkin_sz);
1156 ecmp->ecm_bulkin_state = USBECM_PIPE_BUSY;
1157 data_len = ecmp->ecm_bulkin_sz;
1159 mutex_exit(&ecmp->ecm_mutex);
1160 br = usb_alloc_bulk_req(ecmp->ecm_dip, data_len, USB_FLAGS_SLEEP);
1162 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1165 mutex_enter(&ecmp->ecm_mutex);
1174 br->bulk_client_private = (usb_opaque_t)ecmp;
1178 rval = usb_pipe_bulk_xfer(ecmp->ecm_bulkin_ph, br, 0);
1179 mutex_enter(&ecmp->ecm_mutex);
1181 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1184 ecmp->ecm_bulkin_state = USBECM_PIPE_IDLE;
1200 usbecm_state_t *ecmp = (usbecm_state_t *)req->bulk_client_private;
1206 USB_DPRINTF_L4(PRINT_MASK_CB, ecmp->ecm_lh,
1210 mutex_enter(&ecmp->ecm_mutex);
1211 if ((data_len > 0) && (ecmp->ecm_tx_cnt > 0)) {
1212 if (ecmp->ecm_tx_cnt == usbecm_tx_max) {
1215 ecmp->ecm_tx_cnt--;
1217 mutex_exit(&ecmp->ecm_mutex);
1220 mutex_enter(&ecmp->ecm_mutex);
1221 ecmp->ecm_stat.es_oerrors++;
1222 mutex_exit(&ecmp->ecm_mutex);
1232 mac_tx_update(ecmp->ecm_mh);
1239 usbecm_send_data(usbecm_state_t *ecmp, mblk_t *data)
1248 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1252 mutex_enter(&ecmp->ecm_mutex);
1253 if (ecmp->ecm_tx_cnt >= usbecm_tx_max) {
1254 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1256 ecmp->ecm_tx_cnt);
1257 mutex_exit(&ecmp->ecm_mutex);
1261 mutex_exit(&ecmp->ecm_mutex);
1265 mutex_enter(&ecmp->ecm_mutex);
1266 ecmp->ecm_stat.es_macxmt_err++;
1267 mutex_exit(&ecmp->ecm_mutex);
1269 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1278 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1283 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1297 br = usb_alloc_bulk_req(ecmp->ecm_dip, 0, USB_FLAGS_SLEEP);
1299 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1314 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1320 br->bulk_client_private = (usb_opaque_t)ecmp;
1325 mutex_enter(&ecmp->ecm_mutex);
1328 ecmp->ecm_stat.es_multixmt++;
1330 ecmp->ecm_stat.es_brdcstxmt++;
1332 mutex_exit(&ecmp->ecm_mutex);
1334 rval = usb_pipe_bulk_xfer(ecmp->ecm_bulkout_ph, br, 0);
1338 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1348 mutex_enter(&ecmp->ecm_mutex);
1349 ecmp->ecm_tx_cnt++;
1350 mutex_exit(&ecmp->ecm_mutex);
1358 max_pkt_size = ecmp->ecm_bulk_out_ep->ep_descr.wMaxPacketSize;
1360 if ((rval = usbecm_send_zero_data(ecmp))
1362 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1372 USB_DPRINTF_L4(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1380 usbecm_send_zero_data(usbecm_state_t *ecmp)
1385 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1388 br = usb_alloc_bulk_req(ecmp->ecm_dip, 0, USB_FLAGS_SLEEP);
1390 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1401 br->bulk_client_private = (usb_opaque_t)ecmp;
1404 rval = usb_pipe_bulk_xfer(ecmp->ecm_bulkout_ph, br, 0);
1407 USB_DPRINTF_L2(PRINT_MASK_OPS, ecmp->ecm_lh,
1419 USB_DPRINTF_L4(PRINT_MASK_OPS, ecmp->ecm_lh,
1490 usbecm_pipe_start_polling(usbecm_state_t *ecmp)
1495 USB_DPRINTF_L4(PRINT_MASK_OPEN, ecmp->ecm_lh,
1498 if (ecmp->ecm_intr_ph == NULL) {
1503 intr = usb_alloc_intr_req(ecmp->ecm_dip, 0, USB_FLAGS_SLEEP);
1510 USB_DPRINTF_L2(PRINT_MASK_OPEN, ecmp->ecm_lh,
1519 intr->intr_len = ecmp->ecm_intr_ep->ep_descr.wMaxPacketSize;
1520 intr->intr_client_private = (usb_opaque_t)ecmp;
1524 rval = usb_pipe_intr_xfer(ecmp->ecm_intr_ph, intr, USB_FLAGS_SLEEP);
1526 mutex_enter(&ecmp->ecm_mutex);
1528 ecmp->ecm_intr_state = USBECM_PIPE_BUSY;
1531 ecmp->ecm_intr_state = USBECM_PIPE_IDLE;
1532 USB_DPRINTF_L3(PRINT_MASK_OPEN, ecmp->ecm_lh,
1535 mutex_exit(&ecmp->ecm_mutex);
1537 USB_DPRINTF_L3(PRINT_MASK_OPEN, ecmp->ecm_lh,
1550 usbecm_state_t *ecmp = (usbecm_state_t *)req->intr_client_private;
1560 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1569 mutex_enter(&ecmp->ecm_mutex);
1571 usbecm_parse_intr_data(ecmp, data);
1572 mutex_exit(&ecmp->ecm_mutex);
1584 usbecm_state_t *ecmp = (usbecm_state_t *)req->intr_client_private;
1587 DTRACE_PROBE2(usbecm_intr_ex__cb, int, ecmp->ecm_dev_state,
1597 mutex_enter(&ecmp->ecm_mutex);
1599 if (ecmp->ecm_dev_state != USB_DEV_ONLINE) {
1601 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1603 ecmp->ecm_dev_state);
1605 mutex_exit(&ecmp->ecm_mutex);
1609 mutex_exit(&ecmp->ecm_mutex);
1611 usbecm_pipe_start_polling(ecmp);
1621 usbecm_parse_intr_data(usbecm_state_t *ecmp, mblk_t *data)
1639 if (ecmp->ecm_compatibility) {
1641 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1652 if (ecmp->ecm_ds_ops->ecm_ds_intr_cb(ecmp, data)
1654 USB_DPRINTF_L2(PRINT_MASK_CB, ecmp->ecm_lh,
1669 USB_DPRINTF_L3(PRINT_MASK_CB, ecmp->ecm_lh,
1674 if (ecmp->ecm_stat.es_linkstate == linkstate) {
1679 ecmp->ecm_stat.es_linkstate = linkstate;
1680 mutex_exit(&ecmp->ecm_mutex);
1681 mac_link_update(ecmp->ecm_mh, linkstate);
1682 mutex_enter(&ecmp->ecm_mutex);
1686 USB_DPRINTF_L3(PRINT_MASK_CB, ecmp->ecm_lh,
1691 USB_DPRINTF_L3(PRINT_MASK_CB, ecmp->ecm_lh,
1696 USB_DPRINTF_L3(PRINT_MASK_CB, ecmp->ecm_lh,
1706 ecmp->ecm_stat.es_upspeed = us_rate;
1707 ecmp->ecm_stat.es_downspeed = ds_rate;
1712 USB_DPRINTF_L3(PRINT_MASK_CB, ecmp->ecm_lh,
1727 usbecm_restore_device_state(usbecm_state_t *ecmp)
1731 USB_DPRINTF_L4(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1734 mutex_enter(&ecmp->ecm_mutex);
1735 state = ecmp->ecm_dev_state;
1736 mutex_exit(&ecmp->ecm_mutex);
1745 if (usb_check_same_device(ecmp->ecm_dip, ecmp->ecm_lh, USB_LOG_L0,
1747 mutex_enter(&ecmp->ecm_mutex);
1748 state = ecmp->ecm_dev_state = USB_DEV_DISCONNECTED;
1749 mutex_exit(&ecmp->ecm_mutex);
1755 USB_DPRINTF_L1(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1761 mutex_enter(&ecmp->ecm_mutex);
1762 if (ecmp->ecm_mac_state == USBECM_MAC_STARTED) {
1763 USB_DPRINTF_L3(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1766 mutex_exit(&ecmp->ecm_mutex);
1768 if (usbecm_open_pipes(ecmp) != USB_SUCCESS) {
1773 mutex_enter(&ecmp->ecm_mutex);
1774 if (usbecm_rx_start(ecmp) != USB_SUCCESS) {
1775 mutex_exit(&ecmp->ecm_mutex);
1780 mutex_exit(&ecmp->ecm_mutex);
1785 mutex_enter(&ecmp->ecm_mutex);
1786 state = ecmp->ecm_dev_state = USB_DEV_ONLINE;
1787 mutex_exit(&ecmp->ecm_mutex);
1800 usbecm_state_t *ecmp =
1804 ASSERT(ecmp != NULL);
1806 USB_DPRINTF_L4(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1809 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
1811 mutex_enter(&ecmp->ecm_mutex);
1812 ASSERT(ecmp->ecm_dev_state == USB_DEV_DISCONNECTED);
1814 mutex_exit(&ecmp->ecm_mutex);
1816 if (usbecm_restore_device_state(ecmp) != USB_DEV_ONLINE) {
1817 usb_release_access(ecmp->ecm_ser_acc);
1822 usb_release_access(ecmp->ecm_ser_acc);
1836 usbecm_state_t *ecmp = (usbecm_state_t *)ddi_get_soft_state(
1839 USB_DPRINTF_L4(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1842 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
1844 mutex_enter(&ecmp->ecm_mutex);
1845 ecmp->ecm_dev_state = USB_DEV_DISCONNECTED;
1846 mutex_exit(&ecmp->ecm_mutex);
1848 usbecm_close_pipes(ecmp);
1850 usb_release_access(ecmp->ecm_ser_acc);
1852 USB_DPRINTF_L4(PRINT_MASK_EVENTS, ecmp->ecm_lh,
1866 usbecm_create_pm_components(usbecm_state_t *ecmp)
1868 dev_info_t *dip = ecmp->ecm_dip;
1872 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
1876 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
1883 pm = ecmp->ecm_pm =
1901 usbecm_cleanup(usbecm_state_t *ecmp)
1903 USB_DPRINTF_L4(PRINT_MASK_CLOSE, ecmp->ecm_lh,
1906 if (ecmp == NULL) {
1911 usbecm_close_pipes(ecmp);
1914 if (ecmp->ecm_init_flags & USBECM_INIT_EVENTS) {
1915 USB_DPRINTF_L4(PRINT_MASK_CLOSE, ecmp->ecm_lh,
1918 usb_unregister_event_cbs(ecmp->ecm_dip, &usbecm_events);
1922 if (ecmp->ecm_pm != NULL) {
1923 USB_DPRINTF_L4(PRINT_MASK_CLOSE, ecmp->ecm_lh,
1925 usbecm_destroy_pm_components(ecmp);
1929 if (ecmp->ecm_def_ph != NULL) {
1930 mutex_destroy(&ecmp->ecm_mutex);
1932 usb_free_descr_tree(ecmp->ecm_dip, ecmp->ecm_dev_data);
1933 ecmp->ecm_def_ph = NULL;
1936 if (ecmp->ecm_lh != NULL) {
1937 usb_free_log_hdl(ecmp->ecm_lh);
1938 ecmp->ecm_lh = NULL;
1942 if (ecmp->ecm_dev_data != NULL) {
1943 usb_client_detach(ecmp->ecm_dip, ecmp->ecm_dev_data);
1946 if (ecmp->ecm_init_flags & USBECM_INIT_MAC) {
1947 (void) usbecm_mac_fini(ecmp);
1950 if (ecmp->ecm_init_flags & USBECM_INIT_SER) {
1951 usb_fini_serialization(ecmp->ecm_ser_acc);
1954 ddi_prop_remove_all(ecmp->ecm_dip);
1955 ddi_remove_minor_node(ecmp->ecm_dip, NULL);
1963 usbecm_destroy_pm_components(usbecm_state_t *ecmp)
1965 usbecm_pm_t *pm = ecmp->ecm_pm;
1966 dev_info_t *dip = ecmp->ecm_dip;
1969 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
1972 if (ecmp->ecm_dev_state != USB_DEV_DISCONNECTED) {
1976 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
1984 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
1993 ecmp->ecm_pm = NULL;
2001 usbecm_pm_set_busy(usbecm_state_t *ecmp)
2003 usbecm_pm_t *pm = ecmp->ecm_pm;
2004 dev_info_t *dip = ecmp->ecm_dip;
2007 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
2015 mutex_enter(&ecmp->ecm_mutex);
2018 mutex_exit(&ecmp->ecm_mutex);
2026 mutex_exit(&ecmp->ecm_mutex);
2033 mutex_exit(&ecmp->ecm_mutex);
2037 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
2041 mutex_enter(&ecmp->ecm_mutex);
2043 mutex_exit(&ecmp->ecm_mutex);
2052 usbecm_pm_set_idle(usbecm_state_t *ecmp)
2054 usbecm_pm_t *pm = ecmp->ecm_pm;
2055 dev_info_t *dip = ecmp->ecm_dip;
2057 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
2065 mutex_enter(&ecmp->ecm_mutex);
2067 mutex_exit(&ecmp->ecm_mutex);
2075 mutex_exit(&ecmp->ecm_mutex);
2085 usbecm_pwrlvl0(usbecm_state_t *ecmp)
2089 ASSERT(mutex_owned(&ecmp->ecm_mutex));
2091 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
2094 switch (ecmp->ecm_dev_state) {
2097 rval = usb_set_device_pwrlvl3(ecmp->ecm_dip);
2099 if ((ecmp->ecm_intr_ph != NULL) &&
2100 (ecmp->ecm_intr_state == USBECM_PIPE_BUSY)) {
2101 mutex_exit(&ecmp->ecm_mutex);
2102 usb_pipe_stop_intr_polling(ecmp->ecm_intr_ph,
2104 mutex_enter(&ecmp->ecm_mutex);
2106 ecmp->ecm_intr_state = USBECM_PIPE_IDLE;
2108 ecmp->ecm_dev_state = USB_DEV_PWRED_DOWN;
2109 ecmp->ecm_pm->pm_cur_power = USB_DEV_OS_PWR_OFF;
2119 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
2132 usbecm_pwrlvl1(usbecm_state_t *ecmp)
2135 (void) usb_set_device_pwrlvl2(ecmp->ecm_dip);
2146 usbecm_pwrlvl2(usbecm_state_t *ecmp)
2149 (void) usb_set_device_pwrlvl1(ecmp->ecm_dip);
2161 usbecm_pwrlvl3(usbecm_state_t *ecmp)
2165 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
2168 ASSERT(mutex_owned(&ecmp->ecm_mutex));
2170 switch (ecmp->ecm_dev_state) {
2173 rval = usb_set_device_pwrlvl0(ecmp->ecm_dip);
2176 if (ecmp->ecm_intr_ph != NULL &&
2177 ecmp->ecm_intr_state == USBECM_PIPE_IDLE) {
2178 mutex_exit(&ecmp->ecm_mutex);
2179 usbecm_pipe_start_polling(ecmp);
2180 mutex_enter(&ecmp->ecm_mutex);
2183 ecmp->ecm_dev_state = USB_DEV_ONLINE;
2184 ecmp->ecm_pm->pm_cur_power = USB_DEV_OS_FULL_PWR;
2196 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
2207 usbecm_state_t *ecmp;
2211 ecmp = ddi_get_soft_state(usbecm_statep, ddi_get_instance(dip));
2212 pm = ecmp->ecm_pm;
2214 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
2219 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
2225 mutex_enter(&ecmp->ecm_mutex);
2230 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
2234 mutex_exit(&ecmp->ecm_mutex);
2243 USB_DPRINTF_L2(PRINT_MASK_PM, ecmp->ecm_lh,
2245 mutex_exit(&ecmp->ecm_mutex);
2255 rval = usbecm_pwrlvl0(ecmp);
2259 rval = usbecm_pwrlvl1(ecmp);
2263 rval = usbecm_pwrlvl2(ecmp);
2267 rval = usbecm_pwrlvl3(ecmp);
2272 mutex_exit(&ecmp->ecm_mutex);
2281 usbecm_mac_init(usbecm_state_t *ecmp)
2291 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2301 macp->m_driver = ecmp;
2302 macp->m_dip = ecmp->ecm_dip;
2304 macp->m_src_addr = ecmp->ecm_srcaddr;
2312 err = mac_register(macp, &ecmp->ecm_mh);
2316 USB_DPRINTF_L1(PRINT_MASK_ATTA, ecmp->ecm_lh,
2322 mac_link_update(ecmp->ecm_mh, LINK_STATE_DOWN);
2323 ecmp->ecm_stat.es_linkstate = LINK_STATE_DOWN;
2324 ecmp->ecm_tx_cnt = 0;
2330 usbecm_mac_fini(usbecm_state_t *ecmp)
2334 if ((ecmp->ecm_init_flags & USBECM_INIT_MAC) == 0) {
2338 ecmp->ecm_init_flags &= ~USBECM_INIT_MAC;
2339 if ((rval = mac_disable(ecmp->ecm_mh)) != 0) {
2340 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2346 (void) mac_unregister(ecmp->ecm_mh);
2352 usbecm_resume(usbecm_state_t *ecmp)
2357 USB_DPRINTF_L4(PRINT_MASK_PM, ecmp->ecm_lh,
2360 mutex_enter(&ecmp->ecm_mutex);
2361 current_state = ecmp->ecm_dev_state;
2362 mutex_exit(&ecmp->ecm_mutex);
2366 ret = usbecm_restore_device_state(ecmp);
2375 usbecm_suspend(usbecm_state_t *ecmp)
2377 (void) usb_serialize_access(ecmp->ecm_ser_acc, USB_WAIT, 0);
2379 mutex_enter(&ecmp->ecm_mutex);
2380 ecmp->ecm_dev_state = USB_DEV_SUSPENDED;
2381 mutex_exit(&ecmp->ecm_mutex);
2383 usbecm_close_pipes(ecmp);
2385 usb_release_access(ecmp->ecm_ser_acc);
2425 usbecm_get_descriptors(usbecm_state_t *ecmp)
2436 USB_DPRINTF_L4(PRINT_MASK_ATTA, ecmp->ecm_lh,
2439 usb_dev_desc = ecmp->ecm_dev_data->dev_descr;
2446 if (usb_set_cfg(ecmp->ecm_dip, ecmp->ecm_cfg_index,
2448 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2451 usb_free_dev_data(ecmp->ecm_dip, ecmp->ecm_dev_data);
2452 if (usb_get_dev_data(ecmp->ecm_dip, &ecmp->ecm_dev_data,
2454 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2463 cfg = ecmp->ecm_dev_data->dev_curr_cfg;
2466 ecmp->ecm_ctrl_if_no = ecmp->ecm_data_if_no = 0;
2469 ecmp->ecm_ctrl_if_no = ecmp->ecm_dev_data->dev_curr_if;
2470 if (cfg->cfg_if[ecmp->ecm_ctrl_if_no].if_n_alt == 0) {
2471 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2473 cfg->cfg_if[ecmp->ecm_ctrl_if_no].if_n_alt);
2478 altif = &cfg->cfg_if[ecmp->ecm_ctrl_if_no].if_alt[0];
2518 if (usb_get_string_descr(ecmp->ecm_dip,
2525 USB_DPRINTF_L3(PRINT_MASK_ATTA, ecmp->ecm_lh,
2533 label_to_mac(buf, ecmp->ecm_srcaddr);
2535 bcopy(&ecm_desc, &ecmp->ecm_desc,
2553 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2560 if (ecmp->ecm_data_if_no == 0 &&
2561 slave_if != ecmp->ecm_data_if_no) {
2562 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2566 ecmp->ecm_data_if_no = slave_if;
2569 if ((master_if != ecmp->ecm_ctrl_if_no) ||
2570 (slave_if != ecmp->ecm_data_if_no)) {
2571 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2578 if ((ecmp->ecm_ctrl_if_no >= cfg->cfg_n_if) ||
2579 (ecmp->ecm_data_if_no >= cfg->cfg_n_if)) {
2580 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2583 ecmp->ecm_ctrl_if_no, ecmp->ecm_data_if_no);
2589 if (cfg->cfg_if[ecmp->ecm_data_if_no].if_n_alt < 2) {
2590 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2592 " MUST >= 2", cfg->cfg_if[ecmp->ecm_ctrl_if_no].if_n_alt);
2598 if ((ep_data = usb_lookup_ep_data(ecmp->ecm_dip, ecmp->ecm_dev_data,
2599 ecmp->ecm_ctrl_if_no, 0, 0, USB_EP_ATTR_INTR,
2601 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2604 ecmp->ecm_data_if_no);
2608 ecmp->ecm_intr_ep = ep_data;
2611 if ((ep_data = usb_lookup_ep_data(ecmp->ecm_dip, ecmp->ecm_dev_data,
2612 ecmp->ecm_data_if_no, 1, 0, USB_EP_ATTR_BULK,
2614 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2617 ecmp->ecm_data_if_no);
2621 ecmp->ecm_bulk_in_ep = ep_data;
2623 if ((ep_data = usb_lookup_ep_data(ecmp->ecm_dip, ecmp->ecm_dev_data,
2624 ecmp->ecm_data_if_no, 1, 0, USB_EP_ATTR_BULK,
2626 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2629 ecmp->ecm_data_if_no);
2633 ecmp->ecm_bulk_out_ep = ep_data;
2636 ecmp->ecm_pkt_flt = CDC_ECM_PKT_TYPE_DIRECTED;
2653 int usbecm_find_bulk_in_out_eps(usbecm_state_t *ecmp,
2670 if (((bulk_in = usb_lookup_ep_data(ecmp->ecm_dip,
2671 ecmp->ecm_dev_data, ifc, alt, 0,
2674 (bulk_out = usb_lookup_ep_data(ecmp->ecm_dip,
2675 ecmp->ecm_dev_data, ifc, alt, 0,
2685 if ((ep = usb_lookup_ep_data(ecmp->ecm_dip,
2686 ecmp->ecm_dev_data, ifc, alt, 0,
2692 ecmp->ecm_data_if_no = ifc;
2693 ecmp->ecm_data_if_alt = alt;
2694 ecmp->ecm_intr_ep = intr_ep;
2695 ecmp->ecm_ctrl_if_no = ifc;
2696 ecmp->ecm_bulk_in_ep = bulk_in;
2697 ecmp->ecm_bulk_out_ep = bulk_out;
2706 usbecm_init_non_compatible_device(usbecm_state_t *ecmp)
2716 cur_if = ecmp->ecm_dev_data->dev_curr_cfg->cfg_if;
2717 if_num = ecmp->ecm_dev_data->dev_curr_cfg->cfg_n_if;
2721 if (usbecm_find_bulk_in_out_eps(ecmp, i,
2729 USB_DPRINTF_L4(PRINT_MASK_ATTA, ecmp->ecm_lh,
2731 " data_if=%d, alt=%d", ecmp->ecm_ctrl_if_no,
2732 ecmp->ecm_data_if_no, ecmp->ecm_data_if_alt);
2738 usbecm_is_compatible(usbecm_state_t *ecmp)
2746 cfg_num = ecmp->ecm_dev_data->dev_n_cfg;
2747 USB_DPRINTF_L3(PRINT_MASK_ATTA, ecmp->ecm_lh,
2751 cfg_data = &(ecmp->ecm_dev_data->dev_cfg[cfg_index]);
2753 USB_DPRINTF_L3(PRINT_MASK_ATTA, ecmp->ecm_lh,
2766 ecmp->ecm_cfg_index = cfg_index;
2768 USB_DPRINTF_L3(PRINT_MASK_ATTA, ecmp->ecm_lh,
2784 usbecm_usb_init(usbecm_state_t *ecmp)
2787 if (usb_client_attach(ecmp->ecm_dip, USBDRV_VERSION, 0) !=
2789 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2796 if (usb_get_dev_data(ecmp->ecm_dip, &ecmp->ecm_dev_data,
2798 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2803 ecmp->ecm_def_ph = ecmp->ecm_dev_data->dev_default_ph;
2804 ecmp->ecm_dev_state = USB_DEV_ONLINE;
2806 mutex_init(&ecmp->ecm_mutex, NULL, MUTEX_DRIVER,
2807 ecmp->ecm_dev_data->dev_iblock_cookie);
2809 if ((strcmp(ddi_binding_name(ecmp->ecm_dip),
2811 ((strcmp(ddi_binding_name(ecmp->ecm_dip),
2813 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2815 ecmp->ecm_compatibility = B_TRUE;
2816 } else if (usb_owns_device(ecmp->ecm_dip) &&
2817 usbecm_is_compatible(ecmp)) {
2825 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2827 ecmp->ecm_compatibility = B_TRUE;
2829 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2833 ecmp->ecm_compatibility = B_FALSE;
2836 generate_ether_addr(ecmp->ecm_srcaddr);
2839 if ((ecmp->ecm_compatibility == B_TRUE) &&
2840 (usbecm_get_descriptors(ecmp) != USB_SUCCESS)) {
2841 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2848 if (ecmp->ecm_compatibility == B_FALSE) {
2849 (void) usbecm_init_non_compatible_device(ecmp);
2853 if (usbecm_create_pm_components(ecmp) != USB_SUCCESS) {
2854 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2861 if (usb_register_event_cbs(ecmp->ecm_dip, &usbecm_events, 0)
2863 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2868 ecmp->ecm_init_flags |= USBECM_INIT_EVENTS;
2872 if (usb_pipe_get_max_bulk_transfer_size(ecmp->ecm_dip,
2873 &ecmp->ecm_xfer_sz) != USB_SUCCESS) {
2874 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2881 ecmp->ecm_ser_acc = usb_init_serialization(ecmp->ecm_dip,
2883 ecmp->ecm_init_flags |= USBECM_INIT_SER;
2894 usbecm_open_pipes(usbecm_state_t *ecmp)
2901 ASSERT(!mutex_owned(&ecmp->ecm_mutex));
2903 USB_DPRINTF_L4(PRINT_MASK_OPEN, ecmp->ecm_lh,
2904 "usbsecm_open_pipes: ecmp = 0x%p", (void *)ecmp);
2906 if (ecmp->ecm_compatibility == B_TRUE) {
2910 altif = ecmp->ecm_data_if_alt;
2912 intr_pipe = ecmp->ecm_intr_ep;
2913 in_data = ecmp->ecm_bulk_in_ep;
2914 out_data = ecmp->ecm_bulk_out_ep;
2918 USB_DPRINTF_L2(PRINT_MASK_OPEN, ecmp->ecm_lh,
2921 ecmp->ecm_data_if_no);
2929 if (ecmp->ecm_compatibility == B_TRUE && intr_pipe == NULL) {
2930 USB_DPRINTF_L2(PRINT_MASK_OPEN, ecmp->ecm_lh,
2932 "interface %d", ecmp->ecm_ctrl_if_no);
2937 USB_DPRINTF_L3(PRINT_MASK_OPEN, ecmp->ecm_lh,
2943 USB_DPRINTF_L3(PRINT_MASK_OPEN, ecmp->ecm_lh,
2945 ecmp->ecm_data_if_no, altif);
2947 if ((rval = usb_set_alt_if(ecmp->ecm_dip, ecmp->ecm_data_if_no,
2949 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
2959 if (usb_pipe_open(ecmp->ecm_dip, &in_data->ep_descr, &policy,
2960 USB_FLAGS_SLEEP, &ecmp->ecm_bulkin_ph) != USB_SUCCESS) {
2961 USB_DPRINTF_L2(PRINT_MASK_OPEN, ecmp->ecm_lh,
2968 if (usb_pipe_open(ecmp->ecm_dip, &out_data->ep_descr, &policy,
2969 USB_FLAGS_SLEEP, &ecmp->ecm_bulkout_ph) != USB_SUCCESS) {
2970 USB_DPRINTF_L2(PRINT_MASK_OPEN, ecmp->ecm_lh,
2973 usb_pipe_close(ecmp->ecm_dip, ecmp->ecm_bulkin_ph,
2981 if (usb_pipe_open(ecmp->ecm_dip, &intr_pipe->ep_descr, &policy,
2982 USB_FLAGS_SLEEP, &ecmp->ecm_intr_ph) != USB_SUCCESS) {
2983 USB_DPRINTF_L2(PRINT_MASK_OPEN, ecmp->ecm_lh,
2987 usb_pipe_close(ecmp->ecm_dip, ecmp->ecm_bulkin_ph,
2989 usb_pipe_close(ecmp->ecm_dip, ecmp->ecm_bulkout_ph,
2997 mutex_enter(&ecmp->ecm_mutex);
2998 ecmp->ecm_bulkin_sz = in_data->ep_descr.wMaxPacketSize;
2999 ecmp->ecm_bulkin_state = USBECM_PIPE_IDLE;
3000 ecmp->ecm_bulkout_state = USBECM_PIPE_IDLE;
3001 if (ecmp->ecm_intr_ph != NULL) {
3002 ecmp->ecm_intr_state = USBECM_PIPE_IDLE;
3004 mutex_exit(&ecmp->ecm_mutex);
3006 if (ecmp->ecm_intr_ph != NULL) {
3008 usbecm_pipe_start_polling(ecmp);
3011 USB_DPRINTF_L4(PRINT_MASK_OPEN, ecmp->ecm_lh,
3024 usbecm_close_pipes(usbecm_state_t *ecmp)
3027 mutex_enter(&ecmp->ecm_mutex);
3029 USB_DPRINTF_L4(PRINT_MASK_CLOSE, ecmp->ecm_lh,
3031 ecmp->ecm_bulkin_state);
3037 if ((ecmp->ecm_bulkin_state == USBECM_PIPE_CLOSED) ||
3038 (ecmp->ecm_bulkin_state == USBECM_PIPE_CLOSING)) {
3039 USB_DPRINTF_L2(PRINT_MASK_CLOSE, ecmp->ecm_lh,
3041 mutex_exit(&ecmp->ecm_mutex);
3046 ecmp->ecm_bulkin_state = USBECM_PIPE_CLOSING;
3047 mutex_exit(&ecmp->ecm_mutex);
3050 if ((ecmp->ecm_dev_state == USB_DEV_ONLINE) &&
3051 (usb_set_alt_if(ecmp->ecm_dip, ecmp->ecm_data_if_no,
3053 USB_DPRINTF_L2(PRINT_MASK_ATTA, ecmp->ecm_lh,
3058 usb_pipe_reset(ecmp->ecm_dip, ecmp->ecm_bulkin_ph,
3060 usb_pipe_close(ecmp->ecm_dip, ecmp->ecm_bulkin_ph,
3062 usb_pipe_close(ecmp->ecm_dip, ecmp->ecm_bulkout_ph,
3065 if (ecmp->ecm_intr_ph != NULL) {
3066 usb_pipe_stop_intr_polling(ecmp->ecm_intr_ph,
3068 usb_pipe_close(ecmp->ecm_dip, ecmp->ecm_intr_ph,
3072 mutex_enter(&ecmp->ecm_mutex);
3074 ecmp->ecm_bulkin_state = USBECM_PIPE_CLOSED;
3075 ecmp->ecm_bulkin_ph = NULL;
3076 ecmp->ecm_bulkout_state = USBECM_PIPE_CLOSED;
3077 ecmp->ecm_bulkout_ph = NULL;
3078 if (ecmp->ecm_intr_ph != NULL) {
3079 ecmp->ecm_intr_state = USBECM_PIPE_CLOSED;
3080 ecmp->ecm_intr_ph = NULL;
3083 mutex_exit(&ecmp->ecm_mutex);
3085 USB_DPRINTF_L4(PRINT_MASK_CLOSE, ecmp->ecm_lh,
3091 usbecm_ctrl_write(usbecm_state_t *ecmp, uchar_t request,
3099 USB_DPRINTF_L4(PRINT_MASK_ALL, ecmp->ecm_lh,
3107 setup.wIndex = ecmp->ecm_ctrl_if_no;
3111 rval = usb_pipe_ctrl_xfer_wait(ecmp->ecm_def_ph, &setup, data,
3114 USB_DPRINTF_L4(PRINT_MASK_ALL, ecmp->ecm_lh,
3121 usbecm_ctrl_read(usbecm_state_t *ecmp, uchar_t request,
3128 USB_DPRINTF_L4(PRINT_MASK_ALL, ecmp->ecm_lh,
3136 setup.wIndex = ecmp->ecm_ctrl_if_no;
3140 return (usb_pipe_ctrl_xfer_wait(ecmp->ecm_def_ph, &setup, data,
3146 usbecm_get_statistics(usbecm_state_t *ecmp, uint32_t fs, uint32_t *stat_data)
3152 if ((ecmp->ecm_compatibility == B_TRUE) &&
3153 (ecmp->ecm_desc.bmEthernetStatistics & ECM_STAT_CAP_MASK(fs))) {
3154 if (usbecm_ctrl_read(ecmp, CDC_ECM_GET_ETH_STAT,
3155 ecmp->ecm_ctrl_if_no, &data, 4) != USB_SUCCESS) {