Lines Matching +full:rx +full:- +full:ctrl
139 #define ACKPEEK_HEAD_INVALID ((uint64_t)-1)
176 * The length of the reliable-mode data queue in terms of the LDC
189 * LDC retry count and delay - when the HV returns EWOULDBLOCK
233 * 0x4 - Warnings
234 * 0x2 - All debug messages
235 * 0x1 - Minimal debug messages
238 * setting it to -1 prints debug messages for all channels
254 * caller wants to print it anyway - (id == DBG_ALL_LDCS) in ldcdebug()
255 * debug channel is set to all LDCs - (ldcdbgchan == DBG_ALL_LDCS) in ldcdebug()
279 if ((ldcdbgchan != DBG_ALL_LDCS) && (ldcdbgchan != ldcp->id)) in ldc_inject_error()
305 uint32_t mid = ((c)->mode != LDC_MODE_RAW) ? msg->seqid : 0; \
306 if (msg->type == LDC_DATA) { \
307 D2((c)->id, "%s: msg%d (/%x/%x/%x/,env[%c%c,sz=%d])", \
308 (s), mid, msg->type, msg->stype, msg->ctrl, \
309 (msg->env & LDC_FRAG_START) ? 'B' : ' ', \
310 (msg->env & LDC_FRAG_STOP) ? 'E' : ' ', \
311 (msg->env & LDC_LEN_MASK)); \
313 D2((c)->id, "%s: msg%d (/%x/%x/%x/,env=%x)", (s), \
314 mid, msg->type, msg->stype, msg->ctrl, msg->env); \
326 #define DBG_ALL_LDCS -1
339 * dtrace SDT probes to ease tracing of the rx data queue and HV queue
345 uint64_t, ldcp->id, \
346 uint64_t, ldcp->rx_dq_head, \
347 uint64_t, ldcp->rx_dq_tail, \
348 uint64_t, ldcp->rx_dq_entries)
352 uint64_t, ldcp->id, \
355 uint64_t, ldcp->rx_q_entries)
359 DTRACE_PROBE2(rxdq__copy, uint64_t, ldcp->id, uint64_t, bytes) \
363 ((head) <= (tail) ? ((size) - (tail)) : \
364 ((head) - (tail) - LDC_PACKET_SIZE))
383 return (-1); in _init()
402 mutex_init(&ldcssp->lock, NULL, MUTEX_DRIVER, NULL); in _init()
404 mutex_enter(&ldcssp->lock); in _init()
407 ldcssp->memhdl_cache = kmem_cache_create("ldc_memhdl_cache", in _init()
409 if (ldcssp->memhdl_cache == NULL) { in _init()
411 mutex_exit(&ldcssp->lock); in _init()
412 return (-1); in _init()
416 ldcssp->memseg_cache = kmem_cache_create("ldc_memseg_cache", in _init()
418 if (ldcssp->memseg_cache == NULL) { in _init()
420 mutex_exit(&ldcssp->lock); in _init()
421 return (-1); in _init()
425 ldcssp->channel_count = 0; in _init()
426 ldcssp->channels_open = 0; in _init()
427 ldcssp->chan_list = NULL; in _init()
428 ldcssp->dring_list = NULL; in _init()
433 mutex_exit(&ldcssp->lock); in _init()
464 dringp = ldcssp->dring_list; in _fini()
466 tmp_dringp = dringp->next; in _fini()
483 ldcssp->dring_list = NULL; in _fini()
486 ldcp = ldcssp->chan_list; in _fini()
488 tmp_ldcp = ldcp->next; in _fini()
495 ldcssp->chan_list = NULL; in _fini()
498 kmem_cache_destroy(ldcssp->memhdl_cache); in _fini()
499 kmem_cache_destroy(ldcssp->memseg_cache); in _fini()
505 mutex_destroy(&ldcssp->lock); in _fini()
513 /* -------------------------------------------------------------------------- */
571 ASSERT(MUTEX_HELD(&ldcp->lock)); in i_ldc_txq_reconf()
572 ASSERT(MUTEX_HELD(&ldcp->tx_lock)); in i_ldc_txq_reconf()
574 rv = hv_ldc_tx_qconf(ldcp->id, ldcp->tx_q_ra, ldcp->tx_q_entries); in i_ldc_txq_reconf()
577 "i_ldc_txq_reconf: (0x%lx) cannot set qconf", ldcp->id); in i_ldc_txq_reconf()
580 rv = hv_ldc_tx_get_state(ldcp->id, &(ldcp->tx_head), in i_ldc_txq_reconf()
581 &(ldcp->tx_tail), &(ldcp->link_state)); in i_ldc_txq_reconf()
584 "i_ldc_txq_reconf: (0x%lx) cannot get qptrs", ldcp->id); in i_ldc_txq_reconf()
587 D1(ldcp->id, "i_ldc_txq_reconf: (0x%llx) h=0x%llx,t=0x%llx," in i_ldc_txq_reconf()
588 "s=0x%llx\n", ldcp->id, ldcp->tx_head, ldcp->tx_tail, in i_ldc_txq_reconf()
589 ldcp->link_state); in i_ldc_txq_reconf()
603 ASSERT(MUTEX_HELD(&ldcp->lock)); in i_ldc_rxq_reconf()
604 rv = hv_ldc_rx_get_state(ldcp->id, &rx_head, &rx_tail, in i_ldc_rxq_reconf()
605 &(ldcp->link_state)); in i_ldc_rxq_reconf()
609 ldcp->id); in i_ldc_rxq_reconf()
613 if (force_reset || (ldcp->tstate & ~TS_IN_RESET) == TS_UP) { in i_ldc_rxq_reconf()
614 rv = hv_ldc_rx_qconf(ldcp->id, ldcp->rx_q_ra, in i_ldc_rxq_reconf()
615 ldcp->rx_q_entries); in i_ldc_rxq_reconf()
619 ldcp->id); in i_ldc_rxq_reconf()
622 D1(ldcp->id, "i_ldc_rxq_reconf: (0x%llx) completed q reconf", in i_ldc_rxq_reconf()
623 ldcp->id); in i_ldc_rxq_reconf()
640 ASSERT(MUTEX_HELD(&ldcp->lock)); in i_ldc_rxq_drain()
641 rv = hv_ldc_rx_get_state(ldcp->id, &rx_head, &rx_tail, in i_ldc_rxq_drain()
642 &(ldcp->link_state)); in i_ldc_rxq_drain()
645 "rv = 0x%x", ldcp->id, rv); in i_ldc_rxq_drain()
659 if ((rv = hv_ldc_rx_set_qhead(ldcp->id, rx_tail)) == 0) in i_ldc_rxq_drain()
664 if ((rv = hv_ldc_rx_set_qhead(ldcp->id, rx_tail)) == 0) in i_ldc_rxq_drain()
669 "rv = 0x%x", ldcp->id, rx_tail, rv); in i_ldc_rxq_drain()
679 ASSERT(MUTEX_HELD(&ldcp->lock)); in i_ldc_reset_state()
680 ldcp->last_msg_snt = LDC_INIT_SEQID; in i_ldc_reset_state()
681 ldcp->last_ack_rcd = 0; in i_ldc_reset_state()
682 ldcp->last_msg_rcd = 0; in i_ldc_reset_state()
683 ldcp->tx_ackd_head = ldcp->tx_head; in i_ldc_reset_state()
684 ldcp->stream_remains = 0; in i_ldc_reset_state()
685 ldcp->next_vidx = 0; in i_ldc_reset_state()
686 ldcp->hstate = 0; in i_ldc_reset_state()
687 ldcp->tstate = TS_OPEN; in i_ldc_reset_state()
688 ldcp->status = LDC_OPEN; in i_ldc_reset_state()
689 ldcp->rx_ack_head = ACKPEEK_HEAD_INVALID; in i_ldc_reset_state()
690 ldcp->rx_dq_head = 0; in i_ldc_reset_state()
691 ldcp->rx_dq_tail = 0; in i_ldc_reset_state()
693 if (ldcp->link_state == LDC_CHANNEL_UP || in i_ldc_reset_state()
694 ldcp->link_state == LDC_CHANNEL_RESET) { in i_ldc_reset_state()
696 if (ldcp->mode == LDC_MODE_RAW) { in i_ldc_reset_state()
697 ldcp->status = LDC_UP; in i_ldc_reset_state()
698 ldcp->tstate = TS_UP; in i_ldc_reset_state()
700 ldcp->status = LDC_READY; in i_ldc_reset_state()
701 ldcp->tstate |= TS_LINK_READY; in i_ldc_reset_state()
712 DWARN(ldcp->id, "i_ldc_reset: (0x%llx) channel reset\n", ldcp->id); in i_ldc_reset()
714 ASSERT(MUTEX_HELD(&ldcp->lock)); in i_ldc_reset()
715 ASSERT(MUTEX_HELD(&ldcp->tx_lock)); in i_ldc_reset()
717 /* reconfig Tx and Rx queues */ in i_ldc_reset()
721 /* Clear Tx and Rx interrupts */ in i_ldc_reset()
729 ldcp->tstate |= TS_IN_RESET; in i_ldc_reset()
734 * devclass and their Rx queues have been configured. No locks are
736 * entering the prom or debugger when the system is single-threaded.
743 ldcp = ldcssp->chan_list; in i_ldc_debug_enter()
745 if (((ldcp->tstate & TS_QCONF_RDY) == TS_QCONF_RDY) && in i_ldc_debug_enter()
746 (LDC_DEVCLASS_PROM_RESET(ldcp->devclass) != 0)) { in i_ldc_debug_enter()
747 (void) hv_ldc_rx_qconf(ldcp->id, ldcp->rx_q_ra, in i_ldc_debug_enter()
748 ldcp->rx_q_entries); in i_ldc_debug_enter()
750 ldcp = ldcp->next; in i_ldc_debug_enter()
760 ldc_cnex_t *cinfo = &ldcssp->cinfo; in i_ldc_clear_intr()
762 ASSERT(MUTEX_HELD(&ldcp->lock)); in i_ldc_clear_intr()
763 ASSERT(cinfo->dip != NULL); in i_ldc_clear_intr()
768 if (ldcp->tx_intr_state) in i_ldc_clear_intr()
769 ldcp->tx_intr_state = LDC_INTR_NONE; in i_ldc_clear_intr()
775 /* check Rx interrupt */ in i_ldc_clear_intr()
776 if (ldcp->rx_intr_state) in i_ldc_clear_intr()
777 ldcp->rx_intr_state = LDC_INTR_NONE; in i_ldc_clear_intr()
783 (void) cinfo->clr_intr(cinfo->dip, ldcp->id, itype); in i_ldc_clear_intr()
784 D2(ldcp->id, in i_ldc_clear_intr()
786 ldcp->id, itype); in i_ldc_clear_intr()
799 ASSERT(MUTEX_HELD(&ldcp->lock)); in i_ldc_set_rx_head()
802 if ((rv = hv_ldc_rx_set_qhead(ldcp->id, head)) == 0) in i_ldc_set_rx_head()
813 "rv = 0x%x", ldcp->id, head, rv); in i_ldc_set_rx_head()
814 mutex_enter(&ldcp->tx_lock); in i_ldc_set_rx_head()
816 mutex_exit(&ldcp->tx_lock); in i_ldc_set_rx_head()
829 ASSERT(MUTEX_HELD(&ldcp->tx_lock)); in i_ldc_get_tx_head()
832 *head = ldcp->tx_head; in i_ldc_get_tx_head()
840 if (ldcp->mode == LDC_MODE_RELIABLE) { in i_ldc_get_tx_head()
841 while (ldcp->tx_ackd_head != ldcp->tx_head) { in i_ldc_get_tx_head()
842 pkt = (ldc_msg_t *)(ldcp->tx_q_va + ldcp->tx_ackd_head); in i_ldc_get_tx_head()
843 if ((pkt->type & LDC_DATA) && (pkt->stype & LDC_INFO)) { in i_ldc_get_tx_head()
847 ldcp->tx_ackd_head = in i_ldc_get_tx_head()
848 (ldcp->tx_ackd_head + LDC_PACKET_SIZE) % in i_ldc_get_tx_head()
849 (ldcp->tx_q_entries << LDC_PACKET_SHIFT); in i_ldc_get_tx_head()
851 *head = ldcp->tx_ackd_head; in i_ldc_get_tx_head()
857 * Re-reads the TX queue ptrs if and only if the
866 ASSERT(MUTEX_HELD(&ldcp->tx_lock)); in i_ldc_get_tx_tail()
868 rv = hv_ldc_tx_get_state(ldcp->id, in i_ldc_get_tx_tail()
869 &ldcp->tx_head, &ldcp->tx_tail, &ldcp->link_state); in i_ldc_get_tx_tail()
873 ldcp->id); in i_ldc_get_tx_tail()
876 if (ldcp->link_state == LDC_CHANNEL_DOWN) { in i_ldc_get_tx_tail()
877 D1(ldcp->id, "i_ldc_get_tx_tail: (0x%llx) channel not ready\n", in i_ldc_get_tx_tail()
878 ldcp->id); in i_ldc_get_tx_tail()
885 new_tail = (ldcp->tx_tail + LDC_PACKET_SIZE) % in i_ldc_get_tx_tail()
886 (ldcp->tx_q_entries << LDC_PACKET_SHIFT); in i_ldc_get_tx_tail()
889 DWARN(ldcp->id, in i_ldc_get_tx_tail()
891 ldcp->id); in i_ldc_get_tx_tail()
895 D2(ldcp->id, "i_ldc_get_tx_tail: (0x%llx) head=0x%llx, tail=0x%llx\n", in i_ldc_get_tx_tail()
896 ldcp->id, ldcp->tx_head, ldcp->tx_tail); in i_ldc_get_tx_tail()
898 *tail = ldcp->tx_tail; in i_ldc_get_tx_tail()
913 ASSERT(MUTEX_HELD(&ldcp->tx_lock)); in i_ldc_set_tx_tail()
916 if ((rv = hv_ldc_tx_set_qtail(ldcp->id, tail)) == 0) { in i_ldc_set_tx_tail()
921 DWARN(ldcp->id, "i_ldc_set_tx_tail: (0x%llx) set " in i_ldc_set_tx_tail()
922 "qtail=0x%llx failed, rv=%d\n", ldcp->id, tail, rv); in i_ldc_set_tx_tail()
947 ASSERT(MUTEX_HELD(&ldcp->lock)); in i_ldc_rxdq_copy()
949 q_size = ldcp->rx_q_entries << LDC_PACKET_SHIFT; in i_ldc_rxdq_copy()
950 dq_size = ldcp->rx_dq_entries << LDC_PACKET_SHIFT; in i_ldc_rxdq_copy()
952 ASSERT(Q_CONTIG_SPACE(ldcp->rx_dq_head, ldcp->rx_dq_tail, in i_ldc_rxdq_copy()
955 bcopy((void *)(ldcp->rx_q_va + *head), in i_ldc_rxdq_copy()
956 (void *)(ldcp->rx_dq_va + ldcp->rx_dq_tail), LDC_PACKET_SIZE); in i_ldc_rxdq_copy()
959 /* Update rx head */ in i_ldc_rxdq_copy()
963 ldcp->rx_dq_tail = (ldcp->rx_dq_tail + LDC_PACKET_SIZE) % dq_size; in i_ldc_rxdq_copy()
967 * Update the Rx data queue head pointer
972 ldcp->rx_dq_head = head; in i_ldc_set_rxdq_head()
977 * Get the Rx data queue head and tail pointers
984 *head = ldcp->rx_dq_head; in i_ldc_dq_rx_get_state()
985 *tail = ldcp->rx_dq_tail; in i_ldc_dq_rx_get_state()
990 * Wrapper for the Rx HV queue set head function. Giving the
997 return (i_ldc_h2v_error(hv_ldc_rx_get_state(ldcp->id, head, tail, in i_ldc_hvq_rx_get_state()
1004 * i.e. Rx queue content changes
1024 D1(ldcp->id, "i_ldc_rx_hdlr: (0x%llx) Received intr, ldcp=0x%p\n", in i_ldc_rx_hdlr()
1025 ldcp->id, ldcp); in i_ldc_rx_hdlr()
1026 D1(ldcp->id, "i_ldc_rx_hdlr: (%llx) USR%lx/TS%lx/HS%lx, LSTATE=%lx\n", in i_ldc_rx_hdlr()
1027 ldcp->id, ldcp->status, ldcp->tstate, ldcp->hstate, in i_ldc_rx_hdlr()
1028 ldcp->link_state); in i_ldc_rx_hdlr()
1031 mutex_enter(&ldcp->lock); in i_ldc_rx_hdlr()
1034 ldcp->rx_intr_state = LDC_INTR_ACTIVE; in i_ldc_rx_hdlr()
1038 if (ldcp->mode != LDC_MODE_RELIABLE) { in i_ldc_rx_hdlr()
1049 ldcp->rx_intr_state = LDC_INTR_PEND; in i_ldc_rx_hdlr()
1054 if (notify && ldcp->cb_enabled) { in i_ldc_rx_hdlr()
1055 ldcp->cb_inprogress = B_TRUE; in i_ldc_rx_hdlr()
1056 mutex_exit(&ldcp->lock); in i_ldc_rx_hdlr()
1057 rv = ldcp->cb(event, ldcp->cb_arg); in i_ldc_rx_hdlr()
1059 DWARN(ldcp->id, in i_ldc_rx_hdlr()
1061 ldcp->id); in i_ldc_rx_hdlr()
1063 mutex_enter(&ldcp->lock); in i_ldc_rx_hdlr()
1064 ldcp->cb_inprogress = B_FALSE; in i_ldc_rx_hdlr()
1067 if (ldcp->mode == LDC_MODE_RELIABLE) { in i_ldc_rx_hdlr()
1071 * queue is full and the Rx queue is non-empty. in i_ldc_rx_hdlr()
1073 * handled above, since the Rx queue is non- in i_ldc_rx_hdlr()
1077 ldcp->rx_intr_state = LDC_INTR_PEND; in i_ldc_rx_hdlr()
1080 * We have processed all CTRL packets and in i_ldc_rx_hdlr()
1088 mutex_exit(&ldcp->lock); in i_ldc_rx_hdlr()
1090 D1(ldcp->id, "i_ldc_rx_hdlr: (0x%llx) exiting handler", ldcp->id); in i_ldc_rx_hdlr()
1096 * Wrapper for the Rx HV queue processing function to be used when
1097 * checking the Rx HV queue for data packets. Unlike the interrupt
1098 * handler code flow, the Rx interrupt is not cleared here and
1123 mutex_enter(&ldcp->tx_lock); in i_ldc_send_pkt()
1125 curr_seqid = ldcp->last_msg_snt; in i_ldc_send_pkt()
1130 DWARN(ldcp->id, in i_ldc_send_pkt()
1132 "type=0x%x,subtype=0x%x,ctrl=0x%x\n", in i_ldc_send_pkt()
1133 ldcp->id, pkttype, subtype, ctrlmsg); in i_ldc_send_pkt()
1134 mutex_exit(&ldcp->tx_lock); in i_ldc_send_pkt()
1138 pkt = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail); in i_ldc_send_pkt()
1142 pkt->type = pkttype; in i_ldc_send_pkt()
1143 pkt->stype = subtype; in i_ldc_send_pkt()
1144 pkt->ctrl = ctrlmsg; in i_ldc_send_pkt()
1150 if (ldcp->mode != LDC_MODE_RAW) { in i_ldc_send_pkt()
1151 pkt->seqid = curr_seqid; in i_ldc_send_pkt()
1152 pkt->ackid = ldcp->last_msg_rcd; in i_ldc_send_pkt()
1159 (ldcp->tx_q_entries << LDC_PACKET_SHIFT); in i_ldc_send_pkt()
1163 DWARN(ldcp->id, in i_ldc_send_pkt()
1165 "type=0x%x,stype=0x%x,ctrl=0x%x\n", in i_ldc_send_pkt()
1166 ldcp->id, pkttype, subtype, ctrlmsg); in i_ldc_send_pkt()
1167 mutex_exit(&ldcp->tx_lock); in i_ldc_send_pkt()
1171 ldcp->last_msg_snt = curr_seqid; in i_ldc_send_pkt()
1172 ldcp->tx_tail = tx_tail; in i_ldc_send_pkt()
1174 mutex_exit(&ldcp->tx_lock); in i_ldc_send_pkt()
1187 if (ldcp->mode == LDC_MODE_RAW) in i_ldc_check_seqid()
1191 if (msg->ctrl == LDC_VER || in i_ldc_check_seqid()
1192 msg->ctrl == LDC_RTS || in i_ldc_check_seqid()
1193 msg->ctrl == LDC_RTR) in i_ldc_check_seqid()
1197 if (msg->seqid != (ldcp->last_msg_rcd + 1)) { in i_ldc_check_seqid()
1198 DWARN(ldcp->id, in i_ldc_check_seqid()
1199 "i_ldc_check_seqid: (0x%llx) out-of-order pkt, got 0x%x, " in i_ldc_check_seqid()
1200 "expecting 0x%x\n", ldcp->id, msg->seqid, in i_ldc_check_seqid()
1201 (ldcp->last_msg_rcd + 1)); in i_ldc_check_seqid()
1207 DWARN(ldcp->id, in i_ldc_check_seqid()
1208 "i_ldc_check_seqid: (0x%llx) inject pkt loss\n", ldcp->id); in i_ldc_check_seqid()
1218 * Process an incoming version ctrl message
1223 int rv = 0, idx = ldcp->next_vidx; in i_ldc_process_VER()
1231 D2(ldcp->id, "i_ldc_process_VER: (0x%llx) received VER v%u.%u\n", in i_ldc_process_VER()
1232 ldcp->id, rcvd_ver->major, rcvd_ver->minor); in i_ldc_process_VER()
1235 mutex_enter(&ldcp->tx_lock); in i_ldc_process_VER()
1237 switch (msg->stype) { in i_ldc_process_VER()
1240 if ((ldcp->tstate & ~TS_IN_RESET) == TS_VREADY) { in i_ldc_process_VER()
1243 mutex_exit(&ldcp->tx_lock); in i_ldc_process_VER()
1250 DWARN(ldcp->id, in i_ldc_process_VER()
1252 "version ACK/NACK\n", ldcp->id); in i_ldc_process_VER()
1254 mutex_exit(&ldcp->tx_lock); in i_ldc_process_VER()
1258 pkt = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail); in i_ldc_process_VER()
1262 pkt->type = LDC_CTRL; in i_ldc_process_VER()
1263 pkt->ctrl = LDC_VER; in i_ldc_process_VER()
1267 D1(ldcp->id, "i_ldc_process_VER: got %u.%u chk %u.%u\n", in i_ldc_process_VER()
1268 rcvd_ver->major, rcvd_ver->minor, in i_ldc_process_VER()
1271 if (rcvd_ver->major == ldc_versions[idx].major) { in i_ldc_process_VER()
1272 /* major version match - ACK version */ in i_ldc_process_VER()
1273 pkt->stype = LDC_ACK; in i_ldc_process_VER()
1279 if (rcvd_ver->minor > ldc_versions[idx].minor) in i_ldc_process_VER()
1280 rcvd_ver->minor = in i_ldc_process_VER()
1282 bcopy(rcvd_ver, pkt->udata, sizeof (*rcvd_ver)); in i_ldc_process_VER()
1287 if (rcvd_ver->major > ldc_versions[idx].major) { in i_ldc_process_VER()
1289 D1(ldcp->id, "i_ldc_process_VER: using next" in i_ldc_process_VER()
1295 pkt->stype = LDC_NACK; in i_ldc_process_VER()
1296 bcopy(&ldc_versions[idx], pkt->udata, in i_ldc_process_VER()
1298 ldcp->next_vidx = idx; in i_ldc_process_VER()
1305 D1(ldcp->id, "i_ldc_process_VER: inc idx %x\n", idx); in i_ldc_process_VER()
1308 /* no version match - send NACK */ in i_ldc_process_VER()
1309 pkt->stype = LDC_NACK; in i_ldc_process_VER()
1310 bzero(pkt->udata, sizeof (ldc_ver_t)); in i_ldc_process_VER()
1311 ldcp->next_vidx = 0; in i_ldc_process_VER()
1318 (ldcp->tx_q_entries << LDC_PACKET_SHIFT); in i_ldc_process_VER()
1322 ldcp->tx_tail = tx_tail; in i_ldc_process_VER()
1323 if (pkt->stype == LDC_ACK) { in i_ldc_process_VER()
1324 D2(ldcp->id, "i_ldc_process_VER: (0x%llx) sent" in i_ldc_process_VER()
1325 " version ACK\n", ldcp->id); in i_ldc_process_VER()
1327 ldcp->version.major = rcvd_ver->major; in i_ldc_process_VER()
1328 ldcp->version.minor = rcvd_ver->minor; in i_ldc_process_VER()
1329 ldcp->hstate |= TS_RCVD_VER; in i_ldc_process_VER()
1330 ldcp->tstate |= TS_VER_DONE; in i_ldc_process_VER()
1334 ldcp->id, rcvd_ver->major, rcvd_ver->minor); in i_ldc_process_VER()
1337 DWARN(ldcp->id, in i_ldc_process_VER()
1339 "ACK/NACK\n", ldcp->id); in i_ldc_process_VER()
1341 mutex_exit(&ldcp->tx_lock); in i_ldc_process_VER()
1348 if ((ldcp->tstate & ~TS_IN_RESET) == TS_VREADY) { in i_ldc_process_VER()
1349 if (ldcp->version.major != rcvd_ver->major || in i_ldc_process_VER()
1350 ldcp->version.minor != rcvd_ver->minor) { in i_ldc_process_VER()
1352 /* mismatched version - reset connection */ in i_ldc_process_VER()
1353 DWARN(ldcp->id, in i_ldc_process_VER()
1355 " ACK ver != sent ACK ver\n", ldcp->id); in i_ldc_process_VER()
1357 mutex_exit(&ldcp->tx_lock); in i_ldc_process_VER()
1361 /* SUCCESS - we have agreed on a version */ in i_ldc_process_VER()
1362 ldcp->version.major = rcvd_ver->major; in i_ldc_process_VER()
1363 ldcp->version.minor = rcvd_ver->minor; in i_ldc_process_VER()
1364 ldcp->tstate |= TS_VER_DONE; in i_ldc_process_VER()
1367 D1(ldcp->id, "(0x%llx) Got ACK, Agreed on version v%u.%u\n", in i_ldc_process_VER()
1368 ldcp->id, rcvd_ver->major, rcvd_ver->minor); in i_ldc_process_VER()
1370 /* initiate RTS-RTR-RDX handshake */ in i_ldc_process_VER()
1373 DWARN(ldcp->id, in i_ldc_process_VER()
1375 ldcp->id); in i_ldc_process_VER()
1377 mutex_exit(&ldcp->tx_lock); in i_ldc_process_VER()
1381 pkt = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail); in i_ldc_process_VER()
1384 pkt->type = LDC_CTRL; in i_ldc_process_VER()
1385 pkt->stype = LDC_INFO; in i_ldc_process_VER()
1386 pkt->ctrl = LDC_RTS; in i_ldc_process_VER()
1387 pkt->env = ldcp->mode; in i_ldc_process_VER()
1388 if (ldcp->mode != LDC_MODE_RAW) in i_ldc_process_VER()
1389 pkt->seqid = LDC_INIT_SEQID; in i_ldc_process_VER()
1391 ldcp->last_msg_rcd = LDC_INIT_SEQID; in i_ldc_process_VER()
1397 (ldcp->tx_q_entries << LDC_PACKET_SHIFT); in i_ldc_process_VER()
1401 D2(ldcp->id, in i_ldc_process_VER()
1403 ldcp->id); in i_ldc_process_VER()
1405 mutex_exit(&ldcp->tx_lock); in i_ldc_process_VER()
1409 ldcp->tx_tail = tx_tail; in i_ldc_process_VER()
1410 ldcp->hstate |= TS_SENT_RTS; in i_ldc_process_VER()
1416 if (rcvd_ver->major == 0 && rcvd_ver->minor == 0) { in i_ldc_process_VER()
1420 ldcp->id); in i_ldc_process_VER()
1422 mutex_exit(&ldcp->tx_lock); in i_ldc_process_VER()
1431 "version ACK/NACK\n", ldcp->id); in i_ldc_process_VER()
1433 mutex_exit(&ldcp->tx_lock); in i_ldc_process_VER()
1437 pkt = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail); in i_ldc_process_VER()
1441 pkt->type = LDC_CTRL; in i_ldc_process_VER()
1442 pkt->ctrl = LDC_VER; in i_ldc_process_VER()
1443 pkt->stype = LDC_INFO; in i_ldc_process_VER()
1447 if (rcvd_ver->major == ldc_versions[idx].major) { in i_ldc_process_VER()
1449 * major version match - resubmit request in i_ldc_process_VER()
1453 if (rcvd_ver->minor > ldc_versions[idx].minor) in i_ldc_process_VER()
1454 rcvd_ver->minor = in i_ldc_process_VER()
1456 bcopy(rcvd_ver, pkt->udata, sizeof (*rcvd_ver)); in i_ldc_process_VER()
1460 if (rcvd_ver->major > ldc_versions[idx].major) { in i_ldc_process_VER()
1462 D1(ldcp->id, "i_ldc_process_VER: using next" in i_ldc_process_VER()
1468 bcopy(&ldc_versions[idx], pkt->udata, in i_ldc_process_VER()
1470 ldcp->next_vidx = idx; in i_ldc_process_VER()
1477 D1(ldcp->id, "i_ldc_process_VER: inc idx %x\n", idx); in i_ldc_process_VER()
1480 /* no version match - terminate */ in i_ldc_process_VER()
1481 ldcp->next_vidx = 0; in i_ldc_process_VER()
1482 mutex_exit(&ldcp->tx_lock); in i_ldc_process_VER()
1489 (ldcp->tx_q_entries << LDC_PACKET_SHIFT); in i_ldc_process_VER()
1493 D2(ldcp->id, "i_ldc_process_VER: (0x%llx) sent version" in i_ldc_process_VER()
1494 "INFO v%u.%u\n", ldcp->id, ldc_versions[idx].major, in i_ldc_process_VER()
1496 ldcp->tx_tail = tx_tail; in i_ldc_process_VER()
1500 "INFO\n", ldcp->id); in i_ldc_process_VER()
1502 mutex_exit(&ldcp->tx_lock); in i_ldc_process_VER()
1509 mutex_exit(&ldcp->tx_lock); in i_ldc_process_VER()
1515 * Process an incoming RTS ctrl message
1525 D2(ldcp->id, "i_ldc_process_RTS: (0x%llx) received RTS\n", ldcp->id); in i_ldc_process_RTS()
1527 switch (msg->stype) { in i_ldc_process_RTS()
1529 DWARN(ldcp->id, in i_ldc_process_RTS()
1531 ldcp->id); in i_ldc_process_RTS()
1533 /* Reset the channel -- as we cannot continue */ in i_ldc_process_RTS()
1534 mutex_enter(&ldcp->tx_lock); in i_ldc_process_RTS()
1536 mutex_exit(&ldcp->tx_lock); in i_ldc_process_RTS()
1543 if (ldcp->mode != (ldc_mode_t)msg->env) { in i_ldc_process_RTS()
1546 ldcp->id); in i_ldc_process_RTS()
1553 /* if cannot send NACK - reset channel */ in i_ldc_process_RTS()
1554 mutex_enter(&ldcp->tx_lock); in i_ldc_process_RTS()
1556 mutex_exit(&ldcp->tx_lock); in i_ldc_process_RTS()
1564 DWARN(ldcp->id, "i_ldc_process_RTS: (0x%llx) unexp ACK\n", in i_ldc_process_RTS()
1565 ldcp->id); in i_ldc_process_RTS()
1566 mutex_enter(&ldcp->tx_lock); in i_ldc_process_RTS()
1568 mutex_exit(&ldcp->tx_lock); in i_ldc_process_RTS()
1583 ldcp->hstate |= TS_RCVD_RTS; in i_ldc_process_RTS()
1586 ldcp->last_msg_snt = msg->seqid; in i_ldc_process_RTS()
1589 mutex_enter(&ldcp->tx_lock); in i_ldc_process_RTS()
1596 ldcp->id); in i_ldc_process_RTS()
1598 mutex_exit(&ldcp->tx_lock); in i_ldc_process_RTS()
1602 pkt = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail); in i_ldc_process_RTS()
1606 pkt->type = LDC_CTRL; in i_ldc_process_RTS()
1607 pkt->stype = LDC_INFO; in i_ldc_process_RTS()
1608 pkt->ctrl = LDC_RTR; in i_ldc_process_RTS()
1609 pkt->env = ldcp->mode; in i_ldc_process_RTS()
1610 if (ldcp->mode != LDC_MODE_RAW) in i_ldc_process_RTS()
1611 pkt->seqid = LDC_INIT_SEQID; in i_ldc_process_RTS()
1613 ldcp->last_msg_rcd = msg->seqid; in i_ldc_process_RTS()
1617 (ldcp->tx_q_entries << LDC_PACKET_SHIFT); in i_ldc_process_RTS()
1621 D2(ldcp->id, in i_ldc_process_RTS()
1622 "i_ldc_process_RTS: (0x%llx) sent RTR\n", ldcp->id); in i_ldc_process_RTS()
1625 ldcp->tx_tail = tx_tail; in i_ldc_process_RTS()
1626 ldcp->hstate |= TS_SENT_RTR; in i_ldc_process_RTS()
1631 ldcp->id); in i_ldc_process_RTS()
1633 mutex_exit(&ldcp->tx_lock); in i_ldc_process_RTS()
1637 mutex_exit(&ldcp->tx_lock); in i_ldc_process_RTS()
1642 * Process an incoming RTR ctrl message
1650 D2(ldcp->id, "i_ldc_process_RTR: (0x%llx) received RTR\n", ldcp->id); in i_ldc_process_RTR()
1652 switch (msg->stype) { in i_ldc_process_RTR()
1655 DWARN(ldcp->id, in i_ldc_process_RTR()
1657 ldcp->id); in i_ldc_process_RTR()
1659 /* Reset the channel -- as we cannot continue */ in i_ldc_process_RTR()
1660 mutex_enter(&ldcp->tx_lock); in i_ldc_process_RTR()
1662 mutex_exit(&ldcp->tx_lock); in i_ldc_process_RTR()
1670 if (ldcp->mode != (ldc_mode_t)msg->env) { in i_ldc_process_RTR()
1671 DWARN(ldcp->id, in i_ldc_process_RTR()
1674 ldcp->id, ldcp->mode, (ldc_mode_t)msg->env); in i_ldc_process_RTR()
1681 /* if cannot send NACK - reset channel */ in i_ldc_process_RTR()
1682 mutex_enter(&ldcp->tx_lock); in i_ldc_process_RTR()
1684 mutex_exit(&ldcp->tx_lock); in i_ldc_process_RTR()
1693 DWARN(ldcp->id, "i_ldc_process_RTR: (0x%llx) unexp ACK\n", in i_ldc_process_RTR()
1694 ldcp->id); in i_ldc_process_RTR()
1696 /* Reset the channel -- as we cannot continue */ in i_ldc_process_RTR()
1697 mutex_enter(&ldcp->tx_lock); in i_ldc_process_RTR()
1699 mutex_exit(&ldcp->tx_lock); in i_ldc_process_RTR()
1713 ldcp->last_msg_snt = msg->seqid; in i_ldc_process_RTR()
1714 ldcp->hstate |= TS_RCVD_RTR; in i_ldc_process_RTR()
1720 ldcp->id); in i_ldc_process_RTR()
1721 mutex_enter(&ldcp->tx_lock); in i_ldc_process_RTR()
1723 mutex_exit(&ldcp->tx_lock); in i_ldc_process_RTR()
1726 D2(ldcp->id, in i_ldc_process_RTR()
1727 "i_ldc_process_RTR: (0x%llx) sent RDX\n", ldcp->id); in i_ldc_process_RTR()
1729 ldcp->hstate |= TS_SENT_RDX; in i_ldc_process_RTR()
1730 ldcp->tstate |= TS_HSHAKE_DONE; in i_ldc_process_RTR()
1731 if ((ldcp->tstate & TS_IN_RESET) == 0) in i_ldc_process_RTR()
1732 ldcp->status = LDC_UP; in i_ldc_process_RTR()
1734 D1(ldcp->id, "(0x%llx) Handshake Complete\n", ldcp->id); in i_ldc_process_RTR()
1741 * Process an incoming RDX ctrl message
1748 D2(ldcp->id, "i_ldc_process_RDX: (0x%llx) received RDX\n", ldcp->id); in i_ldc_process_RDX()
1750 switch (msg->stype) { in i_ldc_process_RDX()
1753 DWARN(ldcp->id, in i_ldc_process_RDX()
1755 ldcp->id); in i_ldc_process_RDX()
1757 /* Reset the channel -- as we cannot continue */ in i_ldc_process_RDX()
1758 mutex_enter(&ldcp->tx_lock); in i_ldc_process_RDX()
1760 mutex_exit(&ldcp->tx_lock); in i_ldc_process_RDX()
1771 if ((ldcp->tstate == TS_UP) && (ldcp->hstate & TS_RCVD_RDX)) { in i_ldc_process_RDX()
1774 " - LDC reset\n", ldcp->id); in i_ldc_process_RDX()
1775 mutex_enter(&ldcp->tx_lock); in i_ldc_process_RDX()
1777 mutex_exit(&ldcp->tx_lock); in i_ldc_process_RDX()
1781 ldcp->hstate |= TS_RCVD_RDX; in i_ldc_process_RDX()
1782 ldcp->tstate |= TS_HSHAKE_DONE; in i_ldc_process_RDX()
1783 if ((ldcp->tstate & TS_IN_RESET) == 0) in i_ldc_process_RDX()
1784 ldcp->status = LDC_UP; in i_ldc_process_RDX()
1786 D1(DBG_ALL_LDCS, "(0x%llx) Handshake Complete\n", ldcp->id); in i_ldc_process_RDX()
1790 DWARN(ldcp->id, "i_ldc_process_RDX: (0x%llx) unexp ACK\n", in i_ldc_process_RDX()
1791 ldcp->id); in i_ldc_process_RDX()
1793 /* Reset the channel -- as we cannot continue */ in i_ldc_process_RDX()
1794 mutex_enter(&ldcp->tx_lock); in i_ldc_process_RDX()
1796 mutex_exit(&ldcp->tx_lock); in i_ldc_process_RDX()
1815 mutex_enter(&ldcp->tx_lock); in i_ldc_process_data_ACK()
1820 rv = hv_ldc_tx_get_state(ldcp->id, in i_ldc_process_data_ACK()
1821 &ldcp->tx_head, &ldcp->tx_tail, &ldcp->link_state); in i_ldc_process_data_ACK()
1825 ldcp->id); in i_ldc_process_data_ACK()
1827 /* Reset the channel -- as we cannot continue */ in i_ldc_process_data_ACK()
1829 mutex_exit(&ldcp->tx_lock); in i_ldc_process_data_ACK()
1839 tx_head = ldcp->tx_ackd_head; in i_ldc_process_data_ACK()
1841 pkt = (ldc_msg_t *)(ldcp->tx_q_va + tx_head); in i_ldc_process_data_ACK()
1843 (ldcp->tx_q_entries << LDC_PACKET_SHIFT); in i_ldc_process_data_ACK()
1845 if (pkt->seqid == msg->ackid) { in i_ldc_process_data_ACK()
1846 D2(ldcp->id, in i_ldc_process_data_ACK()
1848 ldcp->id); in i_ldc_process_data_ACK()
1849 ldcp->last_ack_rcd = msg->ackid; in i_ldc_process_data_ACK()
1850 ldcp->tx_ackd_head = tx_head; in i_ldc_process_data_ACK()
1853 if (tx_head == ldcp->tx_head) { in i_ldc_process_data_ACK()
1855 DWARN(ldcp->id, in i_ldc_process_data_ACK()
1857 ldcp->id); in i_ldc_process_data_ACK()
1859 /* Reset the channel -- as we cannot continue */ in i_ldc_process_data_ACK()
1861 mutex_exit(&ldcp->tx_lock); in i_ldc_process_data_ACK()
1866 mutex_exit(&ldcp->tx_lock); in i_ldc_process_data_ACK()
1872 * Return 0 - session can continue
1873 * EAGAIN - reprocess packet - state was changed
1874 * ECONNRESET - channel was reset
1881 D1(ldcp->id, "i_ldc_ctrlmsg: (%llx) tstate = %lx, hstate = %lx\n", in i_ldc_ctrlmsg()
1882 ldcp->id, ldcp->tstate, ldcp->hstate); in i_ldc_ctrlmsg()
1884 switch (ldcp->tstate & ~TS_IN_RESET) { in i_ldc_ctrlmsg()
1889 switch (msg->ctrl & LDC_CTRL_MASK) { in i_ldc_ctrlmsg()
1895 DWARN(ldcp->id, in i_ldc_ctrlmsg()
1896 "i_ldc_ctrlmsg: (0x%llx) unexp ctrl 0x%x " in i_ldc_ctrlmsg()
1897 "tstate=0x%x\n", ldcp->id, in i_ldc_ctrlmsg()
1898 (msg->ctrl & LDC_CTRL_MASK), ldcp->tstate); in i_ldc_ctrlmsg()
1906 switch (msg->ctrl & LDC_CTRL_MASK) { in i_ldc_ctrlmsg()
1924 DWARN(ldcp->id, in i_ldc_ctrlmsg()
1925 "i_ldc_ctrlmsg: (0x%llx) unexp ctrl 0x%x " in i_ldc_ctrlmsg()
1926 "tstate=0x%x\n", ldcp->id, in i_ldc_ctrlmsg()
1927 (msg->ctrl & LDC_CTRL_MASK), ldcp->tstate); in i_ldc_ctrlmsg()
1935 switch (msg->ctrl & LDC_CTRL_MASK) { in i_ldc_ctrlmsg()
1937 DWARN(ldcp->id, in i_ldc_ctrlmsg()
1939 "- LDC reset\n", ldcp->id); in i_ldc_ctrlmsg()
1941 mutex_enter(&ldcp->tx_lock); in i_ldc_ctrlmsg()
1944 mutex_exit(&ldcp->tx_lock); in i_ldc_ctrlmsg()
1954 DWARN(ldcp->id, in i_ldc_ctrlmsg()
1955 "i_ldc_ctrlmsg: (0x%llx) unexp ctrl 0x%x " in i_ldc_ctrlmsg()
1956 "tstate=0x%x\n", ldcp->id, in i_ldc_ctrlmsg()
1957 (msg->ctrl & LDC_CTRL_MASK), ldcp->tstate); in i_ldc_ctrlmsg()
1972 ldc_cnex_t *cinfo = &ldcssp->cinfo; in i_ldc_register_channel()
1974 if (cinfo->dip == NULL) { in i_ldc_register_channel()
1975 DWARN(ldcp->id, in i_ldc_register_channel()
1980 rv = cinfo->reg_chan(cinfo->dip, ldcp->id, ldcp->devclass); in i_ldc_register_channel()
1982 DWARN(ldcp->id, in i_ldc_register_channel()
1987 rv = cinfo->add_intr(cinfo->dip, ldcp->id, CNEX_TX_INTR, in i_ldc_register_channel()
1990 DWARN(ldcp->id, in i_ldc_register_channel()
1992 (void) cinfo->unreg_chan(cinfo->dip, ldcp->id); in i_ldc_register_channel()
1996 rv = cinfo->add_intr(cinfo->dip, ldcp->id, CNEX_RX_INTR, in i_ldc_register_channel()
1999 DWARN(ldcp->id, in i_ldc_register_channel()
2000 "i_ldc_register_channel: cannot add Rx interrupt\n"); in i_ldc_register_channel()
2001 (void) cinfo->rem_intr(cinfo->dip, ldcp->id, CNEX_TX_INTR); in i_ldc_register_channel()
2002 (void) cinfo->unreg_chan(cinfo->dip, ldcp->id); in i_ldc_register_channel()
2006 ldcp->tstate |= TS_CNEX_RDY; in i_ldc_register_channel()
2018 ldc_cnex_t *cinfo = &ldcssp->cinfo; in i_ldc_unregister_channel()
2020 if (cinfo->dip == NULL) { in i_ldc_unregister_channel()
2021 DWARN(ldcp->id, in i_ldc_unregister_channel()
2026 if (ldcp->tstate & TS_CNEX_RDY) { in i_ldc_unregister_channel()
2028 /* Remove the Rx interrupt */ in i_ldc_unregister_channel()
2029 rv = cinfo->rem_intr(cinfo->dip, ldcp->id, CNEX_RX_INTR); in i_ldc_unregister_channel()
2032 DWARN(ldcp->id, in i_ldc_unregister_channel()
2034 "Rx intr\n"); in i_ldc_unregister_channel()
2043 if (ldcp->rx_intr_state != LDC_INTR_PEND) in i_ldc_unregister_channel()
2047 rv = cinfo->rem_intr(cinfo->dip, ldcp->id, in i_ldc_unregister_channel()
2050 DWARN(ldcp->id, "i_ldc_unregister_channel: " in i_ldc_unregister_channel()
2051 "err removing Rx interrupt\n"); in i_ldc_unregister_channel()
2057 rv = cinfo->rem_intr(cinfo->dip, ldcp->id, CNEX_TX_INTR); in i_ldc_unregister_channel()
2059 DWARN(ldcp->id, in i_ldc_unregister_channel()
2065 rv = cinfo->unreg_chan(ldcssp->cinfo.dip, ldcp->id); in i_ldc_unregister_channel()
2067 DWARN(ldcp->id, in i_ldc_unregister_channel()
2072 ldcp->tstate &= ~TS_CNEX_RDY; in i_ldc_unregister_channel()
2098 D1(ldcp->id, "i_ldc_tx_hdlr: (0x%llx) Received intr, ldcp=0x%p\n", in i_ldc_tx_hdlr()
2099 ldcp->id, ldcp); in i_ldc_tx_hdlr()
2102 mutex_enter(&ldcp->lock); in i_ldc_tx_hdlr()
2105 mutex_enter(&ldcp->tx_lock); in i_ldc_tx_hdlr()
2108 ldcp->tx_intr_state = LDC_INTR_ACTIVE; in i_ldc_tx_hdlr()
2111 link_state = ldcp->link_state; in i_ldc_tx_hdlr()
2113 rv = hv_ldc_tx_get_state(ldcp->id, &ldcp->tx_head, &ldcp->tx_tail, in i_ldc_tx_hdlr()
2114 &ldcp->link_state); in i_ldc_tx_hdlr()
2118 ldcp->id, rv); in i_ldc_tx_hdlr()
2120 mutex_exit(&ldcp->tx_lock); in i_ldc_tx_hdlr()
2121 mutex_exit(&ldcp->lock); in i_ldc_tx_hdlr()
2130 if (link_state != ldcp->link_state && in i_ldc_tx_hdlr()
2131 ldcp->link_state == LDC_CHANNEL_DOWN) { in i_ldc_tx_hdlr()
2132 D1(ldcp->id, "i_ldc_tx_hdlr: channel link down\n", ldcp->id); in i_ldc_tx_hdlr()
2138 if (link_state != ldcp->link_state && in i_ldc_tx_hdlr()
2139 ldcp->link_state == LDC_CHANNEL_RESET) { in i_ldc_tx_hdlr()
2140 D1(ldcp->id, "i_ldc_tx_hdlr: channel link reset\n", ldcp->id); in i_ldc_tx_hdlr()
2146 if (link_state != ldcp->link_state && in i_ldc_tx_hdlr()
2147 (ldcp->tstate & ~TS_IN_RESET) == TS_OPEN && in i_ldc_tx_hdlr()
2148 ldcp->link_state == LDC_CHANNEL_UP) { in i_ldc_tx_hdlr()
2149 D1(ldcp->id, "i_ldc_tx_hdlr: channel link up\n", ldcp->id); in i_ldc_tx_hdlr()
2152 ldcp->tstate |= TS_LINK_READY; in i_ldc_tx_hdlr()
2153 ldcp->status = LDC_READY; in i_ldc_tx_hdlr()
2157 if (!ldcp->cb_enabled) in i_ldc_tx_hdlr()
2161 mutex_exit(&ldcp->tx_lock); in i_ldc_tx_hdlr()
2164 ldcp->cb_inprogress = B_TRUE; in i_ldc_tx_hdlr()
2165 mutex_exit(&ldcp->lock); in i_ldc_tx_hdlr()
2166 rv = ldcp->cb(notify_event, ldcp->cb_arg); in i_ldc_tx_hdlr()
2168 DWARN(ldcp->id, "i_ldc_tx_hdlr: (0x%llx) callback " in i_ldc_tx_hdlr()
2169 "failure", ldcp->id); in i_ldc_tx_hdlr()
2171 mutex_enter(&ldcp->lock); in i_ldc_tx_hdlr()
2172 ldcp->cb_inprogress = B_FALSE; in i_ldc_tx_hdlr()
2175 mutex_exit(&ldcp->lock); in i_ldc_tx_hdlr()
2177 D1(ldcp->id, "i_ldc_tx_hdlr: (0x%llx) exiting handler", ldcp->id); in i_ldc_tx_hdlr()
2183 * Process the Rx HV queue.
2219 ASSERT(MUTEX_HELD(&ldcp->lock)); in i_ldc_rx_process_hvq()
2228 link_state = ldcp->link_state; in i_ldc_rx_process_hvq()
2229 rv = hv_ldc_rx_get_state(ldcp->id, &rx_head, &rx_tail, in i_ldc_rx_process_hvq()
2230 &ldcp->link_state); in i_ldc_rx_process_hvq()
2234 "queue ptrs, rv=0x%d\n", ldcp->id, rv); in i_ldc_rx_process_hvq()
2245 if (link_state != ldcp->link_state) { in i_ldc_rx_process_hvq()
2247 switch (ldcp->link_state) { in i_ldc_rx_process_hvq()
2249 D1(ldcp->id, "i_ldc_rx_process_hvq: channel " in i_ldc_rx_process_hvq()
2250 "link down\n", ldcp->id); in i_ldc_rx_process_hvq()
2251 mutex_enter(&ldcp->tx_lock); in i_ldc_rx_process_hvq()
2253 mutex_exit(&ldcp->tx_lock); in i_ldc_rx_process_hvq()
2259 D1(ldcp->id, "i_ldc_rx_process_hvq: " in i_ldc_rx_process_hvq()
2260 "channel link up\n", ldcp->id); in i_ldc_rx_process_hvq()
2262 if ((ldcp->tstate & ~TS_IN_RESET) == TS_OPEN) { in i_ldc_rx_process_hvq()
2265 ldcp->tstate |= TS_LINK_READY; in i_ldc_rx_process_hvq()
2266 ldcp->status = LDC_READY; in i_ldc_rx_process_hvq()
2275 D1(ldcp->id, "i_ldc_rx_process_hvq: channel " in i_ldc_rx_process_hvq()
2276 "link reset\n", ldcp->id); in i_ldc_rx_process_hvq()
2277 mutex_enter(&ldcp->tx_lock); in i_ldc_rx_process_hvq()
2279 mutex_exit(&ldcp->tx_lock); in i_ldc_rx_process_hvq()
2298 D2(ldcp->id, "i_ldc_rx_process_hvq: (0x%llx) " in i_ldc_rx_process_hvq()
2299 "No packets\n", ldcp->id); in i_ldc_rx_process_hvq()
2303 D2(ldcp->id, "i_ldc_rx_process_hvq: head=0x%llx, " in i_ldc_rx_process_hvq()
2306 ldcp->rx_q_va + rx_head); in i_ldc_rx_process_hvq()
2309 msg = (ldc_msg_t *)(ldcp->rx_q_va + rx_head); in i_ldc_rx_process_hvq()
2312 if (ldcp->mode == LDC_MODE_RAW) { in i_ldc_rx_process_hvq()
2318 if ((msg->type & LDC_DATA) && (msg->stype & LDC_INFO)) { in i_ldc_rx_process_hvq()
2321 if ((ldcp->tstate & ~TS_IN_RESET) != TS_UP) { in i_ldc_rx_process_hvq()
2325 (ldcp->rx_q_entries << LDC_PACKET_SHIFT); in i_ldc_rx_process_hvq()
2335 if (ldcp->mode != LDC_MODE_RELIABLE) { in i_ldc_rx_process_hvq()
2336 if ((ldcp->tstate & TS_IN_RESET) == 0) in i_ldc_rx_process_hvq()
2346 (ldcp->rx_dq_entries << LDC_PACKET_SHIFT); in i_ldc_rx_process_hvq()
2359 DWARN(ldcp->id, "i_ldc_rx_process_hvq: (0x%llx) " in i_ldc_rx_process_hvq()
2360 "seqid error, q_ptrs=0x%lx,0x%lx", ldcp->id, in i_ldc_rx_process_hvq()
2365 ldcp->last_msg_rcd = first_fragment - 1; in i_ldc_rx_process_hvq()
2372 rv = i_ldc_send_pkt(ldcp, msg->type, LDC_NACK, in i_ldc_rx_process_hvq()
2373 (msg->ctrl & LDC_CTRL_MASK)); in i_ldc_rx_process_hvq()
2377 "(0x%lx) err sending CTRL/DATA NACK msg\n", in i_ldc_rx_process_hvq()
2378 ldcp->id); in i_ldc_rx_process_hvq()
2380 /* if cannot send NACK - reset channel */ in i_ldc_rx_process_hvq()
2381 mutex_enter(&ldcp->tx_lock); in i_ldc_rx_process_hvq()
2383 mutex_exit(&ldcp->tx_lock); in i_ldc_rx_process_hvq()
2396 ldcp->last_msg_rcd = msg->seqid; in i_ldc_rx_process_hvq()
2399 if (msg->type & LDC_CTRL) { in i_ldc_rx_process_hvq()
2401 uint64_t tstate = ldcp->tstate; in i_ldc_rx_process_hvq()
2405 /* re-process pkt - state was adjusted */ in i_ldc_rx_process_hvq()
2418 if (rv == 0 && ldcp->tstate == TS_UP && in i_ldc_rx_process_hvq()
2420 (ldcp->tstate & ~TS_IN_RESET)) { in i_ldc_rx_process_hvq()
2427 if ((msg->type & LDC_DATA) && (msg->stype & LDC_NACK)) { in i_ldc_rx_process_hvq()
2428 DWARN(ldcp->id, in i_ldc_rx_process_hvq()
2430 ldcp->id); in i_ldc_rx_process_hvq()
2431 mutex_enter(&ldcp->tx_lock); in i_ldc_rx_process_hvq()
2433 mutex_exit(&ldcp->tx_lock); in i_ldc_rx_process_hvq()
2440 if ((msg->type & LDC_DATA) && (msg->stype & LDC_ACK)) { in i_ldc_rx_process_hvq()
2448 if ((msg->type & LDC_DATA) && (msg->stype & LDC_INFO)) { in i_ldc_rx_process_hvq()
2449 ASSERT(ldcp->mode == LDC_MODE_RELIABLE); in i_ldc_rx_process_hvq()
2457 if ((ldcp->tstate & TS_IN_RESET) == 0) in i_ldc_rx_process_hvq()
2462 (ldcp->rx_q_entries << LDC_PACKET_SHIFT); in i_ldc_rx_process_hvq()
2476 if (ldcp->mode == LDC_MODE_RELIABLE) { in i_ldc_rx_process_hvq()
2485 "send ACK\n", ldcp->id); in i_ldc_rx_process_hvq()
2487 mutex_enter(&ldcp->tx_lock); in i_ldc_rx_process_hvq()
2489 mutex_exit(&ldcp->tx_lock); in i_ldc_rx_process_hvq()
2499 * there are no ACKs on the rx queue waiting to be processed. in i_ldc_rx_process_hvq()
2503 ldcp->rx_ack_head = ACKPEEK_HEAD_INVALID; in i_ldc_rx_process_hvq()
2509 ldcp->rx_ack_head = ACKPEEK_HEAD_INVALID; in i_ldc_rx_process_hvq()
2535 if (ldcp->rx_ack_head == ACKPEEK_HEAD_INVALID) in i_ldc_rx_ackpeek()
2536 ldcp->rx_ack_head = rx_head; in i_ldc_rx_ackpeek()
2538 while (ldcp->rx_ack_head != rx_tail) { in i_ldc_rx_ackpeek()
2539 msg = (ldc_msg_t *)(ldcp->rx_q_va + ldcp->rx_ack_head); in i_ldc_rx_ackpeek()
2541 if ((msg->type & LDC_DATA) && (msg->stype & LDC_ACK)) { in i_ldc_rx_ackpeek()
2544 msg->stype &= ~LDC_ACK; in i_ldc_rx_ackpeek()
2547 ldcp->rx_ack_head = in i_ldc_rx_ackpeek()
2548 (ldcp->rx_ack_head + LDC_PACKET_SIZE) % in i_ldc_rx_ackpeek()
2549 (ldcp->rx_q_entries << LDC_PACKET_SHIFT); in i_ldc_rx_ackpeek()
2554 /* -------------------------------------------------------------------------- */
2562 * TX/RX queues, and initialize locks.
2591 mutex_enter(&ldcssp->lock); in ldc_init()
2592 ldcp = ldcssp->chan_list; in ldc_init()
2594 if (ldcp->id == id) { in ldc_init()
2597 mutex_exit(&ldcssp->lock); in ldc_init()
2600 ldcp = ldcp->next; in ldc_init()
2602 mutex_exit(&ldcssp->lock); in ldc_init()
2627 mutex_init(&ldcp->lock, NULL, MUTEX_DRIVER, NULL); in ldc_init()
2628 mutex_init(&ldcp->tx_lock, NULL, MUTEX_DRIVER, NULL); in ldc_init()
2631 ldcp->id = id; in ldc_init()
2632 ldcp->cb = NULL; in ldc_init()
2633 ldcp->cb_arg = NULL; in ldc_init()
2634 ldcp->cb_inprogress = B_FALSE; in ldc_init()
2635 ldcp->cb_enabled = B_FALSE; in ldc_init()
2636 ldcp->next = NULL; in ldc_init()
2639 ldcp->mode = attr->mode; in ldc_init()
2640 ldcp->devclass = attr->devclass; in ldc_init()
2641 ldcp->devinst = attr->instance; in ldc_init()
2642 ldcp->mtu = (attr->mtu > 0) ? attr->mtu : LDC_DEFAULT_MTU; in ldc_init()
2644 D1(ldcp->id, in ldc_init()
2647 ldcp->id, ldcp->devclass, ldcp->devinst, ldcp->mode, ldcp->mtu); in ldc_init()
2649 ldcp->next_vidx = 0; in ldc_init()
2650 ldcp->tstate = TS_IN_RESET; in ldc_init()
2651 ldcp->hstate = 0; in ldc_init()
2652 ldcp->last_msg_snt = LDC_INIT_SEQID; in ldc_init()
2653 ldcp->last_ack_rcd = 0; in ldc_init()
2654 ldcp->last_msg_rcd = 0; in ldc_init()
2655 ldcp->rx_ack_head = ACKPEEK_HEAD_INVALID; in ldc_init()
2657 ldcp->stream_bufferp = NULL; in ldc_init()
2658 ldcp->exp_dring_list = NULL; in ldc_init()
2659 ldcp->imp_dring_list = NULL; in ldc_init()
2660 ldcp->mhdl_list = NULL; in ldc_init()
2662 ldcp->tx_intr_state = LDC_INTR_NONE; in ldc_init()
2663 ldcp->rx_intr_state = LDC_INTR_NONE; in ldc_init()
2666 switch (ldcp->mode) { in ldc_init()
2668 ldcp->pkt_payload = LDC_PAYLOAD_SIZE_RAW; in ldc_init()
2669 ldcp->read_p = i_ldc_read_raw; in ldc_init()
2670 ldcp->write_p = i_ldc_write_raw; in ldc_init()
2673 ldcp->pkt_payload = LDC_PAYLOAD_SIZE_UNRELIABLE; in ldc_init()
2674 ldcp->read_p = i_ldc_read_packet; in ldc_init()
2675 ldcp->write_p = i_ldc_write_packet; in ldc_init()
2678 ldcp->pkt_payload = LDC_PAYLOAD_SIZE_RELIABLE; in ldc_init()
2680 ldcp->stream_remains = 0; in ldc_init()
2681 ldcp->stream_offset = 0; in ldc_init()
2682 ldcp->stream_bufferp = kmem_alloc(ldcp->mtu, KM_SLEEP); in ldc_init()
2683 ldcp->read_p = i_ldc_read_stream; in ldc_init()
2684 ldcp->write_p = i_ldc_write_stream; in ldc_init()
2695 * length is a power-of-two value. in ldc_init()
2697 qlen = (ldcp->mtu * ldc_mtu_msgs) / ldcp->pkt_payload; in ldc_init()
2706 ldcp->rx_q_entries = in ldc_init()
2708 ldcp->tx_q_entries = ldcp->rx_q_entries; in ldc_init()
2710 D1(ldcp->id, "ldc_init: queue length = 0x%llx\n", ldcp->rx_q_entries); in ldc_init()
2713 ldcp->tx_q_va = (uint64_t) in ldc_init()
2714 contig_mem_alloc(ldcp->tx_q_entries << LDC_PACKET_SHIFT); in ldc_init()
2715 if (ldcp->tx_q_va == 0) { in ldc_init()
2718 ldcp->id); in ldc_init()
2722 ldcp->tx_q_ra = va_to_pa((caddr_t)ldcp->tx_q_va); in ldc_init()
2724 D2(ldcp->id, "ldc_init: txq_va=0x%llx, txq_ra=0x%llx, entries=0x%llx\n", in ldc_init()
2725 ldcp->tx_q_va, ldcp->tx_q_ra, ldcp->tx_q_entries); in ldc_init()
2727 ldcp->tstate |= TS_TXQ_RDY; in ldc_init()
2730 ldcp->rx_q_va = (uint64_t) in ldc_init()
2731 contig_mem_alloc(ldcp->rx_q_entries << LDC_PACKET_SHIFT); in ldc_init()
2732 if (ldcp->rx_q_va == 0) { in ldc_init()
2734 "ldc_init: (0x%lx) RX queue allocation failed\n", in ldc_init()
2735 ldcp->id); in ldc_init()
2739 ldcp->rx_q_ra = va_to_pa((caddr_t)ldcp->rx_q_va); in ldc_init()
2741 D2(ldcp->id, "ldc_init: rxq_va=0x%llx, rxq_ra=0x%llx, entries=0x%llx\n", in ldc_init()
2742 ldcp->rx_q_va, ldcp->rx_q_ra, ldcp->rx_q_entries); in ldc_init()
2744 ldcp->tstate |= TS_RXQ_RDY; in ldc_init()
2747 if (ldcp->mode == LDC_MODE_RELIABLE) { in ldc_init()
2748 ldcp->readq_get_state = i_ldc_dq_rx_get_state; in ldc_init()
2749 ldcp->readq_set_head = i_ldc_set_rxdq_head; in ldc_init()
2753 D1(ldcp->id, "ldc_init: (0x%llx) ldc_rxdq_multiplier " in ldc_init()
2754 "not a power of 2, resetting", ldcp->id); in ldc_init()
2758 ldcp->rx_dq_entries = ldc_rxdq_multiplier * ldcp->rx_q_entries; in ldc_init()
2759 ldcp->rx_dq_va = (uint64_t) in ldc_init()
2760 kmem_alloc(ldcp->rx_dq_entries << LDC_PACKET_SHIFT, in ldc_init()
2762 if (ldcp->rx_dq_va == 0) { in ldc_init()
2764 "ldc_init: (0x%lx) RX data queue " in ldc_init()
2765 "allocation failed\n", ldcp->id); in ldc_init()
2770 ldcp->rx_dq_head = ldcp->rx_dq_tail = 0; in ldc_init()
2772 D2(ldcp->id, "ldc_init: rx_dq_va=0x%llx, " in ldc_init()
2773 "rx_dq_entries=0x%llx\n", ldcp->rx_dq_va, in ldc_init()
2774 ldcp->rx_dq_entries); in ldc_init()
2776 ldcp->readq_get_state = i_ldc_hvq_rx_get_state; in ldc_init()
2777 ldcp->readq_set_head = i_ldc_set_rx_head; in ldc_init()
2781 mutex_init(&ldcp->exp_dlist_lock, NULL, MUTEX_DRIVER, NULL); in ldc_init()
2782 mutex_init(&ldcp->imp_dlist_lock, NULL, MUTEX_DRIVER, NULL); in ldc_init()
2783 mutex_init(&ldcp->mlist_lock, NULL, MUTEX_DRIVER, NULL); in ldc_init()
2786 ldcp->status = LDC_INIT; in ldc_init()
2789 mutex_enter(&ldcssp->lock); in ldc_init()
2790 ldcp->next = ldcssp->chan_list; in ldc_init()
2791 ldcssp->chan_list = ldcp; in ldc_init()
2792 ldcssp->channel_count++; in ldc_init()
2793 mutex_exit(&ldcssp->lock); in ldc_init()
2798 D1(ldcp->id, "ldc_init: (0x%llx) channel initialized\n", ldcp->id); in ldc_init()
2804 if (ldcp->mode == LDC_MODE_RELIABLE && ldcp->stream_bufferp) in ldc_init()
2805 kmem_free(ldcp->stream_bufferp, ldcp->mtu); in ldc_init()
2807 if (ldcp->tstate & TS_TXQ_RDY) in ldc_init()
2808 contig_mem_free((caddr_t)ldcp->tx_q_va, in ldc_init()
2809 (ldcp->tx_q_entries << LDC_PACKET_SHIFT)); in ldc_init()
2811 if (ldcp->tstate & TS_RXQ_RDY) in ldc_init()
2812 contig_mem_free((caddr_t)ldcp->rx_q_va, in ldc_init()
2813 (ldcp->rx_q_entries << LDC_PACKET_SHIFT)); in ldc_init()
2815 mutex_destroy(&ldcp->tx_lock); in ldc_init()
2816 mutex_destroy(&ldcp->lock); in ldc_init()
2826 * a ldc_fini operation. It frees TX/RX queues, associated
2841 id = ldcp->id; in ldc_fini()
2843 mutex_enter(&ldcp->lock); in ldc_fini()
2845 if ((ldcp->tstate & ~TS_IN_RESET) > TS_INIT) { in ldc_fini()
2846 DWARN(ldcp->id, "ldc_fini: (0x%llx) channel is open\n", in ldc_fini()
2847 ldcp->id); in ldc_fini()
2848 mutex_exit(&ldcp->lock); in ldc_fini()
2853 mutex_enter(&ldcssp->lock); in ldc_fini()
2854 tmp_ldcp = ldcssp->chan_list; in ldc_fini()
2856 ldcssp->chan_list = ldcp->next; in ldc_fini()
2857 ldcp->next = NULL; in ldc_fini()
2860 if (tmp_ldcp->next == ldcp) { in ldc_fini()
2861 tmp_ldcp->next = ldcp->next; in ldc_fini()
2862 ldcp->next = NULL; in ldc_fini()
2865 tmp_ldcp = tmp_ldcp->next; in ldc_fini()
2869 mutex_exit(&ldcssp->lock); in ldc_fini()
2870 mutex_exit(&ldcp->lock); in ldc_fini()
2875 ldcssp->channel_count--; in ldc_fini()
2877 mutex_exit(&ldcssp->lock); in ldc_fini()
2880 if (ldcp->mtbl) { in ldc_fini()
2881 (void) hv_ldc_set_map_table(ldcp->id, 0, 0); in ldc_fini()
2882 if (ldcp->mtbl->contigmem) in ldc_fini()
2883 contig_mem_free(ldcp->mtbl->table, ldcp->mtbl->size); in ldc_fini()
2885 kmem_free(ldcp->mtbl->table, ldcp->mtbl->size); in ldc_fini()
2886 mutex_destroy(&ldcp->mtbl->lock); in ldc_fini()
2887 kmem_free(ldcp->mtbl, sizeof (ldc_mtbl_t)); in ldc_fini()
2891 mutex_destroy(&ldcp->exp_dlist_lock); in ldc_fini()
2892 mutex_destroy(&ldcp->imp_dlist_lock); in ldc_fini()
2893 mutex_destroy(&ldcp->mlist_lock); in ldc_fini()
2896 if (ldcp->mode == LDC_MODE_RELIABLE && ldcp->stream_bufferp) in ldc_fini()
2897 kmem_free(ldcp->stream_bufferp, ldcp->mtu); in ldc_fini()
2899 /* Free the RX queue */ in ldc_fini()
2900 contig_mem_free((caddr_t)ldcp->rx_q_va, in ldc_fini()
2901 (ldcp->rx_q_entries << LDC_PACKET_SHIFT)); in ldc_fini()
2902 ldcp->tstate &= ~TS_RXQ_RDY; in ldc_fini()
2904 /* Free the RX data queue */ in ldc_fini()
2905 if (ldcp->mode == LDC_MODE_RELIABLE) { in ldc_fini()
2906 kmem_free((caddr_t)ldcp->rx_dq_va, in ldc_fini()
2907 (ldcp->rx_dq_entries << LDC_PACKET_SHIFT)); in ldc_fini()
2911 contig_mem_free((caddr_t)ldcp->tx_q_va, in ldc_fini()
2912 (ldcp->tx_q_entries << LDC_PACKET_SHIFT)); in ldc_fini()
2913 ldcp->tstate &= ~TS_TXQ_RDY; in ldc_fini()
2915 mutex_exit(&ldcp->lock); in ldc_fini()
2918 mutex_destroy(&ldcp->tx_lock); in ldc_fini()
2919 mutex_destroy(&ldcp->lock); in ldc_fini()
2930 * Open the LDC channel for use. It registers the TX/RX queues
2947 mutex_enter(&ldcp->lock); in ldc_open()
2949 if (ldcp->tstate < TS_INIT) { in ldc_open()
2950 DWARN(ldcp->id, in ldc_open()
2951 "ldc_open: (0x%llx) channel not initialized\n", ldcp->id); in ldc_open()
2952 mutex_exit(&ldcp->lock); in ldc_open()
2955 if ((ldcp->tstate & ~TS_IN_RESET) >= TS_OPEN) { in ldc_open()
2956 DWARN(ldcp->id, in ldc_open()
2957 "ldc_open: (0x%llx) channel is already open\n", ldcp->id); in ldc_open()
2958 mutex_exit(&ldcp->lock); in ldc_open()
2965 rv = hv_ldc_tx_qconf(ldcp->id, 0, 0); in ldc_open()
2969 ldcp->id); in ldc_open()
2970 mutex_exit(&ldcp->lock); in ldc_open()
2974 rv = hv_ldc_tx_qconf(ldcp->id, ldcp->tx_q_ra, ldcp->tx_q_entries); in ldc_open()
2978 ldcp->id); in ldc_open()
2979 mutex_exit(&ldcp->lock); in ldc_open()
2983 D2(ldcp->id, "ldc_open: (0x%llx) registered tx queue with LDC\n", in ldc_open()
2984 ldcp->id); in ldc_open()
2987 * Unregister/Register the rx queue with the hypervisor in ldc_open()
2989 rv = hv_ldc_rx_qconf(ldcp->id, 0, 0); in ldc_open()
2992 "ldc_open: (0x%lx) channel rx queue unconf failed\n", in ldc_open()
2993 ldcp->id); in ldc_open()
2994 mutex_exit(&ldcp->lock); in ldc_open()
2998 rv = hv_ldc_rx_qconf(ldcp->id, ldcp->rx_q_ra, ldcp->rx_q_entries); in ldc_open()
3001 "ldc_open: (0x%lx) channel rx queue conf failed\n", in ldc_open()
3002 ldcp->id); in ldc_open()
3003 mutex_exit(&ldcp->lock); in ldc_open()
3007 D2(ldcp->id, "ldc_open: (0x%llx) registered rx queue with LDC\n", in ldc_open()
3008 ldcp->id); in ldc_open()
3010 ldcp->tstate |= TS_QCONF_RDY; in ldc_open()
3016 "ldc_open: (0x%lx) channel register failed\n", ldcp->id); in ldc_open()
3017 ldcp->tstate &= ~TS_QCONF_RDY; in ldc_open()
3018 (void) hv_ldc_tx_qconf(ldcp->id, 0, 0); in ldc_open()
3019 (void) hv_ldc_rx_qconf(ldcp->id, 0, 0); in ldc_open()
3020 mutex_exit(&ldcp->lock); in ldc_open()
3025 ldcp->status = LDC_OPEN; in ldc_open()
3028 rv = hv_ldc_tx_get_state(ldcp->id, in ldc_open()
3029 &ldcp->tx_head, &ldcp->tx_tail, &ldcp->link_state); in ldc_open()
3033 ldcp->id); in ldc_open()
3035 ldcp->tstate &= ~TS_QCONF_RDY; in ldc_open()
3036 (void) hv_ldc_tx_qconf(ldcp->id, 0, 0); in ldc_open()
3037 (void) hv_ldc_rx_qconf(ldcp->id, 0, 0); in ldc_open()
3038 mutex_exit(&ldcp->lock); in ldc_open()
3045 ldcp->tx_ackd_head = ldcp->tx_head; in ldc_open()
3047 /* mark channel ready if HV report link is UP (peer alloc'd Rx queue) */ in ldc_open()
3048 if (ldcp->link_state == LDC_CHANNEL_UP || in ldc_open()
3049 ldcp->link_state == LDC_CHANNEL_RESET) { in ldc_open()
3050 ldcp->tstate |= TS_LINK_READY; in ldc_open()
3051 ldcp->status = LDC_READY; in ldc_open()
3055 * if channel is being opened in RAW mode - no handshake is needed in ldc_open()
3058 if (ldcp->mode == LDC_MODE_RAW) { in ldc_open()
3059 ldcp->tstate = TS_UP; /* set bits associated with LDC UP */ in ldc_open()
3060 ldcp->status = LDC_UP; in ldc_open()
3063 mutex_exit(&ldcp->lock); in ldc_open()
3068 mutex_enter(&ldcssp->lock); in ldc_open()
3069 ldcssp->channels_open++; in ldc_open()
3070 mutex_exit(&ldcssp->lock); in ldc_open()
3072 D1(ldcp->id, in ldc_open()
3075 ldcp->id, ldcp, ldcp->tstate, ldcp->status); in ldc_open()
3098 mutex_enter(&ldcp->lock); in ldc_close()
3101 if ((ldcp->tstate & ~TS_IN_RESET) < TS_OPEN) { in ldc_close()
3102 DWARN(ldcp->id, in ldc_close()
3103 "ldc_close: (0x%llx) channel is not open\n", ldcp->id); in ldc_close()
3104 mutex_exit(&ldcp->lock); in ldc_close()
3109 if (ldcp->mhdl_list != NULL) { in ldc_close()
3110 DWARN(ldcp->id, in ldc_close()
3112 ldcp->id); in ldc_close()
3113 mutex_exit(&ldcp->lock); in ldc_close()
3116 if (ldcp->exp_dring_list != NULL) { in ldc_close()
3117 DWARN(ldcp->id, in ldc_close()
3119 ldcp->id); in ldc_close()
3120 mutex_exit(&ldcp->lock); in ldc_close()
3123 if (ldcp->imp_dring_list != NULL) { in ldc_close()
3124 DWARN(ldcp->id, in ldc_close()
3126 ldcp->id); in ldc_close()
3127 mutex_exit(&ldcp->lock); in ldc_close()
3131 if (ldcp->cb_inprogress) { in ldc_close()
3132 DWARN(ldcp->id, "ldc_close: (0x%llx) callback active\n", in ldc_close()
3133 ldcp->id); in ldc_close()
3134 mutex_exit(&ldcp->lock); in ldc_close()
3139 mutex_enter(&ldcp->tx_lock); in ldc_close()
3143 * if there are pending pkts - wait 1 ms and retry again in ldc_close()
3147 rv = hv_ldc_tx_get_state(ldcp->id, in ldc_close()
3148 &ldcp->tx_head, &ldcp->tx_tail, &ldcp->link_state); in ldc_close()
3151 "ldc_close: (0x%lx) cannot read qptrs\n", ldcp->id); in ldc_close()
3152 mutex_exit(&ldcp->tx_lock); in ldc_close()
3153 mutex_exit(&ldcp->lock); in ldc_close()
3157 if (ldcp->tx_head == ldcp->tx_tail || in ldc_close()
3158 ldcp->link_state != LDC_CHANNEL_UP) { in ldc_close()
3163 DWARN(ldcp->id, in ldc_close()
3165 ldcp->id); in ldc_close()
3175 * Drain the Tx and Rx queues as we are closing the in ldc_close()
3190 mutex_exit(&ldcp->tx_lock); in ldc_close()
3191 mutex_exit(&ldcp->lock); in ldc_close()
3197 ldcp->id, rv); in ldc_close()
3206 mutex_enter(&ldcp->lock); in ldc_close()
3207 mutex_enter(&ldcp->tx_lock); in ldc_close()
3211 ldcp->tstate &= ~TS_QCONF_RDY; in ldc_close()
3216 rv = hv_ldc_tx_qconf(ldcp->id, 0, 0); in ldc_close()
3220 ldcp->id); in ldc_close()
3221 mutex_exit(&ldcp->tx_lock); in ldc_close()
3222 mutex_exit(&ldcp->lock); in ldc_close()
3225 rv = hv_ldc_rx_qconf(ldcp->id, 0, 0); in ldc_close()
3228 "ldc_close: (0x%lx) channel RX queue unconf failed\n", in ldc_close()
3229 ldcp->id); in ldc_close()
3230 mutex_exit(&ldcp->tx_lock); in ldc_close()
3231 mutex_exit(&ldcp->lock); in ldc_close()
3239 ldcp->tx_ackd_head = 0; in ldc_close()
3240 ldcp->tx_head = 0; in ldc_close()
3241 ldcp->tstate = TS_IN_RESET|TS_INIT; in ldc_close()
3242 ldcp->status = LDC_INIT; in ldc_close()
3244 mutex_exit(&ldcp->tx_lock); in ldc_close()
3245 mutex_exit(&ldcp->lock); in ldc_close()
3248 mutex_enter(&ldcssp->lock); in ldc_close()
3249 ldcssp->channels_open--; in ldc_close()
3250 mutex_exit(&ldcssp->lock); in ldc_close()
3252 D1(ldcp->id, "ldc_close: (0x%llx) channel closed\n", ldcp->id); in ldc_close()
3277 mutex_enter(&ldcp->lock); in ldc_reg_callback()
3279 if (ldcp->cb) { in ldc_reg_callback()
3280 DWARN(ldcp->id, "ldc_reg_callback: (0x%llx) callback exists\n", in ldc_reg_callback()
3281 ldcp->id); in ldc_reg_callback()
3282 mutex_exit(&ldcp->lock); in ldc_reg_callback()
3285 if (ldcp->cb_inprogress) { in ldc_reg_callback()
3286 DWARN(ldcp->id, "ldc_reg_callback: (0x%llx) callback active\n", in ldc_reg_callback()
3287 ldcp->id); in ldc_reg_callback()
3288 mutex_exit(&ldcp->lock); in ldc_reg_callback()
3292 ldcp->cb = cb; in ldc_reg_callback()
3293 ldcp->cb_arg = arg; in ldc_reg_callback()
3294 ldcp->cb_enabled = B_TRUE; in ldc_reg_callback()
3296 D1(ldcp->id, in ldc_reg_callback()
3298 ldcp->id); in ldc_reg_callback()
3300 mutex_exit(&ldcp->lock); in ldc_reg_callback()
3320 mutex_enter(&ldcp->lock); in ldc_unreg_callback()
3322 if (ldcp->cb == NULL) { in ldc_unreg_callback()
3323 DWARN(ldcp->id, in ldc_unreg_callback()
3325 ldcp->id); in ldc_unreg_callback()
3326 mutex_exit(&ldcp->lock); in ldc_unreg_callback()
3329 if (ldcp->cb_inprogress) { in ldc_unreg_callback()
3330 DWARN(ldcp->id, in ldc_unreg_callback()
3332 ldcp->id); in ldc_unreg_callback()
3333 mutex_exit(&ldcp->lock); in ldc_unreg_callback()
3337 ldcp->cb = NULL; in ldc_unreg_callback()
3338 ldcp->cb_arg = NULL; in ldc_unreg_callback()
3339 ldcp->cb_enabled = B_FALSE; in ldc_unreg_callback()
3341 D1(ldcp->id, in ldc_unreg_callback()
3343 ldcp->id); in ldc_unreg_callback()
3345 mutex_exit(&ldcp->lock); in ldc_unreg_callback()
3370 mutex_enter(&ldcp->lock); in ldc_up()
3372 D1(ldcp->id, "ldc_up: (0x%llx) doing channel UP\n", ldcp->id); in ldc_up()
3375 tstate = ldcp->tstate; in ldc_up()
3376 ldcp->tstate &= ~TS_IN_RESET; in ldc_up()
3378 if (ldcp->tstate == TS_UP) { in ldc_up()
3379 DWARN(ldcp->id, in ldc_up()
3381 ldcp->id); in ldc_up()
3384 ldcp->status = LDC_UP; in ldc_up()
3389 * trigger an interrupt, causing the RX handler to in ldc_up()
3393 ldcp->rx_intr_state == LDC_INTR_PEND) { in ldc_up()
3394 D1(ldcp->id, in ldc_up()
3396 "clearing interrupt\n", ldcp->id); in ldc_up()
3400 mutex_exit(&ldcp->lock); in ldc_up()
3404 /* if the channel is in RAW mode - mark it as UP, if READY */ in ldc_up()
3405 if (ldcp->mode == LDC_MODE_RAW && ldcp->tstate >= TS_READY) { in ldc_up()
3406 ldcp->tstate = TS_UP; in ldc_up()
3407 mutex_exit(&ldcp->lock); in ldc_up()
3412 if (ldcp->hstate) { in ldc_up()
3413 D1(ldcp->id, in ldc_up()
3415 ldcp->id); in ldc_up()
3416 mutex_exit(&ldcp->lock); in ldc_up()
3420 mutex_enter(&ldcp->tx_lock); in ldc_up()
3423 link_state = ldcp->link_state; in ldc_up()
3428 D1(ldcp->id, "ldc_up: (0x%llx) cannot initiate handshake\n", in ldc_up()
3429 ldcp->id); in ldc_up()
3430 mutex_exit(&ldcp->tx_lock); in ldc_up()
3431 mutex_exit(&ldcp->lock); in ldc_up()
3441 (link_state != ldcp->link_state)) { in ldc_up()
3443 ASSERT((ldcp->link_state == LDC_CHANNEL_RESET) || in ldc_up()
3444 (ldcp->link_state == LDC_CHANNEL_UP)); in ldc_up()
3446 if (ldcp->mode == LDC_MODE_RAW) { in ldc_up()
3447 ldcp->status = LDC_UP; in ldc_up()
3448 ldcp->tstate = TS_UP; in ldc_up()
3449 mutex_exit(&ldcp->tx_lock); in ldc_up()
3450 mutex_exit(&ldcp->lock); in ldc_up()
3453 ldcp->status = LDC_READY; in ldc_up()
3454 ldcp->tstate |= TS_LINK_READY; in ldc_up()
3459 ldcmsg = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail); in ldc_up()
3462 ldcmsg->type = LDC_CTRL; in ldc_up()
3463 ldcmsg->stype = LDC_INFO; in ldc_up()
3464 ldcmsg->ctrl = LDC_VER; in ldc_up()
3465 ldcp->next_vidx = 0; in ldc_up()
3466 bcopy(&ldc_versions[0], ldcmsg->udata, sizeof (ldc_versions[0])); in ldc_up()
3472 (ldcp->tx_q_entries << LDC_PACKET_SHIFT); in ldc_up()
3476 DWARN(ldcp->id, in ldc_up()
3478 ldcp->id, rv); in ldc_up()
3479 mutex_exit(&ldcp->tx_lock); in ldc_up()
3480 mutex_exit(&ldcp->lock); in ldc_up()
3484 ldcp->hstate |= TS_SENT_VER; in ldc_up()
3485 ldcp->tx_tail = tx_tail; in ldc_up()
3486 D1(ldcp->id, "ldc_up: (0x%llx) channel up initiated\n", ldcp->id); in ldc_up()
3488 mutex_exit(&ldcp->tx_lock); in ldc_up()
3489 mutex_exit(&ldcp->lock); in ldc_up()
3508 mutex_enter(&ldcp->lock); in ldc_down()
3509 mutex_enter(&ldcp->tx_lock); in ldc_down()
3511 mutex_exit(&ldcp->tx_lock); in ldc_down()
3512 mutex_exit(&ldcp->lock); in ldc_down()
3531 *status = ((ldc_chan_t *)handle)->status; in ldc_status()
3533 D1(ldcp->id, in ldc_status()
3534 "ldc_status: (0x%llx) returned status %d\n", ldcp->id, *status); in ldc_status()
3540 * Set the channel's callback mode - enable/disable callbacks
3557 mutex_enter(&ldcp->lock); in ldc_set_cb_mode()
3561 if (!ldcp->cb_enabled) { in ldc_set_cb_mode()
3562 DWARN(ldcp->id, in ldc_set_cb_mode()
3564 ldcp->id); in ldc_set_cb_mode()
3567 ldcp->cb_enabled = B_FALSE; in ldc_set_cb_mode()
3569 D1(ldcp->id, "ldc_set_cb_mode: (0x%llx) disabled callbacks\n", in ldc_set_cb_mode()
3570 ldcp->id); in ldc_set_cb_mode()
3574 if (ldcp->cb_enabled) { in ldc_set_cb_mode()
3575 DWARN(ldcp->id, in ldc_set_cb_mode()
3577 ldcp->id); in ldc_set_cb_mode()
3580 ldcp->cb_enabled = B_TRUE; in ldc_set_cb_mode()
3582 D1(ldcp->id, "ldc_set_cb_mode: (0x%llx) enabled callbacks\n", in ldc_set_cb_mode()
3583 ldcp->id); in ldc_set_cb_mode()
3587 mutex_exit(&ldcp->lock); in ldc_set_cb_mode()
3611 mutex_enter(&ldcp->lock); in ldc_chkq()
3613 if (ldcp->tstate != TS_UP) { in ldc_chkq()
3614 D1(ldcp->id, in ldc_chkq()
3615 "ldc_chkq: (0x%llx) channel is not up\n", ldcp->id); in ldc_chkq()
3616 mutex_exit(&ldcp->lock); in ldc_chkq()
3621 rv = hv_ldc_rx_get_state(ldcp->id, &rx_head, &rx_tail, in ldc_chkq()
3622 &ldcp->link_state); in ldc_chkq()
3625 "ldc_chkq: (0x%lx) unable to read queue ptrs", ldcp->id); in ldc_chkq()
3626 mutex_exit(&ldcp->lock); in ldc_chkq()
3631 if (ldcp->link_state == LDC_CHANNEL_DOWN || in ldc_chkq()
3632 ldcp->link_state == LDC_CHANNEL_RESET) { in ldc_chkq()
3633 mutex_enter(&ldcp->tx_lock); in ldc_chkq()
3635 mutex_exit(&ldcp->tx_lock); in ldc_chkq()
3636 mutex_exit(&ldcp->lock); in ldc_chkq()
3640 switch (ldcp->mode) { in ldc_chkq()
3643 * In raw mode, there are no ctrl packets, so checking in ldc_chkq()
3644 * if the queue is non-empty is sufficient. in ldc_chkq()
3651 * In unreliable mode, if the queue is non-empty, we need in ldc_chkq()
3653 * The queue may just contain ctrl packets. in ldc_chkq()
3666 ldcp->rx_intr_state == LDC_INTR_PEND) { in ldc_chkq()
3678 if (ldcp->stream_remains > 0) in ldc_chkq()
3681 *hasdata = (ldcp->rx_dq_head != ldcp->rx_dq_tail); in ldc_chkq()
3686 "(0x%x)", ldcp->id, ldcp->mode); in ldc_chkq()
3687 mutex_exit(&ldcp->lock); in ldc_chkq()
3691 mutex_exit(&ldcp->lock); in ldc_chkq()
3718 mutex_enter(&ldcp->lock); in ldc_read()
3720 if (ldcp->tstate != TS_UP) { in ldc_read()
3721 DWARN(ldcp->id, in ldc_read()
3723 ldcp->id); in ldc_read()
3725 } else if (ldcp->mode == LDC_MODE_RELIABLE) { in ldc_read()
3727 exit_val = ldcp->read_p(ldcp, bufp, sizep); in ldc_read()
3734 * packets on the Rx queue. If the interrupt in ldc_read()
3738 if (ldcp->rx_intr_state == LDC_INTR_PEND && in ldc_read()
3739 Q_CONTIG_SPACE(ldcp->rx_dq_head, ldcp->rx_dq_tail, in ldc_read()
3740 ldcp->rx_dq_entries << LDC_PACKET_SHIFT) >= in ldc_read()
3746 mutex_exit(&ldcp->lock); in ldc_read()
3749 exit_val = ldcp->read_p(ldcp, bufp, sizep); in ldc_read()
3753 * if queue has been drained - clear interrupt in ldc_read()
3755 rv = hv_ldc_rx_get_state(ldcp->id, &rx_head, &rx_tail, in ldc_read()
3756 &ldcp->link_state); in ldc_read()
3759 ldcp->id); in ldc_read()
3760 mutex_enter(&ldcp->tx_lock); in ldc_read()
3762 mutex_exit(&ldcp->tx_lock); in ldc_read()
3763 mutex_exit(&ldcp->lock); in ldc_read()
3768 if (ldcp->link_state == LDC_CHANNEL_DOWN || in ldc_read()
3769 ldcp->link_state == LDC_CHANNEL_RESET) { in ldc_read()
3770 mutex_enter(&ldcp->tx_lock); in ldc_read()
3773 mutex_exit(&ldcp->tx_lock); in ldc_read()
3776 (ldcp->rx_intr_state == LDC_INTR_PEND) && in ldc_read()
3782 mutex_exit(&ldcp->lock); in ldc_read()
3787 * Basic raw mondo read -
3790 * Enter and exit with ldcp->lock held by caller
3806 ASSERT(mutex_owned(&ldcp->lock)); in i_ldc_read_raw()
3809 q_size_mask = (ldcp->rx_q_entries-1)<<LDC_PACKET_SHIFT; in i_ldc_read_raw()
3814 rv = hv_ldc_rx_get_state(ldcp->id, &rx_head, &rx_tail, in i_ldc_read_raw()
3815 &ldcp->link_state); in i_ldc_read_raw()
3819 ldcp->id); in i_ldc_read_raw()
3822 D1(ldcp->id, "ldc_read_raw: (0x%llx) rxh=0x%llx," in i_ldc_read_raw()
3824 ldcp->id, rx_head, rx_tail, ldcp->link_state); in i_ldc_read_raw()
3827 if (ldcp->link_state == LDC_CHANNEL_DOWN || in i_ldc_read_raw()
3828 ldcp->link_state == LDC_CHANNEL_RESET) { in i_ldc_read_raw()
3829 mutex_enter(&ldcp->tx_lock); in i_ldc_read_raw()
3831 mutex_exit(&ldcp->tx_lock); in i_ldc_read_raw()
3844 msgp = (ldc_msg_t *)(ldcp->rx_q_va + rx_head); in i_ldc_read_raw()
3847 msgbufp = (uint8_t *)&(msgp->raw[0]); in i_ldc_read_raw()
3851 DUMP_PAYLOAD(ldcp->id, msgbufp); in i_ldc_read_raw()
3863 * with either un-reliable or reliable delivery.
3865 * Enter and exit with ldcp->lock held by caller
3882 ASSERT(mutex_owned(&ldcp->lock)); in i_ldc_read_packet()
3886 DWARN(ldcp->id, "ldc_read: (0x%llx) invalid buffer/size\n", in i_ldc_read_packet()
3887 ldcp->id); in i_ldc_read_packet()
3892 if (ldcp->mode == LDC_MODE_RELIABLE) { in i_ldc_read_packet()
3893 q_va = ldcp->rx_dq_va; in i_ldc_read_packet()
3894 q_size_mask = (ldcp->rx_dq_entries-1)<<LDC_PACKET_SHIFT; in i_ldc_read_packet()
3896 q_va = ldcp->rx_q_va; in i_ldc_read_packet()
3897 q_size_mask = (ldcp->rx_q_entries-1)<<LDC_PACKET_SHIFT; in i_ldc_read_packet()
3903 rv = ldcp->readq_get_state(ldcp, &curr_head, &rx_tail, in i_ldc_read_packet()
3904 &ldcp->link_state); in i_ldc_read_packet()
3907 ldcp->id); in i_ldc_read_packet()
3908 mutex_enter(&ldcp->tx_lock); in i_ldc_read_packet()
3910 mutex_exit(&ldcp->tx_lock); in i_ldc_read_packet()
3913 D1(ldcp->id, "ldc_read: (0x%llx) chd=0x%llx, tl=0x%llx, st=0x%llx\n", in i_ldc_read_packet()
3914 ldcp->id, curr_head, rx_tail, ldcp->link_state); in i_ldc_read_packet()
3917 if (ldcp->link_state != LDC_CHANNEL_UP) in i_ldc_read_packet()
3924 * If a data queue is being used, check the Rx HV in i_ldc_read_packet()
3928 if (ldcp->mode == LDC_MODE_RELIABLE) in i_ldc_read_packet()
3931 rv = ldcp->readq_get_state(ldcp, in i_ldc_read_packet()
3932 &rx_head, &rx_tail, &ldcp->link_state); in i_ldc_read_packet()
3936 ldcp->id); in i_ldc_read_packet()
3937 mutex_enter(&ldcp->tx_lock); in i_ldc_read_packet()
3939 mutex_exit(&ldcp->tx_lock); in i_ldc_read_packet()
3943 if (ldcp->link_state != LDC_CHANNEL_UP) in i_ldc_read_packet()
3958 if (ldcp->mode != LDC_MODE_RELIABLE) in i_ldc_read_packet()
3959 ldcp->last_msg_rcd = in i_ldc_read_packet()
3960 first_fragment - 1; in i_ldc_read_packet()
3962 "(0x%llx) read timeout", ldcp->id); in i_ldc_read_packet()
3971 D2(ldcp->id, in i_ldc_read_packet()
3973 ldcp->id, curr_head, rx_head, rx_tail); in i_ldc_read_packet()
3979 ldcp->rx_q_va + curr_head); in i_ldc_read_packet()
3982 if (ldcp->mode != LDC_MODE_RELIABLE) { in i_ldc_read_packet()
3985 DWARN(ldcp->id, "ldc_read: (0x%llx) seqid " in i_ldc_read_packet()
3987 ldcp->id, rx_head, rx_tail); in i_ldc_read_packet()
3994 ldcp->last_msg_rcd = first_fragment - 1; in i_ldc_read_packet()
3998 * Send a NACK -- invalid seqid in i_ldc_read_packet()
4001 rv = i_ldc_send_pkt(ldcp, msg->type, LDC_NACK, in i_ldc_read_packet()
4002 (msg->ctrl & LDC_CTRL_MASK)); in i_ldc_read_packet()
4006 "NACK msg\n", ldcp->id); in i_ldc_read_packet()
4008 /* if cannot send NACK - reset chan */ in i_ldc_read_packet()
4009 mutex_enter(&ldcp->tx_lock); in i_ldc_read_packet()
4011 mutex_exit(&ldcp->tx_lock); in i_ldc_read_packet()
4023 * Process any messages of type CTRL messages in i_ldc_read_packet()
4028 * both ctrl+data in i_ldc_read_packet()
4030 if (msg->type & LDC_CTRL) { in i_ldc_read_packet()
4042 if ((msg->type & LDC_DATA) && (msg->stype & LDC_ACK)) { in i_ldc_read_packet()
4051 if ((msg->type & LDC_DATA) && (msg->stype & LDC_NACK)) { in i_ldc_read_packet()
4052 DWARN(ldcp->id, in i_ldc_read_packet()
4054 ldcp->id); in i_ldc_read_packet()
4055 mutex_enter(&ldcp->tx_lock); in i_ldc_read_packet()
4057 mutex_exit(&ldcp->tx_lock); in i_ldc_read_packet()
4063 if ((msg->type & LDC_DATA) && (msg->stype & LDC_INFO)) { in i_ldc_read_packet()
4066 (ldcp->mode == LDC_MODE_RELIABLE) ? in i_ldc_read_packet()
4067 msg->rdata : msg->udata); in i_ldc_read_packet()
4069 D2(ldcp->id, in i_ldc_read_packet()
4070 "ldc_read: (0x%llx) received data msg\n", ldcp->id); in i_ldc_read_packet()
4073 len = (msg->env & LDC_LEN_MASK); in i_ldc_read_packet()
4080 * mondos to make a full packet - this is in i_ldc_read_packet()
4091 if (!(msg->env & LDC_FRAG_START)) { in i_ldc_read_packet()
4094 "ldc_read: (0x%llx) not start - " in i_ldc_read_packet()
4095 "frag=%x\n", ldcp->id, in i_ldc_read_packet()
4096 (msg->env) & LDC_FRAG_MASK); in i_ldc_read_packet()
4104 if (rv = ldcp->readq_set_head(ldcp, in i_ldc_read_packet()
4111 first_fragment = msg->seqid; in i_ldc_read_packet()
4114 if (msg->env & LDC_FRAG_START) { in i_ldc_read_packet()
4119 ldcp->id, msg->env&LDC_FRAG_MASK, in i_ldc_read_packet()
4120 bytes_read, ldcp->last_msg_rcd, in i_ldc_read_packet()
4121 msg->seqid); in i_ldc_read_packet()
4126 first_fragment = msg->seqid; in i_ldc_read_packet()
4128 if (rv = ldcp->readq_set_head(ldcp, in i_ldc_read_packet()
4135 if (len <= (*sizep - bytes_read)) { in i_ldc_read_packet()
4147 "head=0x%lx, expect=%d, got=%d\n", ldcp->id, in i_ldc_read_packet()
4155 if (rv = ldcp->readq_set_head(ldcp, curr_head)) in i_ldc_read_packet()
4164 if (ldcp->mode != LDC_MODE_RELIABLE) in i_ldc_read_packet()
4165 ldcp->last_msg_rcd = msg->seqid; in i_ldc_read_packet()
4170 if (msg->env & LDC_FRAG_STOP) { in i_ldc_read_packet()
4179 if (rv = ldcp->readq_set_head(ldcp, curr_head)) in i_ldc_read_packet()
4187 /* advance head if it is a CTRL packet or a DATA ACK packet */ in i_ldc_read_packet()
4188 if ((msg->type & LDC_CTRL) || in i_ldc_read_packet()
4189 ((msg->type & LDC_DATA) && (msg->stype & LDC_ACK))) { in i_ldc_read_packet()
4192 if (rv = ldcp->readq_set_head(ldcp, curr_head)) { in i_ldc_read_packet()
4197 D2(ldcp->id, "ldc_read: (0x%llx) set ACK qhead 0x%llx", in i_ldc_read_packet()
4198 ldcp->id, curr_head); in i_ldc_read_packet()
4203 D2(ldcp->id, "ldc_read: (0x%llx) end size=%d", ldcp->id, *sizep); in i_ldc_read_packet()
4208 mutex_enter(&ldcp->tx_lock); in i_ldc_read_packet()
4210 mutex_exit(&ldcp->tx_lock); in i_ldc_read_packet()
4218 * Enter and exit with ldcp->lock held by caller
4226 ASSERT(mutex_owned(&ldcp->lock)); in i_ldc_read_stream()
4228 D2(ldcp->id, "i_ldc_read_stream: (0x%llx) buffer size=%d", in i_ldc_read_stream()
4229 ldcp->id, *sizep); in i_ldc_read_stream()
4231 if (ldcp->stream_remains == 0) { in i_ldc_read_stream()
4232 size = ldcp->mtu; in i_ldc_read_stream()
4234 (caddr_t)ldcp->stream_bufferp, &size); in i_ldc_read_stream()
4235 D2(ldcp->id, "i_ldc_read_stream: read packet (0x%llx) size=%d", in i_ldc_read_stream()
4236 ldcp->id, size); in i_ldc_read_stream()
4241 ldcp->stream_remains = size; in i_ldc_read_stream()
4242 ldcp->stream_offset = 0; in i_ldc_read_stream()
4245 size = MIN(ldcp->stream_remains, *sizep); in i_ldc_read_stream()
4247 bcopy(ldcp->stream_bufferp + ldcp->stream_offset, target_bufp, size); in i_ldc_read_stream()
4248 ldcp->stream_offset += size; in i_ldc_read_stream()
4249 ldcp->stream_remains -= size; in i_ldc_read_stream()
4251 D2(ldcp->id, "i_ldc_read_stream: (0x%llx) fill from buffer size=%d", in i_ldc_read_stream()
4252 ldcp->id, size); in i_ldc_read_stream()
4278 mutex_enter(&ldcp->tx_lock); in ldc_write()
4280 /* check if non-zero data to write */ in ldc_write()
4282 DWARN(ldcp->id, "ldc_write: (0x%llx) invalid data write\n", in ldc_write()
4283 ldcp->id); in ldc_write()
4284 mutex_exit(&ldcp->tx_lock); in ldc_write()
4289 DWARN(ldcp->id, "ldc_write: (0x%llx) write size of zero\n", in ldc_write()
4290 ldcp->id); in ldc_write()
4291 mutex_exit(&ldcp->tx_lock); in ldc_write()
4296 if (ldcp->tstate != TS_UP) { in ldc_write()
4297 DWARN(ldcp->id, in ldc_write()
4299 ldcp->id); in ldc_write()
4303 rv = ldcp->write_p(ldcp, buf, sizep); in ldc_write()
4306 mutex_exit(&ldcp->tx_lock); in ldc_write()
4323 ASSERT(MUTEX_HELD(&ldcp->tx_lock)); in i_ldc_write_raw()
4324 ASSERT(ldcp->mode == LDC_MODE_RAW); in i_ldc_write_raw()
4332 if (size > ldcp->pkt_payload) { in i_ldc_write_raw()
4333 DWARN(ldcp->id, in i_ldc_write_raw()
4335 ldcp->id, *sizep); in i_ldc_write_raw()
4341 rv = hv_ldc_tx_get_state(ldcp->id, in i_ldc_write_raw()
4342 &ldcp->tx_head, &ldcp->tx_tail, &ldcp->link_state); in i_ldc_write_raw()
4345 "ldc_write: (0x%lx) cannot read queue ptrs\n", ldcp->id); in i_ldc_write_raw()
4350 if (ldcp->link_state == LDC_CHANNEL_DOWN || in i_ldc_write_raw()
4351 ldcp->link_state == LDC_CHANNEL_RESET) { in i_ldc_write_raw()
4352 DWARN(ldcp->id, in i_ldc_write_raw()
4353 "ldc_write: (0x%llx) channel down/reset\n", ldcp->id); in i_ldc_write_raw()
4356 if (mutex_tryenter(&ldcp->lock)) { in i_ldc_write_raw()
4358 mutex_exit(&ldcp->lock); in i_ldc_write_raw()
4364 mutex_exit(&ldcp->tx_lock); in i_ldc_write_raw()
4365 mutex_enter(&ldcp->lock); in i_ldc_write_raw()
4366 mutex_enter(&ldcp->tx_lock); in i_ldc_write_raw()
4368 mutex_exit(&ldcp->lock); in i_ldc_write_raw()
4373 tx_tail = ldcp->tx_tail; in i_ldc_write_raw()
4374 tx_head = ldcp->tx_head; in i_ldc_write_raw()
4376 ((ldcp->tx_q_entries-1) << LDC_PACKET_SHIFT); in i_ldc_write_raw()
4380 "ldc_write: (0x%llx) TX queue is full\n", ldcp->id); in i_ldc_write_raw()
4385 D2(ldcp->id, "ldc_write: (0x%llx) start xfer size=%d", in i_ldc_write_raw()
4386 ldcp->id, size); in i_ldc_write_raw()
4389 ldcmsg = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail); in i_ldc_write_raw()
4404 DWARN(ldcp->id, "ldc_write: (0x%llx) write timed out\n", in i_ldc_write_raw()
4405 ldcp->id); in i_ldc_write_raw()
4411 if (mutex_tryenter(&ldcp->lock)) { in i_ldc_write_raw()
4413 mutex_exit(&ldcp->lock); in i_ldc_write_raw()
4419 mutex_exit(&ldcp->tx_lock); in i_ldc_write_raw()
4420 mutex_enter(&ldcp->lock); in i_ldc_write_raw()
4421 mutex_enter(&ldcp->tx_lock); in i_ldc_write_raw()
4423 mutex_exit(&ldcp->lock); in i_ldc_write_raw()
4428 ldcp->tx_tail = tx_tail; in i_ldc_write_raw()
4431 D2(ldcp->id, "ldc_write: (0x%llx) end xfer size=%d", ldcp->id, size); in i_ldc_write_raw()
4457 ASSERT(MUTEX_HELD(&ldcp->tx_lock)); in i_ldc_write_packet()
4459 ASSERT(ldcp->mode == LDC_MODE_RELIABLE || in i_ldc_write_packet()
4460 ldcp->mode == LDC_MODE_UNRELIABLE); in i_ldc_write_packet()
4463 txq_size_mask = (ldcp->tx_q_entries - 1) << LDC_PACKET_SHIFT; in i_ldc_write_packet()
4466 rv = hv_ldc_tx_get_state(ldcp->id, in i_ldc_write_packet()
4467 &ldcp->tx_head, &ldcp->tx_tail, &ldcp->link_state); in i_ldc_write_packet()
4470 "ldc_write: (0x%lx) cannot read queue ptrs\n", ldcp->id); in i_ldc_write_packet()
4475 if (ldcp->link_state == LDC_CHANNEL_DOWN || in i_ldc_write_packet()
4476 ldcp->link_state == LDC_CHANNEL_RESET) { in i_ldc_write_packet()
4477 DWARN(ldcp->id, in i_ldc_write_packet()
4478 "ldc_write: (0x%llx) channel down/reset\n", ldcp->id); in i_ldc_write_packet()
4480 if (mutex_tryenter(&ldcp->lock)) { in i_ldc_write_packet()
4482 mutex_exit(&ldcp->lock); in i_ldc_write_packet()
4488 mutex_exit(&ldcp->tx_lock); in i_ldc_write_packet()
4489 mutex_enter(&ldcp->lock); in i_ldc_write_packet()
4490 mutex_enter(&ldcp->tx_lock); in i_ldc_write_packet()
4492 mutex_exit(&ldcp->lock); in i_ldc_write_packet()
4497 tx_tail = ldcp->tx_tail; in i_ldc_write_packet()
4499 (ldcp->tx_q_entries << LDC_PACKET_SHIFT); in i_ldc_write_packet()
4509 "ldc_write: (0x%llx) TX queue is full\n", ldcp->id); in i_ldc_write_packet()
4517 numavail = (tx_head >> LDC_PACKET_SHIFT) - (tx_tail >> LDC_PACKET_SHIFT) in i_ldc_write_packet()
4518 + ldcp->tx_q_entries - 1; in i_ldc_write_packet()
4519 numavail %= ldcp->tx_q_entries; in i_ldc_write_packet()
4521 if (*size > (numavail * ldcp->pkt_payload)) { in i_ldc_write_packet()
4523 "ldc_write: (0x%llx) TX queue has no space\n", ldcp->id); in i_ldc_write_packet()
4527 D2(ldcp->id, "ldc_write: (0x%llx) start xfer size=%d", in i_ldc_write_packet()
4528 ldcp->id, *size); in i_ldc_write_packet()
4532 curr_seqid = ldcp->last_msg_snt; in i_ldc_write_packet()
4537 ldcmsg = (ldc_msg_t *)(ldcp->tx_q_va + tx_tail); in i_ldc_write_packet()
4539 msgbuf = (uint8_t *)((ldcp->mode == LDC_MODE_RELIABLE) ? in i_ldc_write_packet()
4540 ldcmsg->rdata : ldcmsg->udata); in i_ldc_write_packet()
4542 ldcmsg->type = LDC_DATA; in i_ldc_write_packet()
4543 ldcmsg->stype = LDC_INFO; in i_ldc_write_packet()
4544 ldcmsg->ctrl = 0; in i_ldc_write_packet()
4546 remaining = *size - bytes_written; in i_ldc_write_packet()
4547 len = min(ldcp->pkt_payload, remaining); in i_ldc_write_packet()
4548 ldcmsg->env = (uint8_t)len; in i_ldc_write_packet()
4551 ldcmsg->seqid = curr_seqid; in i_ldc_write_packet()
4566 ldcmsg->env |= LDC_FRAG_STOP; in i_ldc_write_packet()
4567 ldcmsg = (ldc_msg_t *)(ldcp->tx_q_va + start); in i_ldc_write_packet()
4568 ldcmsg->env |= LDC_FRAG_START; in i_ldc_write_packet()
4576 ldcp->tx_tail = tx_tail; in i_ldc_write_packet()
4577 ldcp->last_msg_snt = curr_seqid; in i_ldc_write_packet()
4584 if (mutex_tryenter(&ldcp->lock)) { in i_ldc_write_packet()
4586 mutex_exit(&ldcp->lock); in i_ldc_write_packet()
4592 mutex_exit(&ldcp->tx_lock); in i_ldc_write_packet()
4593 mutex_enter(&ldcp->lock); in i_ldc_write_packet()
4594 mutex_enter(&ldcp->tx_lock); in i_ldc_write_packet()
4596 mutex_exit(&ldcp->lock); in i_ldc_write_packet()
4601 D1(ldcp->id, "hv_tx_set_tail returns 0x%x (head 0x%x, " in i_ldc_write_packet()
4603 rv, ldcp->tx_head, ldcp->tx_tail, tx_tail, in i_ldc_write_packet()
4604 (ldcp->tx_q_entries << LDC_PACKET_SHIFT)); in i_ldc_write_packet()
4606 rv2 = hv_ldc_tx_get_state(ldcp->id, in i_ldc_write_packet()
4607 &tx_head, &tx_tail, &ldcp->link_state); in i_ldc_write_packet()
4609 D1(ldcp->id, "hv_ldc_tx_get_state returns 0x%x " in i_ldc_write_packet()
4611 rv2, tx_head, tx_tail, ldcp->link_state); in i_ldc_write_packet()
4616 D2(ldcp->id, "ldc_write: (0x%llx) end xfer size=%d", ldcp->id, *size); in i_ldc_write_packet()
4633 ASSERT(MUTEX_HELD(&ldcp->tx_lock)); in i_ldc_write_stream()
4634 ASSERT(ldcp->mode == LDC_MODE_RELIABLE); in i_ldc_write_stream()
4637 if (*sizep > ldcp->mtu) *sizep = ldcp->mtu; in i_ldc_write_stream()
4652 if (cinfo == NULL || cinfo->dip == NULL || in ldc_register()
4653 cinfo->reg_chan == NULL || cinfo->unreg_chan == NULL || in ldc_register()
4654 cinfo->add_intr == NULL || cinfo->rem_intr == NULL || in ldc_register()
4655 cinfo->clr_intr == NULL) { in ldc_register()
4661 mutex_enter(&ldcssp->lock); in ldc_register()
4664 ldcssp->cinfo.dip = cinfo->dip; in ldc_register()
4665 ldcssp->cinfo.reg_chan = cinfo->reg_chan; in ldc_register()
4666 ldcssp->cinfo.unreg_chan = cinfo->unreg_chan; in ldc_register()
4667 ldcssp->cinfo.add_intr = cinfo->add_intr; in ldc_register()
4668 ldcssp->cinfo.rem_intr = cinfo->rem_intr; in ldc_register()
4669 ldcssp->cinfo.clr_intr = cinfo->clr_intr; in ldc_register()
4672 ldcp = ldcssp->chan_list; in ldc_register()
4674 if ((ldcp->tstate & TS_QCONF_RDY) && in ldc_register()
4675 (ldcp->tstate & TS_CNEX_RDY) == 0) in ldc_register()
4678 ldcp = ldcp->next; in ldc_register()
4681 mutex_exit(&ldcssp->lock); in ldc_register()
4689 if (cinfo == NULL || cinfo->dip == NULL) { in ldc_unregister()
4694 mutex_enter(&ldcssp->lock); in ldc_unregister()
4696 if (cinfo->dip != ldcssp->cinfo.dip) { in ldc_unregister()
4698 mutex_exit(&ldcssp->lock); in ldc_unregister()
4703 ldcssp->cinfo.dip = NULL; in ldc_unregister()
4704 ldcssp->cinfo.reg_chan = NULL; in ldc_unregister()
4705 ldcssp->cinfo.unreg_chan = NULL; in ldc_unregister()
4706 ldcssp->cinfo.add_intr = NULL; in ldc_unregister()
4707 ldcssp->cinfo.rem_intr = NULL; in ldc_unregister()
4708 ldcssp->cinfo.clr_intr = NULL; in ldc_unregister()
4710 mutex_exit(&ldcssp->lock); in ldc_unregister()
4728 mutex_enter(&ldcp->lock); in ldc_info()
4731 if ((ldcp->tstate & ~TS_IN_RESET) < TS_INIT) { in ldc_info()
4732 DWARN(ldcp->id, in ldc_info()
4734 ldcp->id); in ldc_info()
4735 mutex_exit(&ldcp->lock); in ldc_info()
4739 mutex_exit(&ldcp->lock); in ldc_info()
4742 * ldcssp->mapin_size is the max amount of shared memory supported by in ldc_info()
4752 if (ldcssp->mapin_size <= ldc_dring_direct_map_rsvd) { in ldc_info()
4753 info->direct_map_size_max = 0; in ldc_info()
4757 avail = ldcssp->mapin_size - ldc_dring_direct_map_rsvd; in ldc_info()
4759 info->direct_map_size_max = ldc_direct_map_size_max; in ldc_info()
4761 info->direct_map_size_max = 0; in ldc_info()