Lines Matching refs:ldcp
122 static int vgen_ldc_reset(vgen_ldc_t *ldcp, vgen_caller_t caller);
123 static void vgen_ldc_up(vgen_ldc_t *ldcp);
125 static void vgen_ldc_detach(vgen_ldc_t *ldcp);
128 static int vgen_ldc_init(vgen_ldc_t *ldcp);
129 static void vgen_ldc_uninit(vgen_ldc_t *ldcp);
130 static uint64_t vgen_ldc_stat(vgen_ldc_t *ldcp, uint_t stat);
140 static int vgen_create_dring(vgen_ldc_t *ldcp);
141 static void vgen_destroy_dring(vgen_ldc_t *ldcp);
142 static int vgen_map_dring(vgen_ldc_t *ldcp, void *pkt);
143 static void vgen_unmap_dring(vgen_ldc_t *ldcp);
144 static int vgen_mapin_avail(vgen_ldc_t *ldcp);
147 static int vgen_handshake(vgen_ldc_t *ldcp);
148 static int vgen_handshake_done(vgen_ldc_t *ldcp);
149 static vgen_ldc_t *vh_nextphase(vgen_ldc_t *ldcp);
150 static int vgen_handshake_phase2(vgen_ldc_t *ldcp);
151 static int vgen_handshake_phase3(vgen_ldc_t *ldcp);
152 static void vgen_setup_handshake_params(vgen_ldc_t *ldcp);
153 static int vgen_send_version_negotiate(vgen_ldc_t *ldcp);
154 static int vgen_send_attr_info(vgen_ldc_t *ldcp);
155 static int vgen_send_rx_dring_reg(vgen_ldc_t *ldcp);
156 static int vgen_send_tx_dring_reg(vgen_ldc_t *ldcp);
157 static void vgen_init_dring_reg_msg(vgen_ldc_t *ldcp, vio_dring_reg_msg_t *msg,
159 static int vgen_send_rdx_info(vgen_ldc_t *ldcp);
160 static int vgen_send_dringdata(vgen_ldc_t *ldcp, uint32_t start, int32_t end);
161 static int vgen_send_mcast_info(vgen_ldc_t *ldcp);
162 static int vgen_handle_version_negotiate(vgen_ldc_t *ldcp,
164 static int vgen_handle_attr_msg(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp);
165 static int vgen_handle_attr_info(vgen_ldc_t *ldcp, vnet_attr_msg_t *msg);
166 static int vgen_handle_attr_ack(vgen_ldc_t *ldcp, vnet_attr_msg_t *msg);
167 static int vgen_handle_dring_reg(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp);
168 static int vgen_handle_dring_reg_info(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp);
169 static int vgen_handle_dring_reg_ack(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp);
170 static int vgen_handle_rdx_info(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp);
171 static int vgen_handle_mcast_info(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp);
172 static int vgen_handle_ctrlmsg(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp);
174 static int vgen_handle_datamsg(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp,
176 static void vgen_handle_errmsg(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp);
177 static int vgen_dds_rx(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp);
178 static void vgen_handle_evt_up(vgen_ldc_t *ldcp);
179 static int vgen_process_reset(vgen_ldc_t *ldcp, int flags);
180 static int vgen_check_sid(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp);
182 static void vgen_set_vnet_proto_ops(vgen_ldc_t *ldcp);
183 static void vgen_reset_vnet_proto_ops(vgen_ldc_t *ldcp);
203 int vgen_handle_evt_read(vgen_ldc_t *ldcp, vgen_caller_t caller);
204 int vgen_handle_evt_reset(vgen_ldc_t *ldcp, vgen_caller_t caller);
213 extern int vgen_sendmsg(vgen_ldc_t *ldcp, caddr_t msg, size_t msglen,
215 extern void vgen_stop_msg_thread(vgen_ldc_t *ldcp);
216 extern int vgen_create_tx_dring(vgen_ldc_t *ldcp);
217 extern void vgen_destroy_tx_dring(vgen_ldc_t *ldcp);
218 extern int vgen_map_rx_dring(vgen_ldc_t *ldcp, void *pkt);
219 extern void vgen_unmap_rx_dring(vgen_ldc_t *ldcp);
220 extern int vgen_create_rx_dring(vgen_ldc_t *ldcp);
221 extern void vgen_destroy_rx_dring(vgen_ldc_t *ldcp);
222 extern int vgen_map_tx_dring(vgen_ldc_t *ldcp, void *pkt);
223 extern void vgen_unmap_tx_dring(vgen_ldc_t *ldcp);
224 extern int vgen_map_data(vgen_ldc_t *ldcp, void *pkt);
230 extern int vgen_send_dringack_shm(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp,
232 extern mblk_t *vgen_poll_rcv_shm(vgen_ldc_t *ldcp, int bytes_to_pickup);
233 extern mblk_t *vgen_poll_rcv(vgen_ldc_t *ldcp, int bytes_to_pickup);
234 extern int vgen_check_datamsg_seq(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp);
238 #define LDC_LOCK(ldcp) \
239 mutex_enter(&((ldcp)->cblock));\
240 mutex_enter(&((ldcp)->rxlock));\
241 mutex_enter(&((ldcp)->wrlock));\
242 mutex_enter(&((ldcp)->txlock));\
243 mutex_enter(&((ldcp)->tclock));
244 #define LDC_UNLOCK(ldcp) \
245 mutex_exit(&((ldcp)->tclock));\
246 mutex_exit(&((ldcp)->txlock));\
247 mutex_exit(&((ldcp)->wrlock));\
248 mutex_exit(&((ldcp)->rxlock));\
249 mutex_exit(&((ldcp)->cblock));
251 #define VGEN_VER_EQ(ldcp, major, minor) \
252 ((ldcp)->local_hparams.ver_major == (major) && \
253 (ldcp)->local_hparams.ver_minor == (minor))
255 #define VGEN_VER_LT(ldcp, major, minor) \
256 (((ldcp)->local_hparams.ver_major < (major)) || \
257 ((ldcp)->local_hparams.ver_major == (major) && \
258 (ldcp)->local_hparams.ver_minor < (minor)))
260 #define VGEN_VER_GTEQ(ldcp, major, minor) \
261 (((ldcp)->local_hparams.ver_major > (major)) || \
262 ((ldcp)->local_hparams.ver_major == (major) && \
263 (ldcp)->local_hparams.ver_minor >= (minor)))
455 vgen_ldc_t *ldcp, const char *fmt, ...);
465 vgen_inject_error(vgen_ldc_t *ldcp, int error)
467 if ((vgendbg_ldcid == ldcp->ldc_id) &&
781 vgen_ldc_t *ldcp;
834 ldcp = portp->ldcp;
835 status = ldcp->tx(ldcp, mp);
854 vgen_ldc_t *ldcp = (vgen_ldc_t *)arg;
857 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
872 vgen_ldcsend_pkt(ldcp, mp);
878 if (ldcp->tx_dringdata == NULL) {
883 status = ldcp->tx_dringdata(ldcp, mp);
896 vgen_ldc_t *ldcp = (vgen_ldc_t *)arg;
906 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
907 vgen_stats_t *statsp = &ldcp->stats;
910 if (ldcp->ldc_status != LDC_UP) {
912 DWARN(vgenp, ldcp, "status(%d), dropping packet\n",
913 ldcp->ldc_status);
917 if (ldcp->hphase != VH_DONE) {
919 DWARN(vgenp, ldcp, "hphase(%x), dropping packet\n",
920 ldcp->hphase);
927 if (size > (size_t)(ldcp->msglen - VIO_PKT_DATA_HDRSIZE)) {
929 DWARN(vgenp, ldcp, "invalid size(%d)\n", size);
940 DWARN(vgenp, ldcp, "vio_allocb failed\n");
961 pkt->tag.vio_sid = ldcp->local_sid;
965 rv = vgen_sendmsg(ldcp, (caddr_t)pkt, nbytes, B_FALSE);
968 DWARN(vgenp, ldcp, "Error sending priority frame\n");
970 (void) vgen_handle_evt_reset(ldcp, VGEN_OTHER);
997 vgen_ldc_t *ldcp;
1013 ldcp = portp->ldcp;
1014 if (ldcp == NULL) {
1018 mutex_enter(&ldcp->cblock);
1020 if (ldcp->hphase == VH_DONE) {
1030 tagp->vio_sid = ldcp->local_sid;
1034 if (vgen_sendmsg(ldcp, (caddr_t)tagp, sizeof (mcastmsg),
1036 DWARN(vgenp, ldcp, "vgen_sendmsg failed\n");
1094 mutex_exit(&ldcp->cblock);
1183 vgen_ldc_detach(portp->ldcp);
1270 (void) vgen_ldc_init(portp->ldcp);
1276 vgen_ldc_uninit(portp->ldcp);
2450 return (vgen_ldc_stat(portp->ldcp, stat));
2458 vgen_ldc_t *ldcp;
2471 ldcp = kmem_zalloc(sizeof (vgen_ldc_t), KM_NOSLEEP);
2472 if (ldcp == NULL) {
2475 ldcp->ldc_id = ldc_id;
2476 ldcp->portp = portp;
2480 mutex_init(&ldcp->txlock, NULL, MUTEX_DRIVER, NULL);
2481 mutex_init(&ldcp->cblock, NULL, MUTEX_DRIVER, NULL);
2482 mutex_init(&ldcp->tclock, NULL, MUTEX_DRIVER, NULL);
2483 mutex_init(&ldcp->wrlock, NULL, MUTEX_DRIVER, NULL);
2484 mutex_init(&ldcp->rxlock, NULL, MUTEX_DRIVER, NULL);
2485 mutex_init(&ldcp->pollq_lock, NULL, MUTEX_DRIVER, NULL);
2486 mutex_init(&ldcp->msg_thr_lock, NULL, MUTEX_DRIVER, NULL);
2487 cv_init(&ldcp->msg_thr_cv, NULL, CV_DRIVER, NULL);
2495 status = ldc_init(ldc_id, &attr, &ldcp->ldc_handle);
2497 DWARN(vgenp, ldcp, "ldc_init failed,rv (%d)\n", status);
2502 status = ldc_reg_callback(ldcp->ldc_handle, vgen_ldc_cb, (caddr_t)ldcp);
2504 DWARN(vgenp, ldcp, "ldc_reg_callback failed, rv (%d)\n",
2512 ldcp->msglen = VIO_PKT_DATA_HDRSIZE + vgenp->max_frame_size;
2513 ldcp->ldcmsg = kmem_alloc(ldcp->msglen, KM_SLEEP);
2516 (void) ldc_status(ldcp->ldc_handle, &istatus);
2518 ldcp->ldc_status = istatus;
2522 (void) sprintf(kname, "vnetldc0x%lx", ldcp->ldc_id);
2523 ldcp->ksp = vgen_setup_kstats("vnet", instance, kname, &ldcp->stats);
2524 if (ldcp->ksp == NULL) {
2529 bcopy(vgen_versions, ldcp->vgen_versions, sizeof (ldcp->vgen_versions));
2530 vgen_reset_vnet_proto_ops(ldcp);
2533 portp->ldcp = ldcp;
2535 ldcp->link_state = LINK_STATE_UNKNOWN;
2537 ldcp->link_down_forced = B_FALSE;
2539 ldcp->flags |= CHANNEL_ATTACHED;
2544 (void) ldc_unreg_callback(ldcp->ldc_handle);
2545 kmem_free(ldcp->ldcmsg, ldcp->msglen);
2549 (void) ldc_fini(ldcp->ldc_handle);
2552 mutex_destroy(&ldcp->tclock);
2553 mutex_destroy(&ldcp->txlock);
2554 mutex_destroy(&ldcp->cblock);
2555 mutex_destroy(&ldcp->wrlock);
2556 mutex_destroy(&ldcp->rxlock);
2557 mutex_destroy(&ldcp->pollq_lock);
2560 KMEM_FREE(ldcp);
2567 vgen_ldc_detach(vgen_ldc_t *ldcp)
2572 ASSERT(ldcp != NULL);
2574 portp = ldcp->portp;
2577 if (ldcp->ldc_status != LDC_INIT) {
2578 DWARN(vgenp, ldcp, "ldc_status is not INIT\n");
2581 if (ldcp->flags & CHANNEL_ATTACHED) {
2582 ldcp->flags &= ~(CHANNEL_ATTACHED);
2584 (void) ldc_unreg_callback(ldcp->ldc_handle);
2585 (void) ldc_fini(ldcp->ldc_handle);
2587 kmem_free(ldcp->ldcmsg, ldcp->msglen);
2588 vgen_destroy_kstats(ldcp->ksp);
2589 ldcp->ksp = NULL;
2590 mutex_destroy(&ldcp->tclock);
2591 mutex_destroy(&ldcp->txlock);
2592 mutex_destroy(&ldcp->cblock);
2593 mutex_destroy(&ldcp->wrlock);
2594 mutex_destroy(&ldcp->rxlock);
2595 mutex_destroy(&ldcp->pollq_lock);
2596 mutex_destroy(&ldcp->msg_thr_lock);
2597 cv_destroy(&ldcp->msg_thr_cv);
2599 KMEM_FREE(ldcp);
2605 vgen_ldc_init(vgen_ldc_t *ldcp)
2607 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
2616 DBG1(vgenp, ldcp, "enter\n");
2617 LDC_LOCK(ldcp);
2619 rv = ldc_open(ldcp->ldc_handle);
2621 DWARN(vgenp, ldcp, "ldc_open failed: rv(%d)\n", rv);
2626 (void) ldc_status(ldcp->ldc_handle, &istatus);
2628 DWARN(vgenp, ldcp, "status(%d) is not OPEN/READY\n", istatus);
2631 ldcp->ldc_status = istatus;
2633 rv = ldc_set_cb_mode(ldcp->ldc_handle, LDC_CB_ENABLE);
2635 DWARN(vgenp, ldcp, "ldc_set_cb_mode failed: rv(%d)\n", rv);
2641 vgen_ldc_up(ldcp);
2643 (void) ldc_status(ldcp->ldc_handle, &istatus);
2645 DWARN(vgenp, ldcp, "status(%d) is UP\n", istatus);
2648 ldcp->ldc_status = istatus;
2650 ldcp->hphase = VH_PHASE0;
2651 ldcp->hstate = 0;
2652 ldcp->flags |= CHANNEL_STARTED;
2654 vgen_setup_handshake_params(ldcp);
2658 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
2659 if (ldcp->portp != vgenp->vsw_portp) {
2664 &ldcp->portp->use_vsw_port, B_FALSE);
2668 ldcp->local_sid = ddi_get_lbolt();
2671 ldcp->peer_sid = 0;
2673 mutex_exit(&ldcp->tclock);
2674 mutex_exit(&ldcp->txlock);
2675 mutex_exit(&ldcp->wrlock);
2676 mutex_exit(&ldcp->rxlock);
2677 rv = vgen_handshake(vh_nextphase(ldcp));
2678 mutex_exit(&ldcp->cblock);
2682 (void) vgen_process_reset(ldcp, flag);
2685 LDC_UNLOCK(ldcp);
2692 (void) ldc_set_cb_mode(ldcp->ldc_handle, LDC_CB_DISABLE);
2695 (void) ldc_close(ldcp->ldc_handle);
2697 LDC_UNLOCK(ldcp);
2698 DBG1(vgenp, ldcp, "exit\n");
2704 vgen_ldc_uninit(vgen_ldc_t *ldcp)
2706 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
2708 DBG1(vgenp, ldcp, "enter\n");
2710 LDC_LOCK(ldcp);
2712 if ((ldcp->flags & CHANNEL_STARTED) == 0) {
2713 LDC_UNLOCK(ldcp);
2714 DWARN(vgenp, ldcp, "CHANNEL_STARTED flag is not set\n");
2718 LDC_UNLOCK(ldcp);
2720 while (atomic_cas_uint(&ldcp->reset_in_progress, 0, 1) != 0) {
2724 (void) vgen_process_reset(ldcp, VGEN_FLAG_UNINIT);
2726 DBG1(vgenp, ldcp, "exit\n");
2733 vgen_create_dring(vgen_ldc_t *ldcp)
2735 vgen_hparams_t *lp = &ldcp->local_hparams;
2739 rv = vgen_create_rx_dring(ldcp);
2741 rv = vgen_create_tx_dring(ldcp);
2751 vgen_destroy_dring(vgen_ldc_t *ldcp)
2753 vgen_hparams_t *lp = &ldcp->local_hparams;
2756 vgen_destroy_rx_dring(ldcp);
2758 vgen_destroy_tx_dring(ldcp);
2766 vgen_map_dring(vgen_ldc_t *ldcp, void *pkt)
2769 vgen_hparams_t *lp = &ldcp->local_hparams;
2776 rv = vgen_map_tx_dring(ldcp, pkt);
2783 rv = vgen_map_rx_dring(ldcp, pkt);
2793 vgen_unmap_dring(vgen_ldc_t *ldcp)
2795 vgen_hparams_t *lp = &ldcp->local_hparams;
2798 vgen_unmap_tx_dring(ldcp);
2800 vgen_unmap_rx_dring(ldcp);
2821 vgen_ldc_stat(vgen_ldc_t *ldcp, uint_t stat)
2827 statsp = &ldcp->stats;
2939 vgen_handle_evt_up(vgen_ldc_t *ldcp)
2941 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
2943 DBG1(vgenp, ldcp, "enter\n");
2945 ASSERT(MUTEX_HELD(&ldcp->cblock));
2947 if (ldcp->portp != vgenp->vsw_portp) {
2951 (void) atomic_swap_32(&ldcp->portp->use_vsw_port, B_FALSE);
2955 ldcp->local_sid = ddi_get_lbolt();
2958 ldcp->peer_sid = 0;
2961 (void) vgen_handshake(vh_nextphase(ldcp));
2963 DBG1(vgenp, ldcp, "exit\n");
2971 vgen_handle_evt_reset(vgen_ldc_t *ldcp, vgen_caller_t caller)
2974 ASSERT(MUTEX_HELD(&ldcp->cblock));
2978 if (atomic_cas_uint(&ldcp->reset_in_progress, 0, 1) != 0) {
2984 mutex_exit(&ldcp->cblock);
2987 (void) vgen_process_reset(ldcp, VGEN_FLAG_EVT_RESET);
2990 mutex_enter(&ldcp->cblock);
3001 vgen_ldc_t *ldcp;
3007 ldcp = (vgen_ldc_t *)arg;
3008 vgenp = LDC_TO_VGEN(ldcp);
3009 statsp = &ldcp->stats;
3011 DBG1(vgenp, ldcp, "enter\n");
3013 mutex_enter(&ldcp->cblock);
3015 if ((ldcp->ldc_status == LDC_INIT) || (ldcp->ldc_handle == NULL)) {
3016 DWARN(vgenp, ldcp, "status(%d) is LDC_INIT\n",
3017 ldcp->ldc_status);
3018 mutex_exit(&ldcp->cblock);
3028 if (ldc_status(ldcp->ldc_handle, &istatus) != 0) {
3029 DWARN(vgenp, ldcp, "ldc_status err\n");
3034 ldcp->ldc_status = istatus;
3035 if (ldcp->ldc_status != LDC_UP) {
3036 DWARN(vgenp, ldcp, "LDC_EVT_UP received "
3038 ldcp->ldc_status);
3042 DWARN(vgenp, ldcp, "event(%lx) UP, status(%d)\n",
3043 event, ldcp->ldc_status);
3045 vgen_handle_evt_up(ldcp);
3052 if (ldc_status(ldcp->ldc_handle, &istatus) != 0) {
3053 DWARN(vgenp, ldcp, "ldc_status error\n");
3058 ldcp->ldc_status = istatus;
3059 DWARN(vgenp, ldcp, "event(%lx) RESET/DOWN, status(%d)\n",
3060 event, ldcp->ldc_status);
3062 (void) vgen_handle_evt_reset(ldcp, VGEN_LDC_CB);
3069 DWARN(vgenp, ldcp,
3076 DBG2(vgenp, ldcp, "event(%lx) READ, status(%d)\n",
3077 event, ldcp->ldc_status);
3081 if (ldcp->msg_thread != NULL) {
3087 mutex_exit(&ldcp->cblock);
3088 mutex_enter(&ldcp->msg_thr_lock);
3089 if (!(ldcp->msg_thr_flags & VGEN_WTHR_DATARCVD)) {
3090 ldcp->msg_thr_flags |= VGEN_WTHR_DATARCVD;
3091 cv_signal(&ldcp->msg_thr_cv);
3093 mutex_exit(&ldcp->msg_thr_lock);
3094 mutex_enter(&ldcp->cblock);
3096 (void) vgen_handle_evt_read(ldcp, VGEN_LDC_CB);
3101 mutex_exit(&ldcp->cblock);
3102 DBG1(vgenp, ldcp, "exit\n");
3107 vgen_handle_evt_read(vgen_ldc_t *ldcp, vgen_caller_t caller)
3112 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
3117 DBG1(vgenp, ldcp, "enter\n");
3120 ASSERT(MUTEX_HELD(&ldcp->cblock));
3122 mutex_enter(&ldcp->cblock);
3127 ldcmsg = ldcp->ldcmsg;
3131 msglen = ldcp->msglen;
3132 rv = ldc_read(ldcp->ldc_handle, (caddr_t)ldcmsg, &msglen);
3135 DWARN(vgenp, ldcp, "ldc_read() failed "
3142 DBG2(vgenp, ldcp, "ldc_read NODATA");
3145 DBG2(vgenp, ldcp, "ldc_read msglen(%d)", msglen);
3149 if (ldcp->peer_sid) {
3155 if (vgen_inject_error(ldcp, VGEN_ERR_HSID)) {
3161 rv = vgen_check_sid(ldcp, tagp);
3167 DWARN(vgenp, ldcp, "vgen_check_sid() failed\n");
3174 rv = vgen_handle_ctrlmsg(ldcp, tagp);
3176 DWARN(vgenp, ldcp, "vgen_handle_ctrlmsg()"
3182 rv = vgen_handle_datamsg(ldcp, tagp, msglen);
3184 DWARN(vgenp, ldcp, "vgen_handle_datamsg()"
3190 vgen_handle_errmsg(ldcp, tagp);
3194 DWARN(vgenp, ldcp, "Unknown VIO_TYPE(%x)\n",
3210 rv = ldc_chkq(ldcp->ldc_handle, &has_data);
3212 DTRACE_PROBE1(vgen_chkq, vgen_ldc_t *, ldcp);
3225 if (ldc_status(ldcp->ldc_handle, &istatus) != 0) {
3226 DWARN(vgenp, ldcp, "ldc_status err\n");
3228 ldcp->ldc_status = istatus;
3230 (void) vgen_handle_evt_reset(ldcp, caller);
3232 DWARN(vgenp, ldcp, "Calling vgen_ldc_reset()...\n");
3233 (void) vgen_ldc_reset(ldcp, caller);
3238 mutex_exit(&ldcp->cblock);
3241 DBG1(vgenp, ldcp, "exit\n");
3249 vh_nextphase(vgen_ldc_t *ldcp)
3251 if (ldcp->hphase == VH_PHASE4) {
3252 ldcp->hphase = VH_DONE;
3254 ldcp->hphase++;
3256 return (ldcp);
3261 vgen_send_version_negotiate(vgen_ldc_t *ldcp)
3263 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
3273 tagp->vio_sid = ldcp->local_sid;
3275 /* get version msg payload from ldcp->local */
3276 vermsg.ver_major = ldcp->local_hparams.ver_major;
3277 vermsg.ver_minor = ldcp->local_hparams.ver_minor;
3278 vermsg.dev_class = ldcp->local_hparams.dev_class;
3280 rv = vgen_sendmsg(ldcp, (caddr_t)tagp, sizeof (vermsg), B_FALSE);
3282 DWARN(vgenp, ldcp, "vgen_sendmsg failed\n");
3286 ldcp->hstate |= VER_INFO_SENT;
3287 DBG2(vgenp, ldcp, "VER_INFO_SENT ver(%d,%d)\n",
3295 vgen_send_attr_info(vgen_ldc_t *ldcp)
3297 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
3307 tagp->vio_sid = ldcp->local_sid;
3309 /* get attr msg payload from ldcp->local */
3310 attrmsg.mtu = ldcp->local_hparams.mtu;
3311 attrmsg.addr = ldcp->local_hparams.addr;
3312 attrmsg.addr_type = ldcp->local_hparams.addr_type;
3313 attrmsg.xfer_mode = ldcp->local_hparams.xfer_mode;
3314 attrmsg.ack_freq = ldcp->local_hparams.ack_freq;
3315 attrmsg.physlink_update = ldcp->local_hparams.physlink_update;
3316 attrmsg.options = ldcp->local_hparams.dring_mode;
3318 rv = vgen_sendmsg(ldcp, (caddr_t)tagp, sizeof (attrmsg), B_FALSE);
3320 DWARN(vgenp, ldcp, "vgen_sendmsg failed\n");
3324 ldcp->hstate |= ATTR_INFO_SENT;
3325 DBG2(vgenp, ldcp, "ATTR_INFO_SENT\n");
3335 vgen_send_rx_dring_reg(vgen_ldc_t *ldcp)
3337 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
3344 msgsize = VNET_DRING_REG_EXT_MSG_SIZE(ldcp->rx_data_ncookies);
3348 vgen_init_dring_reg_msg(ldcp, msg, VIO_RX_DRING_DATA);
3359 emsg->data_ncookies = ldcp->rx_data_ncookies;
3362 emsg->data_area_size = ldcp->rx_data_sz;
3365 bcopy(ldcp->rx_data_cookie, (ldc_mem_cookie_t *)emsg->data_cookie,
3366 sizeof (ldc_mem_cookie_t) * ldcp->rx_data_ncookies);
3368 rv = vgen_sendmsg(ldcp, (caddr_t)msg, msgsize, B_FALSE);
3370 DWARN(vgenp, ldcp, "vgen_sendmsg failed\n");
3375 ldcp->hstate |= DRING_INFO_SENT;
3376 DBG2(vgenp, ldcp, "DRING_INFO_SENT \n");
3387 vgen_send_tx_dring_reg(vgen_ldc_t *ldcp)
3389 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
3398 vgen_init_dring_reg_msg(ldcp, &msg, VIO_TX_DRING);
3400 rv = vgen_sendmsg(ldcp, (caddr_t)&msg, sizeof (msg), B_FALSE);
3402 DWARN(vgenp, ldcp, "vgen_sendmsg failed\n");
3406 ldcp->hstate |= DRING_INFO_SENT;
3407 DBG2(vgenp, ldcp, "DRING_INFO_SENT \n");
3413 vgen_send_rdx_info(vgen_ldc_t *ldcp)
3415 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
3425 tagp->vio_sid = ldcp->local_sid;
3427 rv = vgen_sendmsg(ldcp, (caddr_t)tagp, sizeof (rdxmsg), B_FALSE);
3429 DWARN(vgenp, ldcp, "vgen_sendmsg failed\n");
3433 ldcp->hstate |= RDX_INFO_SENT;
3434 DBG2(vgenp, ldcp, "RDX_INFO_SENT\n");
3441 vgen_send_mcast_info(vgen_ldc_t *ldcp)
3456 vgenp = LDC_TO_VGEN(ldcp);
3465 tagp->vio_sid = ldcp->local_sid;
3475 rv = vgen_sendmsg(ldcp, (caddr_t)tagp, sizeof (*msgp),
3478 DWARN(vgenp, ldcp, "vgen_sendmsg err(%d)\n", rv);
3494 vgen_dds_rx(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp)
3497 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
3500 DWARN(vgenp, ldcp, "Unknown DDS class, dropping");
3516 vgen_ldc_t *ldcp;
3520 ldcp = vgenp->vsw_portp->ldcp;
3521 if ((ldcp == NULL) || (ldcp->hphase != VH_DONE)) {
3525 dmsg->tag.vio_sid = ldcp->local_sid;
3526 rv = vgen_sendmsg(ldcp, (caddr_t)dmsg, sizeof (vio_dds_msg_t), B_FALSE);
3541 vgen_handshake_phase2(vgen_ldc_t *ldcp)
3546 if (vgen_inject_error(ldcp, VGEN_ERR_HSTATE)) {
3549 rv = vgen_send_rdx_info(ldcp);
3552 if (vgen_inject_error(ldcp, VGEN_ERR_HTIMEOUT)) {
3558 rv = vgen_send_attr_info(ldcp);
3567 vgen_handshake_phase3(vgen_ldc_t *ldcp)
3570 vgen_hparams_t *lp = &ldcp->local_hparams;
3571 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
3572 vgen_stats_t *statsp = &ldcp->stats;
3578 ldcp->rx_dringdata = vgen_handle_dringdata_shm;
3579 ldcp->tx_dringdata = vgen_dringsend_shm;
3588 ldcp->tx = ldcp->tx_dringdata;
3591 ldcp->msg_thread = thread_create(NULL,
3592 2 * DEFAULTSTKSZ, vgen_ldc_msg_worker, ldcp, 0,
3596 rv = vgen_create_dring(ldcp);
3603 bcopy(&(ldcp->rx_dring_cookie),
3604 &(ldcp->local_hparams.dring_cookie),
3606 ldcp->local_hparams.dring_ncookies = ldcp->rx_dring_ncookies;
3607 ldcp->local_hparams.num_desc = ldcp->num_rxds;
3608 ldcp->local_hparams.desc_size =
3610 rv = vgen_send_rx_dring_reg(ldcp);
3612 bcopy(&(ldcp->tx_dring_cookie),
3613 &(ldcp->local_hparams.dring_cookie),
3615 ldcp->local_hparams.dring_ncookies = ldcp->tx_dring_ncookies;
3616 ldcp->local_hparams.num_desc = ldcp->num_txds;
3617 ldcp->local_hparams.desc_size = sizeof (vnet_public_desc_t);
3618 rv = vgen_send_tx_dring_reg(ldcp);
3632 vgen_set_vnet_proto_ops(vgen_ldc_t *ldcp)
3634 vgen_hparams_t *lp = &ldcp->local_hparams;
3635 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
3657 if (VGEN_VER_GTEQ(ldcp, 1, 6)) { /* Ver >= 1.6 */
3661 if (vgen_mapin_avail(ldcp) == B_TRUE) {
3670 if (VGEN_VER_GTEQ(ldcp, 1, 5)) {
3671 vgen_port_t *portp = ldcp->portp;
3686 if (VGEN_VER_GTEQ(ldcp, 1, 4)) {
3692 } else if (VGEN_VER_EQ(ldcp, 1, 3)) {
3699 vgen_port_t *portp = ldcp->portp;
3715 if (VGEN_VER_GTEQ(ldcp, 1, 2)) { /* Versions >= 1.2 */
3723 ldcp->tx_dringdata = vgen_dringsend;
3724 ldcp->rx_dringdata = vgen_handle_dringdata;
3731 ldcp->tx = vgen_ldcsend;
3732 ldcp->rx_pktdata = vgen_handle_pkt_data;
3738 ldcp->tx = ldcp->tx_dringdata;
3739 ldcp->rx_pktdata = vgen_handle_pkt_data_nop;
3745 vgen_reset_vnet_proto_ops(ldcp);
3753 vgen_reset_vnet_proto_ops(vgen_ldc_t *ldcp)
3755 vgen_hparams_t *lp = &ldcp->local_hparams;
3757 ldcp->tx = ldcp->tx_dringdata = vgen_dringsend;
3758 ldcp->rx_dringdata = vgen_handle_dringdata;
3759 ldcp->rx_pktdata = vgen_handle_pkt_data_nop;
3768 vgen_ldc_t *ldcp = portp->ldcp;
3773 mutex_enter(&ldcp->cblock);
3779 if (ldcp->hphase == VH_DONE && VGEN_VER_LT(ldcp, 1, 3) &&
3783 mutex_exit(&ldcp->cblock);
3786 (void) vgen_ldc_reset(ldcp, VGEN_OTHER);
3793 (void) vgen_ldc_reset(portp->ldcp, VGEN_OTHER);
3825 vgen_setup_handshake_params(vgen_ldc_t *ldcp)
3827 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
3832 bzero(&(ldcp->local_hparams), sizeof (ldcp->local_hparams));
3835 ldcp->local_hparams.ver_major =
3836 ldcp->vgen_versions[0].ver_major;
3837 ldcp->local_hparams.ver_minor =
3838 ldcp->vgen_versions[0].ver_minor;
3839 ldcp->local_hparams.dev_class = VDEV_NETWORK;
3842 ldcp->local_hparams.mtu = vgenp->max_frame_size;
3843 ldcp->local_hparams.addr =
3845 ldcp->local_hparams.addr_type = ADDR_TYPE_MAC;
3846 ldcp->local_hparams.xfer_mode = VIO_DRING_MODE_V1_0;
3847 ldcp->local_hparams.ack_freq = 0; /* don't need acks */
3848 ldcp->local_hparams.physlink_update = PHYSLINK_UPDATE_NONE;
3851 vgen_reset_vnet_proto_ops(ldcp);
3852 ldcp->local_hparams.dring_ident = 0;
3853 ldcp->local_hparams.dring_ready = B_FALSE;
3856 bzero(&(ldcp->peer_hparams), sizeof (ldcp->peer_hparams));
3857 ldcp->peer_hparams.dring_ready = B_FALSE;
3866 * ldcp: The channel being processed.
3883 vgen_process_reset(vgen_ldc_t *ldcp, int flags)
3885 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
3886 vgen_port_t *portp = ldcp->portp;
3887 vgen_hparams_t *lp = &ldcp->local_hparams;
3911 mutex_enter(&ldcp->cblock);
3914 ldcp->hstate = 0;
3915 ldcp->hphase = VH_PHASE0;
3917 DWARN(vgenp, ldcp, "Doing Channel Reset...\n");
3918 (void) ldc_down(ldcp->ldc_handle);
3919 (void) ldc_status(ldcp->ldc_handle, &istatus);
3920 DWARN(vgenp, ldcp, "Reset Done, ldc_status(%d)\n", istatus);
3921 ldcp->ldc_status = istatus;
3925 rv = ldc_set_cb_mode(ldcp->ldc_handle, LDC_CB_DISABLE);
3927 DWARN(vgenp, ldcp, "ldc_set_cb_mode failed\n");
3933 DWARN(vgenp, ldcp, "ldc status(%d)\n", ldcp->ldc_status);
3940 if (ldcp->link_state != LINK_STATE_DOWN) {
3941 ldcp->link_state = LINK_STATE_DOWN;
3957 if (ldcp->htid != 0) {
3958 htid = ldcp->htid;
3959 ldcp->htid = 0;
3962 if (ldcp->wd_tid != 0) {
3963 wd_tid = ldcp->wd_tid;
3964 ldcp->wd_tid = 0;
3967 mutex_exit(&ldcp->cblock);
3971 vgen_link_update(vgenp, ldcp->link_state);
3993 if (lp->dring_mode == VIO_TX_DRING && curthread != ldcp->msg_thread) {
3994 vgen_stop_msg_thread(ldcp);
3998 LDC_LOCK(ldcp);
4001 vgen_destroy_dring(ldcp);
4004 vgen_unmap_dring(ldcp);
4013 vgen_setup_handshake_params(ldcp);
4016 vgen_ldc_up(ldcp);
4018 if (ldc_status(ldcp->ldc_handle, &istatus) != 0) {
4019 DWARN(vgenp, ldcp, "ldc_status err\n");
4021 ldcp->ldc_status = istatus;
4025 if (ldcp->ldc_status == LDC_UP) {
4036 ldcp->local_sid = ddi_get_lbolt();
4039 ldcp->peer_sid = 0;
4049 mutex_exit(&ldcp->tclock);
4050 mutex_exit(&ldcp->txlock);
4051 mutex_exit(&ldcp->wrlock);
4052 mutex_exit(&ldcp->rxlock);
4053 rv = vgen_handshake(vh_nextphase(ldcp));
4054 mutex_exit(&ldcp->cblock);
4070 LDC_UNLOCK(ldcp);
4076 while ((rv = ldc_close(ldcp->ldc_handle)) == EAGAIN) {
4085 vgenp->instance, rv, ldcp->ldc_id);
4088 ldcp->ldc_reset_count = 0;
4089 ldcp->ldc_status = LDC_INIT;
4090 ldcp->flags &= ~(CHANNEL_STARTED);
4092 LDC_UNLOCK(ldcp);
4096 ldcp->reset_in_progress = 0;
4105 vgen_handshake(vgen_ldc_t *ldcp)
4107 uint32_t hphase = ldcp->hphase;
4108 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
4122 ASSERT(ldcp->htid == 0);
4123 ldcp->htid = timeout(vgen_hwatchdog, (caddr_t)ldcp,
4127 rv = vgen_send_version_negotiate(ldcp);
4131 rv = vgen_handshake_phase2(ldcp);
4135 rv = vgen_handshake_phase3(ldcp);
4139 rv = vgen_send_rdx_info(ldcp);
4144 ldcp->ldc_reset_count = 0;
4146 DBG1(vgenp, ldcp, "Handshake Done\n");
4153 ldcp->link_state = LINK_STATE_UP;
4155 if (ldcp->portp == vgenp->vsw_portp) {
4160 rv = vgen_send_mcast_info(ldcp);
4178 mutex_exit(&ldcp->cblock);
4179 vgen_link_update(vgenp, ldcp->link_state);
4180 mutex_enter(&ldcp->cblock);
4184 if (ldcp->htid != 0) {
4185 htid = ldcp->htid;
4186 ldcp->htid = 0;
4188 mutex_exit(&ldcp->cblock);
4190 mutex_enter(&ldcp->cblock);
4198 mutex_enter(&ldcp->tclock);
4199 if (ldcp->tx_blocked) {
4201 ldcp->portp->vcb.vio_net_tx_update;
4203 ldcp->tx_blocked = B_FALSE;
4204 vtx_update(ldcp->portp->vhp);
4206 mutex_exit(&ldcp->tclock);
4209 ldcp->wd_tid = timeout(vgen_tx_watchdog, (caddr_t)ldcp,
4226 vgen_handshake_done(vgen_ldc_t *ldcp)
4228 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
4229 uint32_t hphase = ldcp->hphase;
4239 status = ((ldcp->hstate & VER_NEGOTIATED) ==
4248 status = ((ldcp->hstate & ATTR_INFO_EXCHANGED) ==
4257 status = ((ldcp->hstate & DRING_INFO_EXCHANGED) ==
4263 status = ((ldcp->hstate & RDX_EXCHANGED) ==
4274 DBG2(vgenp, ldcp, "PHASE(%d)\n", hphase);
4306 vgen_handle_version_negotiate(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp)
4313 vgen_ver_t *versions = ldcp->vgen_versions;
4316 vgenp = LDC_TO_VGEN(ldcp);
4317 DBG1(vgenp, ldcp, "enter\n");
4322 if (ldcp->peer_sid == 0) {
4323 DBG2(vgenp, ldcp, "Caching peer_sid(%x)\n",
4325 ldcp->peer_sid = tagp->vio_sid;
4328 if (ldcp->hphase != VH_PHASE1) {
4337 ldcp->hstate |= VER_INFO_RCVD;
4340 ldcp->peer_hparams.ver_major = vermsg->ver_major;
4341 ldcp->peer_hparams.ver_minor = vermsg->ver_minor;
4342 ldcp->peer_hparams.dev_class = vermsg->dev_class;
4348 DWARN(vgenp, ldcp, "Version Negotiation Failed\n");
4351 tagp->vio_sid = ldcp->local_sid;
4353 rv = vgen_sendmsg(ldcp, (caddr_t)tagp,
4361 DBG2(vgenp, ldcp, "VER_INFO_RCVD, ver(%d,%d)\n",
4391 ldcp->peer_hparams.ver_minor =
4411 tagp->vio_sid = ldcp->local_sid;
4414 rv = vgen_sendmsg(ldcp, (caddr_t)tagp, sizeof (*vermsg),
4421 ldcp->hstate |= VER_ACK_SENT;
4422 DBG2(vgenp, ldcp, "VER_ACK_SENT, ver(%d,%d) \n",
4426 DWARN(vgenp, ldcp, "Negotiation Failed\n");
4429 if (vgen_handshake_done(ldcp) == VGEN_SUCCESS) {
4434 ASSERT((ldcp->local_hparams.ver_major ==
4435 ldcp->peer_hparams.ver_major) &&
4436 (ldcp->local_hparams.ver_minor ==
4437 ldcp->peer_hparams.ver_minor));
4439 vgen_set_vnet_proto_ops(ldcp);
4442 rv = vgen_handshake(vh_nextphase(ldcp));
4452 if (ldcp->hphase != VH_PHASE1) {
4454 DWARN(vgenp, ldcp, "Invalid Phase(%u)\n", ldcp->hphase);
4459 ldcp->local_hparams.ver_major = vermsg->ver_major;
4460 ldcp->local_hparams.ver_minor = vermsg->ver_minor;
4461 ldcp->hstate |= VER_ACK_RCVD;
4463 DBG2(vgenp, ldcp, "VER_ACK_RCVD, ver(%d,%d) \n",
4466 if (vgen_handshake_done(ldcp) == VGEN_SUCCESS) {
4471 ASSERT((ldcp->local_hparams.ver_major ==
4472 ldcp->peer_hparams.ver_major) &&
4473 (ldcp->local_hparams.ver_minor ==
4474 ldcp->peer_hparams.ver_minor));
4476 vgen_set_vnet_proto_ops(ldcp);
4479 rv = vgen_handshake(vh_nextphase(ldcp));
4488 if (ldcp->hphase != VH_PHASE1) {
4490 DWARN(vgenp, ldcp, "VER_NACK_RCVD Invalid "
4491 "Phase(%u)\n", ldcp->hphase);
4495 DBG2(vgenp, ldcp, "VER_NACK_RCVD next ver(%d,%d)\n",
4503 DWARN(vgenp, ldcp, "Version Negotiation Failed\n");
4514 ldcp->local_hparams.ver_major =
4516 ldcp->local_hparams.ver_minor =
4524 ldcp->local_hparams.ver_major =
4527 ldcp->local_hparams.ver_minor =
4539 DWARN(vgenp, ldcp,
4546 rv = vgen_send_version_negotiate(ldcp);
4554 DBG1(vgenp, ldcp, "exit\n");
4559 vgen_handle_attr_info(vgen_ldc_t *ldcp, vnet_attr_msg_t *msg)
4561 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
4562 vgen_hparams_t *lp = &ldcp->local_hparams;
4563 vgen_hparams_t *rp = &ldcp->peer_hparams;
4567 ldcp->hstate |= ATTR_INFO_RCVD;
4589 if (VGEN_VER_GTEQ(ldcp, 1, 6)) {
4600 vgen_mapin_avail(ldcp) == B_TRUE) {
4627 if (ldcp->hstate & ATTR_ACK_RCVD) {
4648 if (VGEN_VER_GTEQ(ldcp, 1, 4)) {
4667 if (ldcp->hstate & ATTR_ACK_RCVD) {
4695 vgen_handle_attr_ack(vgen_ldc_t *ldcp, vnet_attr_msg_t *msg)
4697 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
4698 vgen_hparams_t *lp = &ldcp->local_hparams;
4703 if (VGEN_VER_GTEQ(ldcp, 1, 6)) {
4710 if (ldcp->hstate & ATTR_ACK_SENT) {
4749 if (VGEN_VER_GTEQ(ldcp, 1, 5) &&
4750 ldcp->portp == vgenp->vsw_portp) {
4770 if (VGEN_VER_GTEQ(ldcp, 1, 4)) {
4783 if (ldcp->hstate & ATTR_ACK_SENT) {
4812 vgen_handle_attr_msg(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp)
4814 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
4818 DBG1(vgenp, ldcp, "enter\n");
4819 if (ldcp->hphase != VH_PHASE2) {
4820 DWARN(vgenp, ldcp, "Rcvd ATTR_INFO subtype(%d),"
4822 tagp->vio_subtype, ldcp->hphase);
4828 rv = vgen_handle_attr_info(ldcp, msg);
4834 tagp->vio_sid = ldcp->local_sid;
4837 rv = vgen_sendmsg(ldcp, (caddr_t)tagp, sizeof (*msg),
4844 DWARN(vgenp, ldcp, "ATTR_NACK_SENT");
4848 ldcp->hstate |= ATTR_ACK_SENT;
4849 DBG2(vgenp, ldcp, "ATTR_ACK_SENT \n");
4850 if (vgen_handshake_done(ldcp) == VGEN_SUCCESS) {
4851 rv = vgen_handshake(vh_nextphase(ldcp));
4861 rv = vgen_handle_attr_ack(ldcp, msg);
4866 ldcp->hstate |= ATTR_ACK_RCVD;
4867 DBG2(vgenp, ldcp, "ATTR_ACK_RCVD \n");
4869 if (vgen_handshake_done(ldcp) == VGEN_SUCCESS) {
4870 rv = vgen_handshake(vh_nextphase(ldcp));
4879 DBG2(vgenp, ldcp, "ATTR_NACK_RCVD \n");
4882 DBG1(vgenp, ldcp, "exit\n");
4887 vgen_handle_dring_reg_info(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp)
4890 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
4891 vgen_hparams_t *lp = &ldcp->local_hparams;
4893 DBG2(vgenp, ldcp, "DRING_INFO_RCVD");
4894 ldcp->hstate |= DRING_INFO_RCVD;
4896 if (VGEN_VER_GTEQ(ldcp, 1, 6) &&
4904 DWARN(vgenp, ldcp,
4913 rv = vgen_map_dring(ldcp, (void *)tagp);
4922 rv = vgen_map_data(ldcp, (void *)tagp);
4924 vgen_unmap_dring(ldcp);
4929 if (ldcp->peer_hparams.dring_ready == B_FALSE) {
4930 ldcp->peer_hparams.dring_ready = B_TRUE;
4937 vgen_handle_dring_reg_ack(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp)
4939 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
4940 vgen_hparams_t *lp = &ldcp->local_hparams;
4942 DBG2(vgenp, ldcp, "DRING_ACK_RCVD");
4943 ldcp->hstate |= DRING_ACK_RCVD;
4963 vgen_handle_dring_reg(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp)
4965 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
4968 vgen_hparams_t *lp = &ldcp->local_hparams;
4970 DBG1(vgenp, ldcp, "enter\n");
4971 if (ldcp->hphase < VH_PHASE2) {
4973 DWARN(vgenp, ldcp,
4975 tagp->vio_subtype, ldcp->hphase);
4982 rv = vgen_handle_dring_reg_info(ldcp, tagp);
4989 tagp->vio_sid = ldcp->local_sid;
4993 VNET_DRING_REG_EXT_MSG_SIZE(ldcp->tx_data_ncookies);
4999 rv = vgen_sendmsg(ldcp, (caddr_t)tagp, msgsize,
5006 DWARN(vgenp, ldcp, "DRING_NACK_SENT");
5010 ldcp->hstate |= DRING_ACK_SENT;
5011 DBG2(vgenp, ldcp, "DRING_ACK_SENT");
5013 if (vgen_handshake_done(ldcp) == VGEN_SUCCESS) {
5014 rv = vgen_handshake(vh_nextphase(ldcp));
5023 rv = vgen_handle_dring_reg_ack(ldcp, tagp);
5028 if (vgen_handshake_done(ldcp) == VGEN_SUCCESS) {
5029 rv = vgen_handshake(vh_nextphase(ldcp));
5039 DWARN(vgenp, ldcp, "DRING_NACK_RCVD");
5042 DBG1(vgenp, ldcp, "exit\n");
5051 vgen_handle_rdx_info(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp)
5054 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
5056 DBG1(vgenp, ldcp, "enter\n");
5057 if (ldcp->hphase != VH_PHASE4) {
5058 DWARN(vgenp, ldcp,
5060 tagp->vio_subtype, ldcp->hphase);
5066 DBG2(vgenp, ldcp, "RDX_INFO_RCVD \n");
5067 ldcp->hstate |= RDX_INFO_RCVD;
5070 tagp->vio_sid = ldcp->local_sid;
5072 rv = vgen_sendmsg(ldcp, (caddr_t)tagp, sizeof (vio_rdx_msg_t),
5078 ldcp->hstate |= RDX_ACK_SENT;
5079 DBG2(vgenp, ldcp, "RDX_ACK_SENT \n");
5081 if (vgen_handshake_done(ldcp) == VGEN_SUCCESS) {
5082 rv = vgen_handshake(vh_nextphase(ldcp));
5092 ldcp->hstate |= RDX_ACK_RCVD;
5094 DBG2(vgenp, ldcp, "RDX_ACK_RCVD \n");
5096 if (vgen_handshake_done(ldcp) == VGEN_SUCCESS) {
5097 rv = vgen_handshake(vh_nextphase(ldcp));
5106 DBG2(vgenp, ldcp, "RDX_NACK_RCVD \n");
5109 DBG1(vgenp, ldcp, "exit\n");
5115 vgen_handle_mcast_info(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp)
5117 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
5123 DBG1(vgenp, ldcp, "enter\n");
5129 DWARN(vgenp, ldcp, "rcvd SET_MCAST_INFO \n");
5135 DBG1(vgenp, ldcp, "rcvd SET_MCAST_ACK \n");
5140 DWARN(vgenp, ldcp, "rcvd SET_MCAST_NACK \n");
5167 DBG1(vgenp, ldcp, "exit\n");
5179 vgen_handle_physlink_info(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp)
5181 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
5186 if (ldcp->portp != vgenp->vsw_portp) {
5216 mutex_exit(&ldcp->cblock);
5221 mutex_enter(&ldcp->cblock);
5225 tagp->vio_sid = ldcp->local_sid;
5228 rv = vgen_sendmsg(ldcp, (caddr_t)tagp,
5238 DWARN(vgenp, ldcp, "rcvd PHYSLINK_ACK \n");
5244 DWARN(vgenp, ldcp, "rcvd PHYSLINK_NACK \n");
5248 DBG1(vgenp, ldcp, "exit\n");
5255 vgen_handle_ctrlmsg(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp)
5258 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
5260 DBG1(vgenp, ldcp, "enter\n");
5264 rv = vgen_handle_version_negotiate(ldcp, tagp);
5268 rv = vgen_handle_attr_msg(ldcp, tagp);
5272 rv = vgen_handle_dring_reg(ldcp, tagp);
5276 rv = vgen_handle_rdx_info(ldcp, tagp);
5280 rv = vgen_handle_mcast_info(ldcp, tagp);
5290 if (ldcp->reset_in_progress == 1) {
5293 rv = vgen_dds_rx(ldcp, tagp);
5297 rv = vgen_handle_physlink_info(ldcp, tagp);
5301 DBG1(vgenp, ldcp, "exit rv(%d)\n", rv);
5307 vgen_handle_errmsg(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp)
5309 _NOTE(ARGUNUSED(ldcp, tagp))
5321 vgen_ldc_t *ldcp = (vgen_ldc_t *)arg1;
5327 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
5328 vgen_stats_t *statsp = &ldcp->stats;
5329 vgen_hparams_t *lp = &ldcp->local_hparams;
5332 ASSERT(MUTEX_HELD(&ldcp->cblock));
5334 mutex_exit(&ldcp->cblock);
5339 mutex_enter(&ldcp->cblock);
5343 vmp = vio_multipool_allocb(&ldcp->vmp, size);
5348 DWARN(vgenp, ldcp, "allocb failure, "
5350 mutex_enter(&ldcp->cblock);
5374 mutex_enter(&ldcp->rxlock);
5376 mutex_enter(&ldcp->pollq_lock);
5379 if (ldcp->polling_on == B_TRUE) {
5380 if (ldcp->rx_pri_tail != NULL) {
5381 ldcp->rx_pri_tail->b_next = mp;
5383 ldcp->rx_pri_head = ldcp->rx_pri_tail = mp;
5386 vrx_cb = ldcp->portp->vcb.vio_net_rx_cb;
5390 mutex_exit(&ldcp->rxlock);
5392 mutex_exit(&ldcp->pollq_lock);
5396 vrx_cb(ldcp->portp->vhp, mp);
5399 mutex_enter(&ldcp->cblock);
5413 vgen_handle_datamsg(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp, uint32_t msglen)
5416 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
5417 vgen_hparams_t *lp = &ldcp->local_hparams;
5419 DBG1(vgenp, ldcp, "enter\n");
5421 if (ldcp->hphase != VH_DONE) {
5430 rv = vgen_check_datamsg_seq(ldcp, tagp);
5438 rv = ldcp->rx_dringdata((void *)ldcp, (void *)tagp);
5442 ldcp->rx_pktdata((void *)ldcp, (void *)tagp, msglen);
5448 DBG1(vgenp, ldcp, "exit rv(%d)\n", rv);
5454 vgen_ldc_reset(vgen_ldc_t *ldcp, vgen_caller_t caller)
5459 ASSERT(MUTEX_HELD(&ldcp->cblock));
5463 if (atomic_cas_uint(&ldcp->reset_in_progress, 0, 1) != 0) {
5469 mutex_exit(&ldcp->cblock);
5472 rv = vgen_process_reset(ldcp, VGEN_FLAG_NEED_LDCRESET);
5475 mutex_enter(&ldcp->cblock);
5482 vgen_ldc_up(vgen_ldc_t *ldcp)
5486 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
5488 ASSERT(MUTEX_HELD(&ldcp->cblock));
5494 if (ldcp->ldc_reset_count == vgen_ldc_max_resets) {
5497 vgenp->instance, vgen_ldc_max_resets, ldcp->ldc_id);
5500 ldcp->ldc_reset_count++;
5503 rv = ldc_up(ldcp->ldc_handle);
5512 DWARN(vgenp, ldcp, "ldc_up err rv(%d)\n", rv);
5522 vgen_ldc_t *ldcp = portp->ldcp;
5523 vgen_hparams_t *lp = &ldcp->local_hparams;
5526 mutex_enter(&ldcp->rxlock);
5528 ldcp->polling_on = B_FALSE;
5534 end_ix = ldcp->next_rxi;
5535 DECR_RXI(end_ix, ldcp);
5536 msg.dring_ident = ldcp->peer_hparams.dring_ident;
5537 (void) vgen_send_dringack_shm(ldcp, (vio_msg_tag_t *)&msg,
5540 mutex_exit(&ldcp->rxlock);
5542 mutex_enter(&ldcp->pollq_lock);
5543 ldcp->polling_on = B_FALSE;
5544 mutex_exit(&ldcp->pollq_lock);
5554 vgen_ldc_t *ldcp = portp->ldcp;
5555 vgen_hparams_t *lp = &ldcp->local_hparams;
5558 mutex_enter(&ldcp->rxlock);
5559 ldcp->polling_on = B_TRUE;
5560 mutex_exit(&ldcp->rxlock);
5562 mutex_enter(&ldcp->pollq_lock);
5563 ldcp->polling_on = B_TRUE;
5564 mutex_exit(&ldcp->pollq_lock);
5574 vgen_ldc_t *ldcp = portp->ldcp;
5575 vgen_hparams_t *lp = &ldcp->local_hparams;
5579 mp = vgen_poll_rcv_shm(ldcp, bytes_to_pickup);
5581 mp = vgen_poll_rcv(ldcp, bytes_to_pickup);
5591 vgen_ldc_t *ldcp;
5597 ldcp = (vgen_ldc_t *)arg;
5598 vgenp = LDC_TO_VGEN(ldcp);
5600 tx_blocked = ldcp->tx_blocked;
5601 tx_blocked_lbolt = ldcp->tx_blocked_lbolt;
5612 DWARN(vgenp, ldcp, "transmit timeout lbolt(%lx), "
5617 if (vgen_inject_error(ldcp, VGEN_ERR_TXTIMEOUT)) {
5629 mutex_enter(&ldcp->cblock);
5630 if (ldcp->wd_tid == 0) {
5632 mutex_exit(&ldcp->cblock);
5635 ldcp->wd_tid = 0;
5636 mutex_exit(&ldcp->cblock);
5641 rv = vgen_ldc_reset(ldcp, VGEN_OTHER);
5648 if (ldcp->tx_blocked) {
5650 ldcp->portp->vcb.vio_net_tx_update;
5652 ldcp->tx_blocked = B_FALSE;
5653 vtx_update(ldcp->portp->vhp);
5669 mutex_enter(&ldcp->cblock);
5670 if (ldcp->wd_tid == 0) {
5672 mutex_exit(&ldcp->cblock);
5675 ldcp->wd_tid = timeout(vgen_tx_watchdog, (caddr_t)ldcp,
5677 mutex_exit(&ldcp->cblock);
5684 vgen_ldc_t *ldcp = (vgen_ldc_t *)arg;
5685 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
5687 DWARN(vgenp, ldcp, "handshake timeout phase(%x) state(%x)\n",
5688 ldcp->hphase, ldcp->hstate);
5690 mutex_enter(&ldcp->cblock);
5691 if (ldcp->htid == 0) {
5693 mutex_exit(&ldcp->cblock);
5696 ldcp->htid = 0;
5697 mutex_exit(&ldcp->cblock);
5703 (void) vgen_ldc_reset(ldcp, VGEN_OTHER);
5708 vgen_check_sid(vgen_ldc_t *ldcp, vio_msg_tag_t *tagp)
5710 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
5712 if (tagp->vio_sid != ldcp->peer_sid) {
5713 DWARN(vgenp, ldcp, "sid mismatch: expected(%x), rcvd(%x)\n",
5714 ldcp->peer_sid, tagp->vio_sid);
5726 vgen_init_dring_reg_msg(vgen_ldc_t *ldcp, vio_dring_reg_msg_t *msg,
5735 tagp->vio_sid = ldcp->local_sid;
5737 /* get dring info msg payload from ldcp->local */
5738 bcopy(&(ldcp->local_hparams.dring_cookie), &(msg->cookie[0]),
5740 msg->ncookies = ldcp->local_hparams.dring_ncookies;
5741 msg->num_descriptors = ldcp->local_hparams.num_desc;
5742 msg->descriptor_size = ldcp->local_hparams.desc_size;
5755 vgen_mapin_avail(vgen_ldc_t *ldcp)
5761 vgen_t *vgenp = LDC_TO_VGEN(ldcp);
5763 rv = ldc_info(ldcp->ldc_handle, &info);
5785 vgen_ldc_t *ldcp, const char *fmt, ...)
5796 if (ldcp != NULL) {
5797 (void) sprintf(bufp, "ldc(%ld):", ldcp->ldc_id);
5807 if ((ldcp == NULL) ||(vgendbg_ldcid == -1) ||
5808 (vgendbg_ldcid == ldcp->ldc_id)) {
5874 vgen_ldc_t *ldcp = portp->ldcp;
5877 mutex_enter(&ldcp->cblock);
5882 (void) ldc_down(ldcp->ldc_handle);
5883 ldcp->link_down_forced = B_TRUE;
5887 vgen_ldc_up(ldcp);
5888 ldcp->link_down_forced = B_FALSE;
5890 if (ldc_status(ldcp->ldc_handle, &istatus) != 0) {
5891 DWARN(vgenp, ldcp, "ldc_status err\n");
5893 ldcp->ldc_status = istatus;
5897 if (ldcp->ldc_status == LDC_UP) {
5898 vgen_handle_evt_up(ldcp);
5904 mutex_exit(&ldcp->cblock);