Lines Matching refs:ldcp
71 void i_ldc_reset(ldc_chan_t *ldcp, boolean_t force_reset);
73 static int i_ldc_txq_reconf(ldc_chan_t *ldcp);
74 static int i_ldc_rxq_reconf(ldc_chan_t *ldcp, boolean_t force_reset);
75 static void i_ldc_rxq_drain(ldc_chan_t *ldcp);
76 static void i_ldc_reset_state(ldc_chan_t *ldcp);
79 static int i_ldc_get_tx_tail(ldc_chan_t *ldcp, uint64_t *tail);
80 static void i_ldc_get_tx_head(ldc_chan_t *ldcp, uint64_t *head);
81 static int i_ldc_set_tx_tail(ldc_chan_t *ldcp, uint64_t tail);
82 static int i_ldc_set_rx_head(ldc_chan_t *ldcp, uint64_t head);
83 static int i_ldc_send_pkt(ldc_chan_t *ldcp, uint8_t pkttype, uint8_t subtype,
86 static int i_ldc_set_rxdq_head(ldc_chan_t *ldcp, uint64_t head);
87 static void i_ldc_rxdq_copy(ldc_chan_t *ldcp, uint64_t *head);
88 static uint64_t i_ldc_dq_rx_get_state(ldc_chan_t *ldcp, uint64_t *head,
90 static uint64_t i_ldc_hvq_rx_get_state(ldc_chan_t *ldcp, uint64_t *head,
92 static int i_ldc_rx_ackpeek(ldc_chan_t *ldcp, uint64_t rx_head,
94 static uint_t i_ldc_chkq(ldc_chan_t *ldcp);
99 static uint_t i_ldc_rx_process_hvq(ldc_chan_t *ldcp, boolean_t *notify_client,
101 static void i_ldc_clear_intr(ldc_chan_t *ldcp, cnex_intrtype_t itype);
104 static int i_ldc_read_raw(ldc_chan_t *ldcp, caddr_t target_bufp, size_t *sizep);
105 static int i_ldc_read_packet(ldc_chan_t *ldcp, caddr_t target_bufp,
107 static int i_ldc_read_stream(ldc_chan_t *ldcp, caddr_t target_bufp,
111 static int i_ldc_write_raw(ldc_chan_t *ldcp, caddr_t target_bufp,
113 static int i_ldc_write_packet(ldc_chan_t *ldcp, caddr_t target_bufp,
115 static int i_ldc_write_stream(ldc_chan_t *ldcp, caddr_t target_bufp,
119 static int i_ldc_check_seqid(ldc_chan_t *ldcp, ldc_msg_t *ldcmsg);
120 static int i_ldc_ctrlmsg(ldc_chan_t *ldcp, ldc_msg_t *ldcmsg);
121 static int i_ldc_process_VER(ldc_chan_t *ldcp, ldc_msg_t *msg);
122 static int i_ldc_process_RTS(ldc_chan_t *ldcp, ldc_msg_t *msg);
123 static int i_ldc_process_RTR(ldc_chan_t *ldcp, ldc_msg_t *msg);
124 static int i_ldc_process_RDX(ldc_chan_t *ldcp, ldc_msg_t *msg);
125 static int i_ldc_process_data_ACK(ldc_chan_t *ldcp, ldc_msg_t *msg);
277 ldc_inject_error(ldc_chan_t *ldcp, uint64_t error)
279 if ((ldcdbgchan != DBG_ALL_LDCS) && (ldcdbgchan != ldcp->id))
334 extern void i_ldc_mem_inject_dring_clear(ldc_chan_t *ldcp);
359 #define TRACE_RXDQ_LENGTH(ldcp) \
361 uint64_t, ldcp->id, \
362 uint64_t, ldcp->rx_dq_head, \
363 uint64_t, ldcp->rx_dq_tail, \
364 uint64_t, ldcp->rx_dq_entries)
366 #define TRACE_RXHVQ_LENGTH(ldcp, head, tail) \
368 uint64_t, ldcp->id, \
371 uint64_t, ldcp->rx_q_entries)
374 #define TRACE_RXDQ_COPY(ldcp, bytes) \
375 DTRACE_PROBE2(rxdq__copy, uint64_t, ldcp->id, uint64_t, bytes) \
465 ldc_chan_t *tmp_ldcp, *ldcp;
502 ldcp = ldcssp->chan_list;
503 while (ldcp != NULL) {
504 tmp_ldcp = ldcp->next;
506 (void) ldc_close((ldc_handle_t)ldcp);
507 (void) ldc_fini((ldc_handle_t)ldcp);
509 ldcp = tmp_ldcp;
583 i_ldc_txq_reconf(ldc_chan_t *ldcp)
587 ASSERT(MUTEX_HELD(&ldcp->lock));
588 ASSERT(MUTEX_HELD(&ldcp->tx_lock));
590 rv = hv_ldc_tx_qconf(ldcp->id, ldcp->tx_q_ra, ldcp->tx_q_entries);
593 "i_ldc_txq_reconf: (0x%lx) cannot set qconf", ldcp->id);
596 rv = hv_ldc_tx_get_state(ldcp->id, &(ldcp->tx_head),
597 &(ldcp->tx_tail), &(ldcp->link_state));
600 "i_ldc_txq_reconf: (0x%lx) cannot get qptrs", ldcp->id);
603 D1(ldcp->id, "i_ldc_txq_reconf: (0x%llx) h=0x%llx,t=0x%llx,"
604 "s=0x%llx\n", ldcp->id, ldcp->tx_head, ldcp->tx_tail,
605 ldcp->link_state);
614 i_ldc_rxq_reconf(ldc_chan_t *ldcp, boolean_t force_reset)
619 ASSERT(MUTEX_HELD(&ldcp->lock));
620 rv = hv_ldc_rx_get_state(ldcp->id, &rx_head, &rx_tail,
621 &(ldcp->link_state));
625 ldcp->id);
629 if (force_reset || (ldcp->tstate & ~TS_IN_RESET) == TS_UP) {
630 rv = hv_ldc_rx_qconf(ldcp->id, ldcp->rx_q_ra,
631 ldcp->rx_q_entries);
635 ldcp->id);
638 D1(ldcp->id, "i_ldc_rxq_reconf: (0x%llx) completed q reconf",
639 ldcp->id);
650 i_ldc_rxq_drain(ldc_chan_t *ldcp)
656 ASSERT(MUTEX_HELD(&ldcp->lock));
657 rv = hv_ldc_rx_get_state(ldcp->id, &rx_head, &rx_tail,
658 &(ldcp->link_state));
661 "rv = 0x%x", ldcp->id, rv);
675 if ((rv = hv_ldc_rx_set_qhead(ldcp->id, rx_tail)) == 0)
680 if ((rv = hv_ldc_rx_set_qhead(ldcp->id, rx_tail)) == 0)
685 "rv = 0x%x", ldcp->id, rx_tail, rv);
693 i_ldc_reset_state(ldc_chan_t *ldcp)
695 ASSERT(MUTEX_HELD(&ldcp->lock));
696 ldcp->last_msg_snt = LDC_INIT_SEQID;
697 ldcp->last_ack_rcd = 0;
698 ldcp->last_msg_rcd = 0;
699 ldcp->tx_ackd_head = ldcp->tx_head;
700 ldcp->stream_remains = 0;
701 ldcp->next_vidx = 0;
702 ldcp->hstate = 0;
703 ldcp->tstate = TS_OPEN;
704 ldcp->status = LDC_OPEN;
705 ldcp->rx_ack_head = ACKPEEK_HEAD_INVALID;
706 ldcp->rx_dq_head = 0;
707 ldcp->rx_dq_tail = 0;
709 if (ldcp->link_state == LDC_CHANNEL_UP ||
710 ldcp->link_state == LDC_CHANNEL_RESET) {
712 if (ldcp->mode == LDC_MODE_RAW) {
713 ldcp->status = LDC_UP;
714 ldcp->tstate = TS_UP;
716 ldcp->status = LDC_READY;
717 ldcp->tstate |= TS_LINK_READY;
726 i_ldc_reset(ldc_chan_t *ldcp, boolean_t force_reset)
728 DWARN(ldcp->id, "i_ldc_reset: (0x%llx) channel reset\n", ldcp->id);
730 ASSERT(MUTEX_HELD(&ldcp->lock));
731 ASSERT(MUTEX_HELD(&ldcp->tx_lock));
734 (void) i_ldc_txq_reconf(ldcp);
735 (void) i_ldc_rxq_reconf(ldcp, force_reset);
738 (void) i_ldc_clear_intr(ldcp, CNEX_TX_INTR);
739 (void) i_ldc_clear_intr(ldcp, CNEX_RX_INTR);
742 i_ldc_reset_state(ldcp);
745 ldcp->tstate |= TS_IN_RESET;
757 ldc_chan_t *ldcp;
759 ldcp = ldcssp->chan_list;
760 while (ldcp != NULL) {
761 if (((ldcp->tstate & TS_QCONF_RDY) == TS_QCONF_RDY) &&
762 (LDC_DEVCLASS_PROM_RESET(ldcp->devclass) != 0)) {
763 (void) hv_ldc_rx_qconf(ldcp->id, ldcp->rx_q_ra,
764 ldcp->rx_q_entries);
766 ldcp = ldcp->next;
774 i_ldc_clear_intr(ldc_chan_t *ldcp, cnex_intrtype_t itype)
778 ASSERT(MUTEX_HELD(&ldcp->lock));
784 if (ldcp->tx_intr_state)
785 ldcp->tx_intr_state = LDC_INTR_NONE;
792 if (ldcp->rx_intr_state)
793 ldcp->rx_intr_state = LDC_INTR_NONE;
799 (void) cinfo->clr_intr(cinfo->dip, ldcp->id, itype);
800 D2(ldcp->id,
802 ldcp->id, itype);
810 i_ldc_set_rx_head(ldc_chan_t *ldcp, uint64_t head)
815 ASSERT(MUTEX_HELD(&ldcp->lock));
818 if ((rv = hv_ldc_rx_set_qhead(ldcp->id, head)) == 0)
829 "rv = 0x%x", ldcp->id, head, rv);
830 mutex_enter(&ldcp->tx_lock);
831 i_ldc_reset(ldcp, B_TRUE);
832 mutex_exit(&ldcp->tx_lock);
841 i_ldc_get_tx_head(ldc_chan_t *ldcp, uint64_t *head)
845 ASSERT(MUTEX_HELD(&ldcp->tx_lock));
848 *head = ldcp->tx_head;
856 if (ldcp->mode == LDC_MODE_RELIABLE) {
857 while (ldcp->tx_ackd_head != ldcp->tx_head) {
858 pkt = (ldc_msg_t *)(ldcp->tx_q_va + ldcp->tx_ackd_head);
863 ldcp->tx_ackd_head =
864 (ldcp->tx_ackd_head + LDC_PACKET_SIZE) %
865 (ldcp->tx_q_entries << LDC_PACKET_SHIFT);
867 *head = ldcp->tx_ackd_head;
877 i_ldc_get_tx_tail(ldc_chan_t *ldcp, uint64_t *tail)
882 ASSERT(MUTEX_HELD(&ldcp->tx_lock));
884 rv = hv_ldc_tx_get_state(ldcp->id,
885 &ldcp->tx_head, &ldcp->tx_tail, &ldcp->link_state);
889 ldcp->id);
892 if (ldcp->link_state == LDC_CHANNEL_DOWN) {
893 D1(ldcp->id, "i_ldc_get_tx_tail: (0x%llx) channel not ready\n",
894 ldcp->id);
898 i_ldc_get_tx_head(ldcp, ¤t_head);
901 new_tail = (ldcp->tx_tail + LDC_PACKET_SIZE) %
902 (ldcp->tx_q_entries << LDC_PACKET_SHIFT);
905 DWARN(ldcp->id,
907 ldcp->id);
911 D2(ldcp->id, "i_ldc_get_tx_tail: (0x%llx) head=0x%llx, tail=0x%llx\n",
912 ldcp->id, ldcp->tx_head, ldcp->tx_tail);
914 *tail = ldcp->tx_tail;
924 i_ldc_set_tx_tail(ldc_chan_t *ldcp, uint64_t tail)
929 ASSERT(MUTEX_HELD(&ldcp->tx_lock));
932 if ((rv = hv_ldc_tx_set_qtail(ldcp->id, tail)) == 0) {
937 DWARN(ldcp->id, "i_ldc_set_tx_tail: (0x%llx) set "
938 "qtail=0x%llx failed, rv=%d\n", ldcp->id, tail, rv);
959 i_ldc_rxdq_copy(ldc_chan_t *ldcp, uint64_t *head)
963 ASSERT(MUTEX_HELD(&ldcp->lock));
965 q_size = ldcp->rx_q_entries << LDC_PACKET_SHIFT;
966 dq_size = ldcp->rx_dq_entries << LDC_PACKET_SHIFT;
968 ASSERT(Q_CONTIG_SPACE(ldcp->rx_dq_head, ldcp->rx_dq_tail,
971 bcopy((void *)(ldcp->rx_q_va + *head),
972 (void *)(ldcp->rx_dq_va + ldcp->rx_dq_tail), LDC_PACKET_SIZE);
973 TRACE_RXDQ_COPY(ldcp, LDC_PACKET_SIZE);
979 ldcp->rx_dq_tail = (ldcp->rx_dq_tail + LDC_PACKET_SIZE) % dq_size;
986 i_ldc_set_rxdq_head(ldc_chan_t *ldcp, uint64_t head)
988 ldcp->rx_dq_head = head;
996 i_ldc_dq_rx_get_state(ldc_chan_t *ldcp, uint64_t *head, uint64_t *tail,
1000 *head = ldcp->rx_dq_head;
1001 *tail = ldcp->rx_dq_tail;
1010 i_ldc_hvq_rx_get_state(ldc_chan_t *ldcp, uint64_t *head, uint64_t *tail,
1013 return (i_ldc_h2v_error(hv_ldc_rx_get_state(ldcp->id, head, tail,
1027 ldc_chan_t *ldcp;
1038 ldcp = (ldc_chan_t *)arg1;
1040 D1(ldcp->id, "i_ldc_rx_hdlr: (0x%llx) Received intr, ldcp=0x%p\n",
1041 ldcp->id, ldcp);
1042 D1(ldcp->id, "i_ldc_rx_hdlr: (%llx) USR%lx/TS%lx/HS%lx, LSTATE=%lx\n",
1043 ldcp->id, ldcp->status, ldcp->tstate, ldcp->hstate,
1044 ldcp->link_state);
1047 mutex_enter(&ldcp->lock);
1050 ldcp->rx_intr_state = LDC_INTR_ACTIVE;
1052 status = i_ldc_rx_process_hvq(ldcp, ¬ify, &event);
1054 if (ldcp->mode != LDC_MODE_RELIABLE) {
1063 i_ldc_clear_intr(ldcp, CNEX_RX_INTR);
1065 ldcp->rx_intr_state = LDC_INTR_PEND;
1070 if (notify && ldcp->cb_enabled) {
1071 ldcp->cb_inprogress = B_TRUE;
1072 mutex_exit(&ldcp->lock);
1073 rv = ldcp->cb(event, ldcp->cb_arg);
1075 DWARN(ldcp->id,
1077 ldcp->id);
1079 mutex_enter(&ldcp->lock);
1080 ldcp->cb_inprogress = B_FALSE;
1083 if (ldcp->mode == LDC_MODE_RELIABLE) {
1093 ldcp->rx_intr_state = LDC_INTR_PEND;
1100 i_ldc_clear_intr(ldcp, CNEX_RX_INTR);
1104 mutex_exit(&ldcp->lock);
1106 D1(ldcp->id, "i_ldc_rx_hdlr: (0x%llx) exiting handler", ldcp->id);
1118 i_ldc_chkq(ldc_chan_t *ldcp)
1123 return (i_ldc_rx_process_hvq(ldcp, ¬ify, &event));
1130 i_ldc_send_pkt(ldc_chan_t *ldcp, uint8_t pkttype, uint8_t subtype,
1139 mutex_enter(&ldcp->tx_lock);
1141 curr_seqid = ldcp->last_msg_snt;
1144 rv = i_ldc_get_tx_tail(ldcp, &tx_tail);
1146 DWARN(ldcp->id,
1149 ldcp->id, pkttype, subtype, ctrlmsg);
1150 mutex_exit(&ldcp->tx_lock);
1154 pkt = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail);
1166 if (ldcp->mode != LDC_MODE_RAW) {
1168 pkt->ackid = ldcp->last_msg_rcd;
1171 DUMP_LDC_PKT(ldcp, "i_ldc_send_pkt", (uint64_t)pkt);
1175 (ldcp->tx_q_entries << LDC_PACKET_SHIFT);
1177 rv = i_ldc_set_tx_tail(ldcp, tx_tail);
1179 DWARN(ldcp->id,
1182 ldcp->id, pkttype, subtype, ctrlmsg);
1183 mutex_exit(&ldcp->tx_lock);
1187 ldcp->last_msg_snt = curr_seqid;
1188 ldcp->tx_tail = tx_tail;
1190 mutex_exit(&ldcp->tx_lock);
1200 i_ldc_check_seqid(ldc_chan_t *ldcp, ldc_msg_t *msg)
1203 if (ldcp->mode == LDC_MODE_RAW)
1213 if (msg->seqid != (ldcp->last_msg_rcd + 1)) {
1214 DWARN(ldcp->id,
1216 "expecting 0x%x\n", ldcp->id, msg->seqid,
1217 (ldcp->last_msg_rcd + 1));
1222 if (LDC_INJECT_PKTLOSS(ldcp)) {
1223 DWARN(ldcp->id,
1224 "i_ldc_check_seqid: (0x%llx) inject pkt loss\n", ldcp->id);
1237 i_ldc_process_VER(ldc_chan_t *ldcp, ldc_msg_t *msg)
1239 int rv = 0, idx = ldcp->next_vidx;
1247 D2(ldcp->id, "i_ldc_process_VER: (0x%llx) received VER v%u.%u\n",
1248 ldcp->id, rcvd_ver->major, rcvd_ver->minor);
1251 mutex_enter(&ldcp->tx_lock);
1256 if ((ldcp->tstate & ~TS_IN_RESET) == TS_VREADY) {
1257 (void) i_ldc_txq_reconf(ldcp);
1258 i_ldc_reset_state(ldcp);
1259 mutex_exit(&ldcp->tx_lock);
1264 rv = i_ldc_get_tx_tail(ldcp, &tx_tail);
1266 DWARN(ldcp->id,
1268 "version ACK/NACK\n", ldcp->id);
1269 i_ldc_reset(ldcp, B_TRUE);
1270 mutex_exit(&ldcp->tx_lock);
1274 pkt = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail);
1283 D1(ldcp->id, "i_ldc_process_VER: got %u.%u chk %u.%u\n",
1305 D1(ldcp->id, "i_ldc_process_VER: using next"
1314 ldcp->next_vidx = idx;
1321 D1(ldcp->id, "i_ldc_process_VER: inc idx %x\n", idx);
1327 ldcp->next_vidx = 0;
1334 (ldcp->tx_q_entries << LDC_PACKET_SHIFT);
1336 rv = i_ldc_set_tx_tail(ldcp, tx_tail);
1338 ldcp->tx_tail = tx_tail;
1340 D2(ldcp->id, "i_ldc_process_VER: (0x%llx) sent"
1341 " version ACK\n", ldcp->id);
1343 ldcp->version.major = rcvd_ver->major;
1344 ldcp->version.minor = rcvd_ver->minor;
1345 ldcp->hstate |= TS_RCVD_VER;
1346 ldcp->tstate |= TS_VER_DONE;
1350 ldcp->id, rcvd_ver->major, rcvd_ver->minor);
1353 DWARN(ldcp->id,
1355 "ACK/NACK\n", ldcp->id);
1356 i_ldc_reset(ldcp, B_TRUE);
1357 mutex_exit(&ldcp->tx_lock);
1364 if ((ldcp->tstate & ~TS_IN_RESET) == TS_VREADY) {
1365 if (ldcp->version.major != rcvd_ver->major ||
1366 ldcp->version.minor != rcvd_ver->minor) {
1369 DWARN(ldcp->id,
1371 " ACK ver != sent ACK ver\n", ldcp->id);
1372 i_ldc_reset(ldcp, B_TRUE);
1373 mutex_exit(&ldcp->tx_lock);
1378 ldcp->version.major = rcvd_ver->major;
1379 ldcp->version.minor = rcvd_ver->minor;
1380 ldcp->tstate |= TS_VER_DONE;
1383 D1(ldcp->id, "(0x%llx) Got ACK, Agreed on version v%u.%u\n",
1384 ldcp->id, rcvd_ver->major, rcvd_ver->minor);
1387 rv = i_ldc_get_tx_tail(ldcp, &tx_tail);
1389 DWARN(ldcp->id,
1391 ldcp->id);
1392 i_ldc_reset(ldcp, B_TRUE);
1393 mutex_exit(&ldcp->tx_lock);
1397 pkt = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail);
1403 pkt->env = ldcp->mode;
1404 if (ldcp->mode != LDC_MODE_RAW)
1407 ldcp->last_msg_rcd = LDC_INIT_SEQID;
1409 DUMP_LDC_PKT(ldcp, "i_ldc_process_VER snd rts", (uint64_t)pkt);
1413 (ldcp->tx_q_entries << LDC_PACKET_SHIFT);
1415 rv = i_ldc_set_tx_tail(ldcp, tx_tail);
1417 D2(ldcp->id,
1419 ldcp->id);
1420 i_ldc_reset(ldcp, B_TRUE);
1421 mutex_exit(&ldcp->tx_lock);
1425 ldcp->tx_tail = tx_tail;
1426 ldcp->hstate |= TS_SENT_RTS;
1436 ldcp->id);
1437 i_ldc_reset(ldcp, B_TRUE);
1438 mutex_exit(&ldcp->tx_lock);
1443 rv = i_ldc_get_tx_tail(ldcp, &tx_tail);
1447 "version ACK/NACK\n", ldcp->id);
1448 i_ldc_reset(ldcp, B_TRUE);
1449 mutex_exit(&ldcp->tx_lock);
1453 pkt = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail);
1478 D1(ldcp->id, "i_ldc_process_VER: using next"
1486 ldcp->next_vidx = idx;
1493 D1(ldcp->id, "i_ldc_process_VER: inc idx %x\n", idx);
1497 ldcp->next_vidx = 0;
1498 mutex_exit(&ldcp->tx_lock);
1505 (ldcp->tx_q_entries << LDC_PACKET_SHIFT);
1507 rv = i_ldc_set_tx_tail(ldcp, tx_tail);
1509 D2(ldcp->id, "i_ldc_process_VER: (0x%llx) sent version"
1510 "INFO v%u.%u\n", ldcp->id, ldc_versions[idx].major,
1512 ldcp->tx_tail = tx_tail;
1516 "INFO\n", ldcp->id);
1517 i_ldc_reset(ldcp, B_TRUE);
1518 mutex_exit(&ldcp->tx_lock);
1525 mutex_exit(&ldcp->tx_lock);
1534 i_ldc_process_RTS(ldc_chan_t *ldcp, ldc_msg_t *msg)
1541 D2(ldcp->id, "i_ldc_process_RTS: (0x%llx) received RTS\n", ldcp->id);
1545 DWARN(ldcp->id,
1547 ldcp->id);
1550 mutex_enter(&ldcp->tx_lock);
1551 i_ldc_reset(ldcp, B_TRUE);
1552 mutex_exit(&ldcp->tx_lock);
1559 if (ldcp->mode != (ldc_mode_t)msg->env) {
1562 ldcp->id);
1567 rv = i_ldc_send_pkt(ldcp, LDC_CTRL, LDC_NACK, LDC_RTS);
1570 mutex_enter(&ldcp->tx_lock);
1571 i_ldc_reset(ldcp, B_TRUE);
1572 mutex_exit(&ldcp->tx_lock);
1580 DWARN(ldcp->id, "i_ldc_process_RTS: (0x%llx) unexp ACK\n",
1581 ldcp->id);
1582 mutex_enter(&ldcp->tx_lock);
1583 i_ldc_reset(ldcp, B_TRUE);
1584 mutex_exit(&ldcp->tx_lock);
1599 ldcp->hstate |= TS_RCVD_RTS;
1602 ldcp->last_msg_snt = msg->seqid;
1605 mutex_enter(&ldcp->tx_lock);
1608 rv = i_ldc_get_tx_tail(ldcp, &tx_tail);
1612 ldcp->id);
1613 i_ldc_reset(ldcp, B_TRUE);
1614 mutex_exit(&ldcp->tx_lock);
1618 pkt = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail);
1625 pkt->env = ldcp->mode;
1626 if (ldcp->mode != LDC_MODE_RAW)
1629 ldcp->last_msg_rcd = msg->seqid;
1633 (ldcp->tx_q_entries << LDC_PACKET_SHIFT);
1635 rv = i_ldc_set_tx_tail(ldcp, tx_tail);
1637 D2(ldcp->id,
1638 "i_ldc_process_RTS: (0x%llx) sent RTR\n", ldcp->id);
1639 DUMP_LDC_PKT(ldcp, "i_ldc_process_RTS sent rtr", (uint64_t)pkt);
1641 ldcp->tx_tail = tx_tail;
1642 ldcp->hstate |= TS_SENT_RTR;
1647 ldcp->id);
1648 i_ldc_reset(ldcp, B_TRUE);
1649 mutex_exit(&ldcp->tx_lock);
1653 mutex_exit(&ldcp->tx_lock);
1661 i_ldc_process_RTR(ldc_chan_t *ldcp, ldc_msg_t *msg)
1666 D2(ldcp->id, "i_ldc_process_RTR: (0x%llx) received RTR\n", ldcp->id);
1671 DWARN(ldcp->id,
1673 ldcp->id);
1676 mutex_enter(&ldcp->tx_lock);
1677 i_ldc_reset(ldcp, B_TRUE);
1678 mutex_exit(&ldcp->tx_lock);
1686 if (ldcp->mode != (ldc_mode_t)msg->env) {
1687 DWARN(ldcp->id,
1690 ldcp->id, ldcp->mode, (ldc_mode_t)msg->env);
1695 rv = i_ldc_send_pkt(ldcp, LDC_CTRL, LDC_NACK, LDC_RTR);
1698 mutex_enter(&ldcp->tx_lock);
1699 i_ldc_reset(ldcp, B_TRUE);
1700 mutex_exit(&ldcp->tx_lock);
1709 DWARN(ldcp->id, "i_ldc_process_RTR: (0x%llx) unexp ACK\n",
1710 ldcp->id);
1713 mutex_enter(&ldcp->tx_lock);
1714 i_ldc_reset(ldcp, B_TRUE);
1715 mutex_exit(&ldcp->tx_lock);
1729 ldcp->last_msg_snt = msg->seqid;
1730 ldcp->hstate |= TS_RCVD_RTR;
1732 rv = i_ldc_send_pkt(ldcp, LDC_CTRL, LDC_INFO, LDC_RDX);
1736 ldcp->id);
1737 mutex_enter(&ldcp->tx_lock);
1738 i_ldc_reset(ldcp, B_TRUE);
1739 mutex_exit(&ldcp->tx_lock);
1742 D2(ldcp->id,
1743 "i_ldc_process_RTR: (0x%llx) sent RDX\n", ldcp->id);
1745 ldcp->hstate |= TS_SENT_RDX;
1746 ldcp->tstate |= TS_HSHAKE_DONE;
1747 if ((ldcp->tstate & TS_IN_RESET) == 0)
1748 ldcp->status = LDC_UP;
1750 D1(ldcp->id, "(0x%llx) Handshake Complete\n", ldcp->id);
1760 i_ldc_process_RDX(ldc_chan_t *ldcp, ldc_msg_t *msg)
1764 D2(ldcp->id, "i_ldc_process_RDX: (0x%llx) received RDX\n", ldcp->id);
1769 DWARN(ldcp->id,
1771 ldcp->id);
1774 mutex_enter(&ldcp->tx_lock);
1775 i_ldc_reset(ldcp, B_TRUE);
1776 mutex_exit(&ldcp->tx_lock);
1787 if ((ldcp->tstate == TS_UP) && (ldcp->hstate & TS_RCVD_RDX)) {
1790 " - LDC reset\n", ldcp->id);
1791 mutex_enter(&ldcp->tx_lock);
1792 i_ldc_reset(ldcp, B_TRUE);
1793 mutex_exit(&ldcp->tx_lock);
1797 ldcp->hstate |= TS_RCVD_RDX;
1798 ldcp->tstate |= TS_HSHAKE_DONE;
1799 if ((ldcp->tstate & TS_IN_RESET) == 0)
1800 ldcp->status = LDC_UP;
1802 D1(DBG_ALL_LDCS, "(0x%llx) Handshake Complete\n", ldcp->id);
1806 DWARN(ldcp->id, "i_ldc_process_RDX: (0x%llx) unexp ACK\n",
1807 ldcp->id);
1810 mutex_enter(&ldcp->tx_lock);
1811 i_ldc_reset(ldcp, B_TRUE);
1812 mutex_exit(&ldcp->tx_lock);
1824 i_ldc_process_data_ACK(ldc_chan_t *ldcp, ldc_msg_t *msg)
1831 mutex_enter(&ldcp->tx_lock);
1836 rv = hv_ldc_tx_get_state(ldcp->id,
1837 &ldcp->tx_head, &ldcp->tx_tail, &ldcp->link_state);
1841 ldcp->id);
1844 i_ldc_reset(ldcp, B_TRUE);
1845 mutex_exit(&ldcp->tx_lock);
1855 tx_head = ldcp->tx_ackd_head;
1857 pkt = (ldc_msg_t *)(ldcp->tx_q_va + tx_head);
1859 (ldcp->tx_q_entries << LDC_PACKET_SHIFT);
1862 D2(ldcp->id,
1864 ldcp->id);
1865 ldcp->last_ack_rcd = msg->ackid;
1866 ldcp->tx_ackd_head = tx_head;
1869 if (tx_head == ldcp->tx_head) {
1871 DWARN(ldcp->id,
1873 ldcp->id);
1876 i_ldc_reset(ldcp, B_TRUE);
1877 mutex_exit(&ldcp->tx_lock);
1882 mutex_exit(&ldcp->tx_lock);
1893 i_ldc_ctrlmsg(ldc_chan_t *ldcp, ldc_msg_t *msg)
1897 D1(ldcp->id, "i_ldc_ctrlmsg: (%llx) tstate = %lx, hstate = %lx\n",
1898 ldcp->id, ldcp->tstate, ldcp->hstate);
1900 switch (ldcp->tstate & ~TS_IN_RESET) {
1908 rv = i_ldc_process_VER(ldcp, msg);
1911 DWARN(ldcp->id,
1913 "tstate=0x%x\n", ldcp->id,
1914 (msg->ctrl & LDC_CTRL_MASK), ldcp->tstate);
1925 rv = i_ldc_process_VER(ldcp, msg);
1929 rv = i_ldc_process_RTS(ldcp, msg);
1933 rv = i_ldc_process_RTR(ldcp, msg);
1937 rv = i_ldc_process_RDX(ldcp, msg);
1940 DWARN(ldcp->id,
1942 "tstate=0x%x\n", ldcp->id,
1943 (msg->ctrl & LDC_CTRL_MASK), ldcp->tstate);
1953 DWARN(ldcp->id,
1955 "- LDC reset\n", ldcp->id);
1957 mutex_enter(&ldcp->tx_lock);
1958 (void) i_ldc_txq_reconf(ldcp);
1959 i_ldc_reset_state(ldcp);
1960 mutex_exit(&ldcp->tx_lock);
1966 rv = i_ldc_process_RDX(ldcp, msg);
1970 DWARN(ldcp->id,
1972 "tstate=0x%x\n", ldcp->id,
1973 (msg->ctrl & LDC_CTRL_MASK), ldcp->tstate);
1985 i_ldc_register_channel(ldc_chan_t *ldcp)
1991 DWARN(ldcp->id,
1996 rv = cinfo->reg_chan(cinfo->dip, ldcp->id, ldcp->devclass);
1998 DWARN(ldcp->id,
2003 rv = cinfo->add_intr(cinfo->dip, ldcp->id, CNEX_TX_INTR,
2004 i_ldc_tx_hdlr, ldcp, NULL);
2006 DWARN(ldcp->id,
2008 (void) cinfo->unreg_chan(cinfo->dip, ldcp->id);
2012 rv = cinfo->add_intr(cinfo->dip, ldcp->id, CNEX_RX_INTR,
2013 i_ldc_rx_hdlr, ldcp, NULL);
2015 DWARN(ldcp->id,
2017 (void) cinfo->rem_intr(cinfo->dip, ldcp->id, CNEX_TX_INTR);
2018 (void) cinfo->unreg_chan(cinfo->dip, ldcp->id);
2022 ldcp->tstate |= TS_CNEX_RDY;
2031 i_ldc_unregister_channel(ldc_chan_t *ldcp)
2037 DWARN(ldcp->id,
2042 if (ldcp->tstate & TS_CNEX_RDY) {
2045 rv = cinfo->rem_intr(cinfo->dip, ldcp->id, CNEX_RX_INTR);
2048 DWARN(ldcp->id,
2059 if (ldcp->rx_intr_state != LDC_INTR_PEND)
2062 (void) i_ldc_clear_intr(ldcp, CNEX_RX_INTR);
2063 rv = cinfo->rem_intr(cinfo->dip, ldcp->id,
2066 DWARN(ldcp->id, "i_ldc_unregister_channel: "
2073 rv = cinfo->rem_intr(cinfo->dip, ldcp->id, CNEX_TX_INTR);
2075 DWARN(ldcp->id,
2081 rv = cinfo->unreg_chan(ldcssp->cinfo.dip, ldcp->id);
2083 DWARN(ldcp->id,
2088 ldcp->tstate &= ~TS_CNEX_RDY;
2106 ldc_chan_t *ldcp;
2112 ldcp = (ldc_chan_t *)arg1;
2114 D1(ldcp->id, "i_ldc_tx_hdlr: (0x%llx) Received intr, ldcp=0x%p\n",
2115 ldcp->id, ldcp);
2118 mutex_enter(&ldcp->lock);
2121 mutex_enter(&ldcp->tx_lock);
2124 ldcp->tx_intr_state = LDC_INTR_ACTIVE;
2127 link_state = ldcp->link_state;
2129 rv = hv_ldc_tx_get_state(ldcp->id, &ldcp->tx_head, &ldcp->tx_tail,
2130 &ldcp->link_state);
2134 ldcp->id, rv);
2135 i_ldc_clear_intr(ldcp, CNEX_TX_INTR);
2136 mutex_exit(&ldcp->tx_lock);
2137 mutex_exit(&ldcp->lock);
2146 if (link_state != ldcp->link_state &&
2147 ldcp->link_state == LDC_CHANNEL_DOWN) {
2148 D1(ldcp->id, "i_ldc_tx_hdlr: channel link down\n", ldcp->id);
2149 i_ldc_reset(ldcp, B_FALSE);
2154 if (link_state != ldcp->link_state &&
2155 ldcp->link_state == LDC_CHANNEL_RESET) {
2156 D1(ldcp->id, "i_ldc_tx_hdlr: channel link reset\n", ldcp->id);
2157 i_ldc_reset(ldcp, B_FALSE);
2162 if (link_state != ldcp->link_state &&
2163 (ldcp->tstate & ~TS_IN_RESET) == TS_OPEN &&
2164 ldcp->link_state == LDC_CHANNEL_UP) {
2165 D1(ldcp->id, "i_ldc_tx_hdlr: channel link up\n", ldcp->id);
2168 ldcp->tstate |= TS_LINK_READY;
2169 ldcp->status = LDC_READY;
2173 if (!ldcp->cb_enabled)
2176 i_ldc_clear_intr(ldcp, CNEX_TX_INTR);
2177 mutex_exit(&ldcp->tx_lock);
2180 ldcp->cb_inprogress = B_TRUE;
2181 mutex_exit(&ldcp->lock);
2182 rv = ldcp->cb(notify_event, ldcp->cb_arg);
2184 DWARN(ldcp->id, "i_ldc_tx_hdlr: (0x%llx) callback "
2185 "failure", ldcp->id);
2187 mutex_enter(&ldcp->lock);
2188 ldcp->cb_inprogress = B_FALSE;
2191 mutex_exit(&ldcp->lock);
2193 D1(ldcp->id, "i_ldc_tx_hdlr: (0x%llx) exiting handler", ldcp->id);
2226 i_ldc_rx_process_hvq(ldc_chan_t *ldcp, boolean_t *notify_client,
2235 ASSERT(MUTEX_HELD(&ldcp->lock));
2244 link_state = ldcp->link_state;
2245 rv = hv_ldc_rx_get_state(ldcp->id, &rx_head, &rx_tail,
2246 &ldcp->link_state);
2250 "queue ptrs, rv=0x%d\n", ldcp->id, rv);
2251 i_ldc_clear_intr(ldcp, CNEX_RX_INTR);
2261 if (link_state != ldcp->link_state) {
2263 switch (ldcp->link_state) {
2265 D1(ldcp->id, "i_ldc_rx_process_hvq: channel "
2266 "link down\n", ldcp->id);
2267 mutex_enter(&ldcp->tx_lock);
2268 i_ldc_reset(ldcp, B_FALSE);
2269 mutex_exit(&ldcp->tx_lock);
2275 D1(ldcp->id, "i_ldc_rx_process_hvq: "
2276 "channel link up\n", ldcp->id);
2278 if ((ldcp->tstate & ~TS_IN_RESET) == TS_OPEN) {
2281 ldcp->tstate |= TS_LINK_READY;
2282 ldcp->status = LDC_READY;
2291 D1(ldcp->id, "i_ldc_rx_process_hvq: channel "
2292 "link reset\n", ldcp->id);
2293 mutex_enter(&ldcp->tx_lock);
2294 i_ldc_reset(ldcp, B_FALSE);
2295 mutex_exit(&ldcp->tx_lock);
2303 if (LDC_INJECT_RESET(ldcp))
2305 if (LDC_INJECT_DRNGCLEAR(ldcp))
2306 i_ldc_mem_inject_dring_clear(ldcp);
2309 TRACE_RXHVQ_LENGTH(ldcp, rx_head, rx_tail);
2314 D2(ldcp->id, "i_ldc_rx_process_hvq: (0x%llx) "
2315 "No packets\n", ldcp->id);
2319 D2(ldcp->id, "i_ldc_rx_process_hvq: head=0x%llx, "
2321 DUMP_LDC_PKT(ldcp, "i_ldc_rx_process_hvq rcd",
2322 ldcp->rx_q_va + rx_head);
2325 msg = (ldc_msg_t *)(ldcp->rx_q_va + rx_head);
2328 if (ldcp->mode == LDC_MODE_RAW) {
2337 if ((ldcp->tstate & ~TS_IN_RESET) != TS_UP) {
2341 (ldcp->rx_q_entries << LDC_PACKET_SHIFT);
2343 if (rv = i_ldc_set_rx_head(ldcp, rx_head))
2351 if (ldcp->mode != LDC_MODE_RELIABLE) {
2352 if ((ldcp->tstate & TS_IN_RESET) == 0)
2359 (void) i_ldc_dq_rx_get_state(ldcp, &dq_head,
2362 (ldcp->rx_dq_entries << LDC_PACKET_SHIFT);
2364 LDC_INJECT_DQFULL(ldcp)) {
2372 rv = i_ldc_check_seqid(ldcp, msg);
2375 DWARN(ldcp->id, "i_ldc_rx_process_hvq: (0x%llx) "
2376 "seqid error, q_ptrs=0x%lx,0x%lx", ldcp->id,
2381 ldcp->last_msg_rcd = first_fragment - 1;
2388 rv = i_ldc_send_pkt(ldcp, msg->type, LDC_NACK,
2394 ldcp->id);
2397 mutex_enter(&ldcp->tx_lock);
2398 i_ldc_reset(ldcp, B_TRUE);
2399 mutex_exit(&ldcp->tx_lock);
2407 (void) i_ldc_set_rx_head(ldcp, rx_tail);
2412 ldcp->last_msg_rcd = msg->seqid;
2417 uint64_t tstate = ldcp->tstate;
2419 rv = i_ldc_ctrlmsg(ldcp, msg);
2434 if (rv == 0 && ldcp->tstate == TS_UP &&
2436 (ldcp->tstate & ~TS_IN_RESET)) {
2444 DWARN(ldcp->id,
2446 ldcp->id);
2447 mutex_enter(&ldcp->tx_lock);
2448 i_ldc_reset(ldcp, B_TRUE);
2449 mutex_exit(&ldcp->tx_lock);
2457 if (rv = i_ldc_process_data_ACK(ldcp, msg)) {
2465 ASSERT(ldcp->mode == LDC_MODE_RELIABLE);
2471 i_ldc_rxdq_copy(ldcp, &rx_head);
2473 if ((ldcp->tstate & TS_IN_RESET) == 0)
2478 (ldcp->rx_q_entries << LDC_PACKET_SHIFT);
2482 if (rv = i_ldc_set_rx_head(ldcp, rx_head)) {
2492 if (ldcp->mode == LDC_MODE_RELIABLE) {
2497 ack_rv = i_ldc_send_pkt(ldcp, LDC_DATA, LDC_ACK, 0);
2501 "send ACK\n", ldcp->id);
2503 mutex_enter(&ldcp->tx_lock);
2504 i_ldc_reset(ldcp, B_FALSE);
2505 mutex_exit(&ldcp->tx_lock);
2518 if (i_ldc_rx_ackpeek(ldcp, rx_head, rx_tail) != 0) {
2519 ldcp->rx_ack_head = ACKPEEK_HEAD_INVALID;
2525 ldcp->rx_ack_head = ACKPEEK_HEAD_INVALID;
2546 i_ldc_rx_ackpeek(ldc_chan_t *ldcp, uint64_t rx_head, uint64_t rx_tail)
2551 if (ldcp->rx_ack_head == ACKPEEK_HEAD_INVALID)
2552 ldcp->rx_ack_head = rx_head;
2554 while (ldcp->rx_ack_head != rx_tail) {
2555 msg = (ldc_msg_t *)(ldcp->rx_q_va + ldcp->rx_ack_head);
2558 if (rv = i_ldc_process_data_ACK(ldcp, msg))
2563 ldcp->rx_ack_head =
2564 (ldcp->rx_ack_head + LDC_PACKET_SIZE) %
2565 (ldcp->rx_q_entries << LDC_PACKET_SHIFT);
2583 ldc_chan_t *ldcp;
2608 ldcp = ldcssp->chan_list;
2609 while (ldcp != NULL) {
2610 if (ldcp->id == id) {
2616 ldcp = ldcp->next;
2620 ASSERT(ldcp == NULL);
2624 /* Allocate an ldcp structure */
2625 ldcp = kmem_zalloc(sizeof (ldc_chan_t), KM_SLEEP);
2643 mutex_init(&ldcp->lock, NULL, MUTEX_DRIVER, NULL);
2644 mutex_init(&ldcp->tx_lock, NULL, MUTEX_DRIVER, NULL);
2647 ldcp->id = id;
2648 ldcp->cb = NULL;
2649 ldcp->cb_arg = NULL;
2650 ldcp->cb_inprogress = B_FALSE;
2651 ldcp->cb_enabled = B_FALSE;
2652 ldcp->next = NULL;
2655 ldcp->mode = attr->mode;
2656 ldcp->devclass = attr->devclass;
2657 ldcp->devinst = attr->instance;
2658 ldcp->mtu = (attr->mtu > 0) ? attr->mtu : LDC_DEFAULT_MTU;
2660 D1(ldcp->id,
2663 ldcp->id, ldcp->devclass, ldcp->devinst, ldcp->mode, ldcp->mtu);
2665 ldcp->next_vidx = 0;
2666 ldcp->tstate = TS_IN_RESET;
2667 ldcp->hstate = 0;
2668 ldcp->last_msg_snt = LDC_INIT_SEQID;
2669 ldcp->last_ack_rcd = 0;
2670 ldcp->last_msg_rcd = 0;
2671 ldcp->rx_ack_head = ACKPEEK_HEAD_INVALID;
2673 ldcp->stream_bufferp = NULL;
2674 ldcp->exp_dring_list = NULL;
2675 ldcp->imp_dring_list = NULL;
2676 ldcp->mhdl_list = NULL;
2678 ldcp->tx_intr_state = LDC_INTR_NONE;
2679 ldcp->rx_intr_state = LDC_INTR_NONE;
2682 switch (ldcp->mode) {
2684 ldcp->pkt_payload = LDC_PAYLOAD_SIZE_RAW;
2685 ldcp->read_p = i_ldc_read_raw;
2686 ldcp->write_p = i_ldc_write_raw;
2689 ldcp->pkt_payload = LDC_PAYLOAD_SIZE_UNRELIABLE;
2690 ldcp->read_p = i_ldc_read_packet;
2691 ldcp->write_p = i_ldc_write_packet;
2694 ldcp->pkt_payload = LDC_PAYLOAD_SIZE_RELIABLE;
2696 ldcp->stream_remains = 0;
2697 ldcp->stream_offset = 0;
2698 ldcp->stream_bufferp = kmem_alloc(ldcp->mtu, KM_SLEEP);
2699 ldcp->read_p = i_ldc_read_stream;
2700 ldcp->write_p = i_ldc_write_stream;
2713 qlen = (ldcp->mtu * ldc_mtu_msgs) / ldcp->pkt_payload;
2722 ldcp->rx_q_entries =
2724 ldcp->tx_q_entries = ldcp->rx_q_entries;
2726 D1(ldcp->id, "ldc_init: queue length = 0x%llx\n", ldcp->rx_q_entries);
2729 ldcp->tx_q_va = (uint64_t)
2730 contig_mem_alloc(ldcp->tx_q_entries << LDC_PACKET_SHIFT);
2731 if (ldcp->tx_q_va == NULL) {
2734 ldcp->id);
2738 ldcp->tx_q_ra = va_to_pa((caddr_t)ldcp->tx_q_va);
2740 D2(ldcp->id, "ldc_init: txq_va=0x%llx, txq_ra=0x%llx, entries=0x%llx\n",
2741 ldcp->tx_q_va, ldcp->tx_q_ra, ldcp->tx_q_entries);
2743 ldcp->tstate |= TS_TXQ_RDY;
2746 ldcp->rx_q_va = (uint64_t)
2747 contig_mem_alloc(ldcp->rx_q_entries << LDC_PACKET_SHIFT);
2748 if (ldcp->rx_q_va == NULL) {
2751 ldcp->id);
2755 ldcp->rx_q_ra = va_to_pa((caddr_t)ldcp->rx_q_va);
2757 D2(ldcp->id, "ldc_init: rxq_va=0x%llx, rxq_ra=0x%llx, entries=0x%llx\n",
2758 ldcp->rx_q_va, ldcp->rx_q_ra, ldcp->rx_q_entries);
2760 ldcp->tstate |= TS_RXQ_RDY;
2763 if (ldcp->mode == LDC_MODE_RELIABLE) {
2764 ldcp->readq_get_state = i_ldc_dq_rx_get_state;
2765 ldcp->readq_set_head = i_ldc_set_rxdq_head;
2769 D1(ldcp->id, "ldc_init: (0x%llx) ldc_rxdq_multiplier "
2770 "not a power of 2, resetting", ldcp->id);
2774 ldcp->rx_dq_entries = ldc_rxdq_multiplier * ldcp->rx_q_entries;
2775 ldcp->rx_dq_va = (uint64_t)
2776 kmem_alloc(ldcp->rx_dq_entries << LDC_PACKET_SHIFT,
2778 if (ldcp->rx_dq_va == NULL) {
2781 "allocation failed\n", ldcp->id);
2786 ldcp->rx_dq_head = ldcp->rx_dq_tail = 0;
2788 D2(ldcp->id, "ldc_init: rx_dq_va=0x%llx, "
2789 "rx_dq_entries=0x%llx\n", ldcp->rx_dq_va,
2790 ldcp->rx_dq_entries);
2792 ldcp->readq_get_state = i_ldc_hvq_rx_get_state;
2793 ldcp->readq_set_head = i_ldc_set_rx_head;
2797 mutex_init(&ldcp->exp_dlist_lock, NULL, MUTEX_DRIVER, NULL);
2798 mutex_init(&ldcp->imp_dlist_lock, NULL, MUTEX_DRIVER, NULL);
2799 mutex_init(&ldcp->mlist_lock, NULL, MUTEX_DRIVER, NULL);
2802 ldcp->status = LDC_INIT;
2806 ldcp->next = ldcssp->chan_list;
2807 ldcssp->chan_list = ldcp;
2812 *handle = (ldc_handle_t)ldcp;
2814 D1(ldcp->id, "ldc_init: (0x%llx) channel initialized\n", ldcp->id);
2820 if (ldcp->mode == LDC_MODE_RELIABLE && ldcp->stream_bufferp)
2821 kmem_free(ldcp->stream_bufferp, ldcp->mtu);
2823 if (ldcp->tstate & TS_TXQ_RDY)
2824 contig_mem_free((caddr_t)ldcp->tx_q_va,
2825 (ldcp->tx_q_entries << LDC_PACKET_SHIFT));
2827 if (ldcp->tstate & TS_RXQ_RDY)
2828 contig_mem_free((caddr_t)ldcp->rx_q_va,
2829 (ldcp->rx_q_entries << LDC_PACKET_SHIFT));
2831 mutex_destroy(&ldcp->tx_lock);
2832 mutex_destroy(&ldcp->lock);
2834 if (ldcp)
2835 kmem_free(ldcp, sizeof (ldc_chan_t));
2849 ldc_chan_t *ldcp;
2857 ldcp = (ldc_chan_t *)handle;
2858 id = ldcp->id;
2860 mutex_enter(&ldcp->lock);
2862 if ((ldcp->tstate & ~TS_IN_RESET) > TS_INIT) {
2863 DWARN(ldcp->id, "ldc_fini: (0x%llx) channel is open\n",
2864 ldcp->id);
2865 mutex_exit(&ldcp->lock);
2872 if (tmp_ldcp == ldcp) {
2873 ldcssp->chan_list = ldcp->next;
2874 ldcp->next = NULL;
2877 if (tmp_ldcp->next == ldcp) {
2878 tmp_ldcp->next = ldcp->next;
2879 ldcp->next = NULL;
2887 mutex_exit(&ldcp->lock);
2897 if (ldcp->mtbl) {
2898 (void) hv_ldc_set_map_table(ldcp->id, NULL, NULL);
2899 if (ldcp->mtbl->contigmem)
2900 contig_mem_free(ldcp->mtbl->table, ldcp->mtbl->size);
2902 kmem_free(ldcp->mtbl->table, ldcp->mtbl->size);
2903 mutex_destroy(&ldcp->mtbl->lock);
2904 kmem_free(ldcp->mtbl, sizeof (ldc_mtbl_t));
2908 mutex_destroy(&ldcp->exp_dlist_lock);
2909 mutex_destroy(&ldcp->imp_dlist_lock);
2910 mutex_destroy(&ldcp->mlist_lock);
2913 if (ldcp->mode == LDC_MODE_RELIABLE && ldcp->stream_bufferp)
2914 kmem_free(ldcp->stream_bufferp, ldcp->mtu);
2917 contig_mem_free((caddr_t)ldcp->rx_q_va,
2918 (ldcp->rx_q_entries << LDC_PACKET_SHIFT));
2919 ldcp->tstate &= ~TS_RXQ_RDY;
2922 if (ldcp->mode == LDC_MODE_RELIABLE) {
2923 kmem_free((caddr_t)ldcp->rx_dq_va,
2924 (ldcp->rx_dq_entries << LDC_PACKET_SHIFT));
2928 contig_mem_free((caddr_t)ldcp->tx_q_va,
2929 (ldcp->tx_q_entries << LDC_PACKET_SHIFT));
2930 ldcp->tstate &= ~TS_TXQ_RDY;
2932 mutex_exit(&ldcp->lock);
2935 mutex_destroy(&ldcp->tx_lock);
2936 mutex_destroy(&ldcp->lock);
2939 kmem_free(ldcp, sizeof (ldc_chan_t));
2954 ldc_chan_t *ldcp;
2962 ldcp = (ldc_chan_t *)handle;
2964 mutex_enter(&ldcp->lock);
2966 if (ldcp->tstate < TS_INIT) {
2967 DWARN(ldcp->id,
2968 "ldc_open: (0x%llx) channel not initialized\n", ldcp->id);
2969 mutex_exit(&ldcp->lock);
2972 if ((ldcp->tstate & ~TS_IN_RESET) >= TS_OPEN) {
2973 DWARN(ldcp->id,
2974 "ldc_open: (0x%llx) channel is already open\n", ldcp->id);
2975 mutex_exit(&ldcp->lock);
2982 rv = hv_ldc_tx_qconf(ldcp->id, NULL, NULL);
2986 ldcp->id);
2987 mutex_exit(&ldcp->lock);
2991 rv = hv_ldc_tx_qconf(ldcp->id, ldcp->tx_q_ra, ldcp->tx_q_entries);
2995 ldcp->id);
2996 mutex_exit(&ldcp->lock);
3000 D2(ldcp->id, "ldc_open: (0x%llx) registered tx queue with LDC\n",
3001 ldcp->id);
3006 rv = hv_ldc_rx_qconf(ldcp->id, NULL, NULL);
3010 ldcp->id);
3011 mutex_exit(&ldcp->lock);
3015 rv = hv_ldc_rx_qconf(ldcp->id, ldcp->rx_q_ra, ldcp->rx_q_entries);
3019 ldcp->id);
3020 mutex_exit(&ldcp->lock);
3024 D2(ldcp->id, "ldc_open: (0x%llx) registered rx queue with LDC\n",
3025 ldcp->id);
3027 ldcp->tstate |= TS_QCONF_RDY;
3030 rv = i_ldc_register_channel(ldcp);
3033 "ldc_open: (0x%lx) channel register failed\n", ldcp->id);
3034 ldcp->tstate &= ~TS_QCONF_RDY;
3035 (void) hv_ldc_tx_qconf(ldcp->id, NULL, NULL);
3036 (void) hv_ldc_rx_qconf(ldcp->id, NULL, NULL);
3037 mutex_exit(&ldcp->lock);
3042 ldcp->status = LDC_OPEN;
3045 rv = hv_ldc_tx_get_state(ldcp->id,
3046 &ldcp->tx_head, &ldcp->tx_tail, &ldcp->link_state);
3050 ldcp->id);
3051 (void) i_ldc_unregister_channel(ldcp);
3052 ldcp->tstate &= ~TS_QCONF_RDY;
3053 (void) hv_ldc_tx_qconf(ldcp->id, NULL, NULL);
3054 (void) hv_ldc_rx_qconf(ldcp->id, NULL, NULL);
3055 mutex_exit(&ldcp->lock);
3062 ldcp->tx_ackd_head = ldcp->tx_head;
3065 if (ldcp->link_state == LDC_CHANNEL_UP ||
3066 ldcp->link_state == LDC_CHANNEL_RESET) {
3067 ldcp->tstate |= TS_LINK_READY;
3068 ldcp->status = LDC_READY;
3075 if (ldcp->mode == LDC_MODE_RAW) {
3076 ldcp->tstate = TS_UP; /* set bits associated with LDC UP */
3077 ldcp->status = LDC_UP;
3080 mutex_exit(&ldcp->lock);
3089 D1(ldcp->id,
3092 ldcp->id, ldcp, ldcp->tstate, ldcp->status);
3105 ldc_chan_t *ldcp;
3113 ldcp = (ldc_chan_t *)handle;
3115 mutex_enter(&ldcp->lock);
3118 if ((ldcp->tstate & ~TS_IN_RESET) < TS_OPEN) {
3119 DWARN(ldcp->id,
3120 "ldc_close: (0x%llx) channel is not open\n", ldcp->id);
3121 mutex_exit(&ldcp->lock);
3126 if (ldcp->mhdl_list != NULL) {
3127 DWARN(ldcp->id,
3129 ldcp->id);
3130 mutex_exit(&ldcp->lock);
3133 if (ldcp->exp_dring_list != NULL) {
3134 DWARN(ldcp->id,
3136 ldcp->id);
3137 mutex_exit(&ldcp->lock);
3140 if (ldcp->imp_dring_list != NULL) {
3141 DWARN(ldcp->id,
3143 ldcp->id);
3144 mutex_exit(&ldcp->lock);
3148 if (ldcp->cb_inprogress) {
3149 DWARN(ldcp->id, "ldc_close: (0x%llx) callback active\n",
3150 ldcp->id);
3151 mutex_exit(&ldcp->lock);
3156 mutex_enter(&ldcp->tx_lock);
3164 rv = hv_ldc_tx_get_state(ldcp->id,
3165 &ldcp->tx_head, &ldcp->tx_tail, &ldcp->link_state);
3168 "ldc_close: (0x%lx) cannot read qptrs\n", ldcp->id);
3169 mutex_exit(&ldcp->tx_lock);
3170 mutex_exit(&ldcp->lock);
3174 if (ldcp->tx_head == ldcp->tx_tail ||
3175 ldcp->link_state != LDC_CHANNEL_UP) {
3180 DWARN(ldcp->id,
3182 ldcp->id);
3199 (void) i_ldc_txq_reconf(ldcp);
3200 i_ldc_rxq_drain(ldcp);
3205 while ((rv = i_ldc_unregister_channel(ldcp)) != 0) {
3207 mutex_exit(&ldcp->tx_lock);
3208 mutex_exit(&ldcp->lock);
3214 ldcp->id, rv);
3223 mutex_enter(&ldcp->lock);
3224 mutex_enter(&ldcp->tx_lock);
3228 ldcp->tstate &= ~TS_QCONF_RDY;
3233 rv = hv_ldc_tx_qconf(ldcp->id, NULL, NULL);
3237 ldcp->id);
3238 mutex_exit(&ldcp->tx_lock);
3239 mutex_exit(&ldcp->lock);
3242 rv = hv_ldc_rx_qconf(ldcp->id, NULL, NULL);
3246 ldcp->id);
3247 mutex_exit(&ldcp->tx_lock);
3248 mutex_exit(&ldcp->lock);
3253 i_ldc_reset_state(ldcp);
3256 ldcp->tx_ackd_head = 0;
3257 ldcp->tx_head = 0;
3258 ldcp->tstate = TS_IN_RESET|TS_INIT;
3259 ldcp->status = LDC_INIT;
3261 mutex_exit(&ldcp->tx_lock);
3262 mutex_exit(&ldcp->lock);
3269 D1(ldcp->id, "ldc_close: (0x%llx) channel closed\n", ldcp->id);
3281 ldc_chan_t *ldcp;
3292 ldcp = (ldc_chan_t *)handle;
3294 mutex_enter(&ldcp->lock);
3296 if (ldcp->cb) {
3297 DWARN(ldcp->id, "ldc_reg_callback: (0x%llx) callback exists\n",
3298 ldcp->id);
3299 mutex_exit(&ldcp->lock);
3302 if (ldcp->cb_inprogress) {
3303 DWARN(ldcp->id, "ldc_reg_callback: (0x%llx) callback active\n",
3304 ldcp->id);
3305 mutex_exit(&ldcp->lock);
3309 ldcp->cb = cb;
3310 ldcp->cb_arg = arg;
3311 ldcp->cb_enabled = B_TRUE;
3313 D1(ldcp->id,
3315 ldcp->id);
3317 mutex_exit(&ldcp->lock);
3328 ldc_chan_t *ldcp;
3335 ldcp = (ldc_chan_t *)handle;
3337 mutex_enter(&ldcp->lock);
3339 if (ldcp->cb == NULL) {
3340 DWARN(ldcp->id,
3342 ldcp->id);
3343 mutex_exit(&ldcp->lock);
3346 if (ldcp->cb_inprogress) {
3347 DWARN(ldcp->id,
3349 ldcp->id);
3350 mutex_exit(&ldcp->lock);
3354 ldcp->cb = NULL;
3355 ldcp->cb_arg = NULL;
3356 ldcp->cb_enabled = B_FALSE;
3358 D1(ldcp->id,
3360 ldcp->id);
3362 mutex_exit(&ldcp->lock);
3377 ldc_chan_t *ldcp;
3385 ldcp = (ldc_chan_t *)handle;
3387 mutex_enter(&ldcp->lock);
3389 D1(ldcp->id, "ldc_up: (0x%llx) doing channel UP\n", ldcp->id);
3392 tstate = ldcp->tstate;
3393 ldcp->tstate &= ~TS_IN_RESET;
3395 if (ldcp->tstate == TS_UP) {
3396 DWARN(ldcp->id,
3398 ldcp->id);
3401 ldcp->status = LDC_UP;
3410 ldcp->rx_intr_state == LDC_INTR_PEND) {
3411 D1(ldcp->id,
3413 "clearing interrupt\n", ldcp->id);
3414 i_ldc_clear_intr(ldcp, CNEX_RX_INTR);
3417 mutex_exit(&ldcp->lock);
3422 if (ldcp->mode == LDC_MODE_RAW && ldcp->tstate >= TS_READY) {
3423 ldcp->tstate = TS_UP;
3424 mutex_exit(&ldcp->lock);
3429 if (ldcp->hstate) {
3430 D1(ldcp->id,
3432 ldcp->id);
3433 mutex_exit(&ldcp->lock);
3437 mutex_enter(&ldcp->tx_lock);
3440 link_state = ldcp->link_state;
3443 rv = i_ldc_get_tx_tail(ldcp, &tx_tail);
3445 D1(ldcp->id, "ldc_up: (0x%llx) cannot initiate handshake\n",
3446 ldcp->id);
3447 mutex_exit(&ldcp->tx_lock);
3448 mutex_exit(&ldcp->lock);
3458 (link_state != ldcp->link_state)) {
3460 ASSERT((ldcp->link_state == LDC_CHANNEL_RESET) ||
3461 (ldcp->link_state == LDC_CHANNEL_UP));
3463 if (ldcp->mode == LDC_MODE_RAW) {
3464 ldcp->status = LDC_UP;
3465 ldcp->tstate = TS_UP;
3466 mutex_exit(&ldcp->tx_lock);
3467 mutex_exit(&ldcp->lock);
3470 ldcp->status = LDC_READY;
3471 ldcp->tstate |= TS_LINK_READY;
3476 ldcmsg = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail);
3482 ldcp->next_vidx = 0;
3485 DUMP_LDC_PKT(ldcp, "ldc_up snd ver", (uint64_t)ldcmsg);
3489 (ldcp->tx_q_entries << LDC_PACKET_SHIFT);
3491 rv = i_ldc_set_tx_tail(ldcp, tx_tail);
3493 DWARN(ldcp->id,
3495 ldcp->id, rv);
3496 mutex_exit(&ldcp->tx_lock);
3497 mutex_exit(&ldcp->lock);
3501 ldcp->hstate |= TS_SENT_VER;
3502 ldcp->tx_tail = tx_tail;
3503 D1(ldcp->id, "ldc_up: (0x%llx) channel up initiated\n", ldcp->id);
3505 mutex_exit(&ldcp->tx_lock);
3506 mutex_exit(&ldcp->lock);
3518 ldc_chan_t *ldcp;
3524 ldcp = (ldc_chan_t *)handle;
3525 mutex_enter(&ldcp->lock);
3526 mutex_enter(&ldcp->tx_lock);
3527 i_ldc_reset(ldcp, B_TRUE);
3528 mutex_exit(&ldcp->tx_lock);
3529 mutex_exit(&ldcp->lock);
3540 ldc_chan_t *ldcp;
3546 ldcp = (ldc_chan_t *)handle;
3550 D1(ldcp->id,
3551 "ldc_status: (0x%llx) returned status %d\n", ldcp->id, *status);
3562 ldc_chan_t *ldcp;
3569 ldcp = (ldc_chan_t *)handle;
3574 mutex_enter(&ldcp->lock);
3578 if (!ldcp->cb_enabled) {
3579 DWARN(ldcp->id,
3581 ldcp->id);
3584 ldcp->cb_enabled = B_FALSE;
3586 D1(ldcp->id, "ldc_set_cb_mode: (0x%llx) disabled callbacks\n",
3587 ldcp->id);
3591 if (ldcp->cb_enabled) {
3592 DWARN(ldcp->id,
3594 ldcp->id);
3597 ldcp->cb_enabled = B_TRUE;
3599 D1(ldcp->id, "ldc_set_cb_mode: (0x%llx) enabled callbacks\n",
3600 ldcp->id);
3604 mutex_exit(&ldcp->lock);
3618 ldc_chan_t *ldcp;
3624 ldcp = (ldc_chan_t *)handle;
3628 mutex_enter(&ldcp->lock);
3630 if (ldcp->tstate != TS_UP) {
3631 D1(ldcp->id,
3632 "ldc_chkq: (0x%llx) channel is not up\n", ldcp->id);
3633 mutex_exit(&ldcp->lock);
3638 rv = hv_ldc_rx_get_state(ldcp->id, &rx_head, &rx_tail,
3639 &ldcp->link_state);
3642 "ldc_chkq: (0x%lx) unable to read queue ptrs", ldcp->id);
3643 mutex_exit(&ldcp->lock);
3648 if (ldcp->link_state == LDC_CHANNEL_DOWN ||
3649 ldcp->link_state == LDC_CHANNEL_RESET) {
3650 mutex_enter(&ldcp->tx_lock);
3651 i_ldc_reset(ldcp, B_FALSE);
3652 mutex_exit(&ldcp->tx_lock);
3653 mutex_exit(&ldcp->lock);
3657 switch (ldcp->mode) {
3673 *hasdata = (i_ldc_chkq(ldcp) == 0);
3683 ldcp->rx_intr_state == LDC_INTR_PEND) {
3684 i_ldc_clear_intr(ldcp, CNEX_RX_INTR);
3695 if (ldcp->stream_remains > 0)
3698 *hasdata = (ldcp->rx_dq_head != ldcp->rx_dq_tail);
3703 "(0x%x)", ldcp->id, ldcp->mode);
3704 mutex_exit(&ldcp->lock);
3708 mutex_exit(&ldcp->lock);
3723 ldc_chan_t *ldcp;
3732 ldcp = (ldc_chan_t *)handle;
3735 mutex_enter(&ldcp->lock);
3737 if (ldcp->tstate != TS_UP) {
3738 DWARN(ldcp->id,
3740 ldcp->id);
3742 } else if (ldcp->mode == LDC_MODE_RELIABLE) {
3743 TRACE_RXDQ_LENGTH(ldcp);
3744 exit_val = ldcp->read_p(ldcp, bufp, sizep);
3755 if (ldcp->rx_intr_state == LDC_INTR_PEND &&
3756 Q_CONTIG_SPACE(ldcp->rx_dq_head, ldcp->rx_dq_tail,
3757 ldcp->rx_dq_entries << LDC_PACKET_SHIFT) >=
3760 i_ldc_clear_intr(ldcp, CNEX_RX_INTR);
3763 mutex_exit(&ldcp->lock);
3766 exit_val = ldcp->read_p(ldcp, bufp, sizep);
3772 rv = hv_ldc_rx_get_state(ldcp->id, &rx_head, &rx_tail,
3773 &ldcp->link_state);
3776 ldcp->id);
3777 mutex_enter(&ldcp->tx_lock);
3778 i_ldc_reset(ldcp, B_TRUE);
3779 mutex_exit(&ldcp->tx_lock);
3780 mutex_exit(&ldcp->lock);
3785 if (ldcp->link_state == LDC_CHANNEL_DOWN ||
3786 ldcp->link_state == LDC_CHANNEL_RESET) {
3787 mutex_enter(&ldcp->tx_lock);
3788 i_ldc_reset(ldcp, B_FALSE);
3790 mutex_exit(&ldcp->tx_lock);
3793 (ldcp->rx_intr_state == LDC_INTR_PEND) &&
3795 i_ldc_clear_intr(ldcp, CNEX_RX_INTR);
3799 mutex_exit(&ldcp->lock);
3807 * Enter and exit with ldcp->lock held by caller
3810 i_ldc_read_raw(ldc_chan_t *ldcp, caddr_t target_bufp, size_t *sizep)
3823 ASSERT(mutex_owned(&ldcp->lock));
3826 q_size_mask = (ldcp->rx_q_entries-1)<<LDC_PACKET_SHIFT;
3831 rv = hv_ldc_rx_get_state(ldcp->id, &rx_head, &rx_tail,
3832 &ldcp->link_state);
3836 ldcp->id);
3839 D1(ldcp->id, "ldc_read_raw: (0x%llx) rxh=0x%llx,"
3841 ldcp->id, rx_head, rx_tail, ldcp->link_state);
3844 if (ldcp->link_state == LDC_CHANNEL_DOWN ||
3845 ldcp->link_state == LDC_CHANNEL_RESET) {
3846 mutex_enter(&ldcp->tx_lock);
3847 i_ldc_reset(ldcp, B_FALSE);
3848 mutex_exit(&ldcp->tx_lock);
3861 msgp = (ldc_msg_t *)(ldcp->rx_q_va + rx_head);
3868 DUMP_PAYLOAD(ldcp->id, msgbufp);
3873 rv = i_ldc_set_rx_head(ldcp, rx_head);
3882 * Enter and exit with ldcp->lock held by caller
3885 i_ldc_read_packet(ldc_chan_t *ldcp, caddr_t target_bufp, size_t *sizep)
3899 ASSERT(mutex_owned(&ldcp->lock));
3903 DWARN(ldcp->id, "ldc_read: (0x%llx) invalid buffer/size\n",
3904 ldcp->id);
3909 if (ldcp->mode == LDC_MODE_RELIABLE) {
3910 q_va = ldcp->rx_dq_va;
3911 q_size_mask = (ldcp->rx_dq_entries-1)<<LDC_PACKET_SHIFT;
3913 q_va = ldcp->rx_q_va;
3914 q_size_mask = (ldcp->rx_q_entries-1)<<LDC_PACKET_SHIFT;
3920 rv = ldcp->readq_get_state(ldcp, &curr_head, &rx_tail,
3921 &ldcp->link_state);
3924 ldcp->id);
3925 mutex_enter(&ldcp->tx_lock);
3926 i_ldc_reset(ldcp, B_TRUE);
3927 mutex_exit(&ldcp->tx_lock);
3930 D1(ldcp->id, "ldc_read: (0x%llx) chd=0x%llx, tl=0x%llx, st=0x%llx\n",
3931 ldcp->id, curr_head, rx_tail, ldcp->link_state);
3934 if (ldcp->link_state != LDC_CHANNEL_UP)
3945 if (ldcp->mode == LDC_MODE_RELIABLE)
3946 (void) i_ldc_chkq(ldcp);
3948 rv = ldcp->readq_get_state(ldcp,
3949 &rx_head, &rx_tail, &ldcp->link_state);
3953 ldcp->id);
3954 mutex_enter(&ldcp->tx_lock);
3955 i_ldc_reset(ldcp, B_TRUE);
3956 mutex_exit(&ldcp->tx_lock);
3960 if (ldcp->link_state != LDC_CHANNEL_UP)
3975 if (ldcp->mode != LDC_MODE_RELIABLE)
3976 ldcp->last_msg_rcd =
3979 "(0x%llx) read timeout", ldcp->id);
3988 D2(ldcp->id,
3990 ldcp->id, curr_head, rx_head, rx_tail);
3995 DUMP_LDC_PKT(ldcp, "ldc_read received pkt",
3996 ldcp->rx_q_va + curr_head);
3999 if (ldcp->mode != LDC_MODE_RELIABLE) {
4000 if ((rv = i_ldc_check_seqid(ldcp, msg)) != 0) {
4002 DWARN(ldcp->id, "ldc_read: (0x%llx) seqid "
4004 ldcp->id, rx_head, rx_tail);
4011 ldcp->last_msg_rcd = first_fragment - 1;
4018 rv = i_ldc_send_pkt(ldcp, msg->type, LDC_NACK,
4023 "NACK msg\n", ldcp->id);
4026 mutex_enter(&ldcp->tx_lock);
4027 i_ldc_reset(ldcp, B_FALSE);
4028 mutex_exit(&ldcp->tx_lock);
4034 rv = i_ldc_set_rx_head(ldcp, rx_tail);
4048 if (rv = i_ldc_ctrlmsg(ldcp, msg)) {
4051 rv = i_ldc_set_rx_head(ldcp, rx_tail);
4060 if (rv = i_ldc_process_data_ACK(ldcp, msg)) {
4069 DWARN(ldcp->id,
4071 ldcp->id);
4072 mutex_enter(&ldcp->tx_lock);
4073 i_ldc_reset(ldcp, B_TRUE);
4074 mutex_exit(&ldcp->tx_lock);
4083 (ldcp->mode == LDC_MODE_RELIABLE) ?
4086 D2(ldcp->id,
4087 "ldc_read: (0x%llx) received data msg\n", ldcp->id);
4112 "frag=%x\n", ldcp->id,
4121 if (rv = ldcp->readq_set_head(ldcp,
4136 ldcp->id, msg->env&LDC_FRAG_MASK,
4137 bytes_read, ldcp->last_msg_rcd,
4145 if (rv = ldcp->readq_set_head(ldcp,
4164 "head=0x%lx, expect=%d, got=%d\n", ldcp->id,
4172 if (rv = ldcp->readq_set_head(ldcp, curr_head))
4181 if (ldcp->mode != LDC_MODE_RELIABLE)
4182 ldcp->last_msg_rcd = msg->seqid;
4196 if (rv = ldcp->readq_set_head(ldcp, curr_head))
4209 if (rv = ldcp->readq_set_head(ldcp, curr_head)) {
4214 D2(ldcp->id, "ldc_read: (0x%llx) set ACK qhead 0x%llx",
4215 ldcp->id, curr_head);
4220 D2(ldcp->id, "ldc_read: (0x%llx) end size=%d", ldcp->id, *sizep);
4225 mutex_enter(&ldcp->tx_lock);
4226 i_ldc_reset(ldcp, B_FALSE);
4227 mutex_exit(&ldcp->tx_lock);
4235 * Enter and exit with ldcp->lock held by caller
4238 i_ldc_read_stream(ldc_chan_t *ldcp, caddr_t target_bufp, size_t *sizep)
4243 ASSERT(mutex_owned(&ldcp->lock));
4245 D2(ldcp->id, "i_ldc_read_stream: (0x%llx) buffer size=%d",
4246 ldcp->id, *sizep);
4248 if (ldcp->stream_remains == 0) {
4249 size = ldcp->mtu;
4250 rv = i_ldc_read_packet(ldcp,
4251 (caddr_t)ldcp->stream_bufferp, &size);
4252 D2(ldcp->id, "i_ldc_read_stream: read packet (0x%llx) size=%d",
4253 ldcp->id, size);
4258 ldcp->stream_remains = size;
4259 ldcp->stream_offset = 0;
4262 size = MIN(ldcp->stream_remains, *sizep);
4264 bcopy(ldcp->stream_bufferp + ldcp->stream_offset, target_bufp, size);
4265 ldcp->stream_offset += size;
4266 ldcp->stream_remains -= size;
4268 D2(ldcp->id, "i_ldc_read_stream: (0x%llx) fill from buffer size=%d",
4269 ldcp->id, size);
4286 ldc_chan_t *ldcp;
4293 ldcp = (ldc_chan_t *)handle;
4295 mutex_enter(&ldcp->tx_lock);
4299 DWARN(ldcp->id, "ldc_write: (0x%llx) invalid data write\n",
4300 ldcp->id);
4301 mutex_exit(&ldcp->tx_lock);
4306 DWARN(ldcp->id, "ldc_write: (0x%llx) write size of zero\n",
4307 ldcp->id);
4308 mutex_exit(&ldcp->tx_lock);
4313 if (ldcp->tstate != TS_UP) {
4314 DWARN(ldcp->id,
4316 ldcp->id);
4320 rv = ldcp->write_p(ldcp, buf, sizep);
4323 mutex_exit(&ldcp->tx_lock);
4333 i_ldc_write_raw(ldc_chan_t *ldcp, caddr_t buf, size_t *sizep)
4340 ASSERT(MUTEX_HELD(&ldcp->tx_lock));
4341 ASSERT(ldcp->mode == LDC_MODE_RAW);
4349 if (size > ldcp->pkt_payload) {
4350 DWARN(ldcp->id,
4352 ldcp->id, *sizep);
4358 rv = hv_ldc_tx_get_state(ldcp->id,
4359 &ldcp->tx_head, &ldcp->tx_tail, &ldcp->link_state);
4362 "ldc_write: (0x%lx) cannot read queue ptrs\n", ldcp->id);
4367 if (ldcp->link_state == LDC_CHANNEL_DOWN ||
4368 ldcp->link_state == LDC_CHANNEL_RESET) {
4369 DWARN(ldcp->id,
4370 "ldc_write: (0x%llx) channel down/reset\n", ldcp->id);
4373 if (mutex_tryenter(&ldcp->lock)) {
4374 i_ldc_reset(ldcp, B_FALSE);
4375 mutex_exit(&ldcp->lock);
4381 mutex_exit(&ldcp->tx_lock);
4382 mutex_enter(&ldcp->lock);
4383 mutex_enter(&ldcp->tx_lock);
4384 i_ldc_reset(ldcp, B_FALSE);
4385 mutex_exit(&ldcp->lock);
4390 tx_tail = ldcp->tx_tail;
4391 tx_head = ldcp->tx_head;
4393 ((ldcp->tx_q_entries-1) << LDC_PACKET_SHIFT);
4397 "ldc_write: (0x%llx) TX queue is full\n", ldcp->id);
4402 D2(ldcp->id, "ldc_write: (0x%llx) start xfer size=%d",
4403 ldcp->id, size);
4406 ldcmsg = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail);
4418 rv = i_ldc_set_tx_tail(ldcp, tx_tail);
4421 DWARN(ldcp->id, "ldc_write: (0x%llx) write timed out\n",
4422 ldcp->id);
4428 if (mutex_tryenter(&ldcp->lock)) {
4429 i_ldc_reset(ldcp, B_FALSE);
4430 mutex_exit(&ldcp->lock);
4436 mutex_exit(&ldcp->tx_lock);
4437 mutex_enter(&ldcp->lock);
4438 mutex_enter(&ldcp->tx_lock);
4439 i_ldc_reset(ldcp, B_FALSE);
4440 mutex_exit(&ldcp->lock);
4445 ldcp->tx_tail = tx_tail;
4448 D2(ldcp->id, "ldc_write: (0x%llx) end xfer size=%d", ldcp->id, size);
4464 i_ldc_write_packet(ldc_chan_t *ldcp, caddr_t buf, size_t *size)
4474 ASSERT(MUTEX_HELD(&ldcp->tx_lock));
4476 ASSERT(ldcp->mode == LDC_MODE_RELIABLE ||
4477 ldcp->mode == LDC_MODE_UNRELIABLE);
4480 txq_size_mask = (ldcp->tx_q_entries - 1) << LDC_PACKET_SHIFT;
4483 rv = hv_ldc_tx_get_state(ldcp->id,
4484 &ldcp->tx_head, &ldcp->tx_tail, &ldcp->link_state);
4487 "ldc_write: (0x%lx) cannot read queue ptrs\n", ldcp->id);
4492 if (ldcp->link_state == LDC_CHANNEL_DOWN ||
4493 ldcp->link_state == LDC_CHANNEL_RESET) {
4494 DWARN(ldcp->id,
4495 "ldc_write: (0x%llx) channel down/reset\n", ldcp->id);
4497 if (mutex_tryenter(&ldcp->lock)) {
4498 i_ldc_reset(ldcp, B_FALSE);
4499 mutex_exit(&ldcp->lock);
4505 mutex_exit(&ldcp->tx_lock);
4506 mutex_enter(&ldcp->lock);
4507 mutex_enter(&ldcp->tx_lock);
4508 i_ldc_reset(ldcp, B_FALSE);
4509 mutex_exit(&ldcp->lock);
4514 tx_tail = ldcp->tx_tail;
4516 (ldcp->tx_q_entries << LDC_PACKET_SHIFT);
4522 i_ldc_get_tx_head(ldcp, &tx_head);
4526 "ldc_write: (0x%llx) TX queue is full\n", ldcp->id);
4535 + ldcp->tx_q_entries - 1;
4536 numavail %= ldcp->tx_q_entries;
4538 if (*size > (numavail * ldcp->pkt_payload)) {
4540 "ldc_write: (0x%llx) TX queue has no space\n", ldcp->id);
4544 D2(ldcp->id, "ldc_write: (0x%llx) start xfer size=%d",
4545 ldcp->id, *size);
4549 curr_seqid = ldcp->last_msg_snt;
4554 ldcmsg = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail);
4556 msgbuf = (uint8_t *)((ldcp->mode == LDC_MODE_RELIABLE) ?
4564 len = min(ldcp->pkt_payload, remaining);
4584 ldcmsg = (ldc_msg_t *)(ldcp->tx_q_va + start);
4591 rv = i_ldc_set_tx_tail(ldcp, tx_tail);
4593 ldcp->tx_tail = tx_tail;
4594 ldcp->last_msg_snt = curr_seqid;
4601 if (mutex_tryenter(&ldcp->lock)) {
4602 i_ldc_reset(ldcp, B_FALSE);
4603 mutex_exit(&ldcp->lock);
4609 mutex_exit(&ldcp->tx_lock);
4610 mutex_enter(&ldcp->lock);
4611 mutex_enter(&ldcp->tx_lock);
4612 i_ldc_reset(ldcp, B_FALSE);
4613 mutex_exit(&ldcp->lock);
4618 D1(ldcp->id, "hv_tx_set_tail returns 0x%x (head 0x%x, "
4620 rv, ldcp->tx_head, ldcp->tx_tail, tx_tail,
4621 (ldcp->tx_q_entries << LDC_PACKET_SHIFT));
4623 rv2 = hv_ldc_tx_get_state(ldcp->id,
4624 &tx_head, &tx_tail, &ldcp->link_state);
4626 D1(ldcp->id, "hv_ldc_tx_get_state returns 0x%x "
4628 rv2, tx_head, tx_tail, ldcp->link_state);
4633 D2(ldcp->id, "ldc_write: (0x%llx) end xfer size=%d", ldcp->id, *size);
4648 i_ldc_write_stream(ldc_chan_t *ldcp, caddr_t buf, size_t *sizep)
4650 ASSERT(MUTEX_HELD(&ldcp->tx_lock));
4651 ASSERT(ldcp->mode == LDC_MODE_RELIABLE);
4654 if (*sizep > ldcp->mtu) *sizep = ldcp->mtu;
4655 return (i_ldc_write_packet(ldcp, buf, sizep));
4667 ldc_chan_t *ldcp;
4689 ldcp = ldcssp->chan_list;
4690 while (ldcp) {
4691 if ((ldcp->tstate & TS_QCONF_RDY) &&
4692 (ldcp->tstate & TS_CNEX_RDY) == 0)
4693 (void) i_ldc_register_channel(ldcp);
4695 ldcp = ldcp->next;
4735 ldc_chan_t *ldcp;
4743 ldcp = (ldc_chan_t *)handle;
4745 mutex_enter(&ldcp->lock);
4748 if ((ldcp->tstate & ~TS_IN_RESET) < TS_INIT) {
4749 DWARN(ldcp->id,
4751 ldcp->id);
4752 mutex_exit(&ldcp->lock);
4756 mutex_exit(&ldcp->lock);