*
  * Note: May sleep if invoked from outside a response handler.
  */
-static void fc_exch_done(struct fc_seq *sp)
+void fc_exch_done(struct fc_seq *sp)
 {
        struct fc_exch *ep = fc_seq_exch(sp);
        int rc;
        if (!rc)
                fc_exch_delete(ep);
 }
+EXPORT_SYMBOL(fc_exch_done);
 
 /**
  * fc_exch_resp() - Allocate a new exchange for a response frame
        if (!lport->tt.seq_set_resp)
                lport->tt.seq_set_resp = fc_seq_set_resp;
 
-       if (!lport->tt.exch_done)
-               lport->tt.exch_done = fc_exch_done;
-
        if (!lport->tt.exch_mgr_reset)
                lport->tt.exch_mgr_reset = fc_exch_mgr_reset;
 
 
 static void fc_fcp_retry_cmd(struct fc_fcp_pkt *fsp, int status_code)
 {
        if (fsp->seq_ptr) {
-               fsp->lp->tt.exch_done(fsp->seq_ptr);
+               fc_exch_done(fsp->seq_ptr);
                fsp->seq_ptr = NULL;
        }
 
                                fc_seq_send(lport, csp, conf_frame);
                        }
                }
-               lport->tt.exch_done(seq);
+               fc_exch_done(seq);
        }
        /*
         * Some resets driven by SCSI are not I/Os and do not have
  */
 static void fc_fcp_cleanup_cmd(struct fc_fcp_pkt *fsp, int error)
 {
-       struct fc_lport *lport = fsp->lp;
-
        if (fsp->seq_ptr) {
-               lport->tt.exch_done(fsp->seq_ptr);
+               fc_exch_done(fsp->seq_ptr);
                fsp->seq_ptr = NULL;
        }
        fsp->status_code = error;
 
        spin_lock_bh(&fsp->scsi_pkt_lock);
        if (fsp->seq_ptr) {
-               lport->tt.exch_done(fsp->seq_ptr);
+               fc_exch_done(fsp->seq_ptr);
                fsp->seq_ptr = NULL;
        }
        fsp->wait_for_comp = 0;
        if (fh->fh_type != FC_TYPE_BLS)
                fc_fcp_resp(fsp, fp);
        fsp->seq_ptr = NULL;
-       fsp->lp->tt.exch_done(seq);
+       fc_exch_done(seq);
 out_unlock:
        fc_fcp_unlock_pkt(fsp);
 out:
 
        fh = fc_frame_header_get(fp);
        /*
-        * BUG? fc_fcp_srr_error calls exch_done which would release
+        * BUG? fc_fcp_srr_error calls fc_exch_done which would release
         * the ep. But if fc_fcp_srr_error had got -FC_EX_TIMEOUT,
-        * then fc_exch_timeout would be sending an abort. The exch_done
+        * then fc_exch_timeout would be sending an abort. The fc_exch_done
         * call by fc_fcp_srr_error would prevent fc_exch.c from seeing
         * an abort response though.
         */
        }
        fc_fcp_unlock_pkt(fsp);
 out:
-       fsp->lp->tt.exch_done(seq);
+       fc_exch_done(seq);
        fc_frame_free(fp);
 }
 
        }
        fc_fcp_unlock_pkt(fsp);
 out:
-       fsp->lp->tt.exch_done(fsp->recov_seq);
+       fc_exch_done(fsp->recov_seq);
 }
 
 /**
 
        FC_LPORT_DBG(lport, "dropping unexpected frame type %x\n", fh->fh_type);
        fc_frame_free(fp);
        if (sp)
-               lport->tt.exch_done(sp);
+               fc_exch_done(sp);
 }
 EXPORT_SYMBOL(fc_lport_recv);
 
 
                se_cmd->scsi_status = SAM_STAT_TASK_SET_FULL;
                return -ENOMEM;
        }
-       lport->tt.exch_done(cmd->seq);
+       fc_exch_done(cmd->seq);
        /*
         * Drop the extra ACK_KREF reference taken by target_submit_cmd()
         * ahead of ft_check_stop_free() -> transport_generic_free_cmd()
        sp = fr_seq(fp);
        if (sp) {
                fc_seq_send(lport, sp, fp);
-               lport->tt.exch_done(sp);
+               fc_exch_done(sp);
        } else {
                lport->tt.frame_send(lport, fp);
        }
 
         */
        void (*get_lesb)(struct fc_lport *, struct fc_els_lesb *lesb);
 
-       /*
-        * Indicate that an exchange/sequence tuple is complete and the memory
-        * allocated for the related objects may be freed.
-        *
-        * STATUS: OPTIONAL
-        */
-       void (*exch_done)(struct fc_seq *);
-
        /*
         * Start a new sequence on the same exchange/sequence tuple.
         *
 void fc_exch_mgr_reset(struct fc_lport *, u32 s_id, u32 d_id);
 int fc_seq_send(struct fc_lport *lport, struct fc_seq *sp, struct fc_frame *fp);
 int fc_seq_exch_abort(const struct fc_seq *, unsigned int timer_msec);
+void fc_exch_done(struct fc_seq *sp);
 
 /*
  * Functions for fc_functions_template