return;
 
        mutex_lock(&lport->disc.disc_mutex);
-       rdata = lport->tt.rport_create(lport, port_id);
+       rdata = fc_rport_create(lport, port_id);
        if (!rdata) {
                mutex_unlock(&lport->disc.disc_mutex);
                return;
 
 
                if (ids.port_id != lport->port_id &&
                    ids.port_name != lport->wwpn) {
-                       rdata = lport->tt.rport_create(lport, ids.port_id);
+                       rdata = fc_rport_create(lport, ids.port_id);
                        if (rdata) {
                                rdata->ids.port_name = ids.port_name;
                                rdata->disc_id = disc->disc_id;
                        mutex_unlock(&rdata->rp_mutex);
                        lport->tt.rport_logoff(rdata);
                        mutex_lock(&lport->disc.disc_mutex);
-                       new_rdata = lport->tt.rport_create(lport,
-                                                          rdata->ids.port_id);
+                       new_rdata = fc_rport_create(lport, rdata->ids.port_id);
                        mutex_unlock(&lport->disc.disc_mutex);
                        if (new_rdata) {
                                new_rdata->disc_id = disc->disc_id;
 {
        struct fc_rport_priv *rdata;
 
-       rdata = lport->tt.rport_create(lport, dp->port_id);
+       rdata = fc_rport_create(lport, dp->port_id);
        if (!rdata)
                return -ENOMEM;
        rdata->disc_id = 0;
 
                kref_put(&lport->ptp_rdata->kref, fc_rport_destroy);
        }
        mutex_lock(&lport->disc.disc_mutex);
-       lport->ptp_rdata = lport->tt.rport_create(lport, remote_fid);
+       lport->ptp_rdata = fc_rport_create(lport, remote_fid);
        kref_get(&lport->ptp_rdata->kref);
        lport->ptp_rdata->ids.port_name = remote_wwpn;
        lport->ptp_rdata->ids.node_name = remote_wwnn;
        fc_lport_state_enter(lport, LPORT_ST_DNS);
 
        mutex_lock(&lport->disc.disc_mutex);
-       rdata = lport->tt.rport_create(lport, FC_FID_DIR_SERV);
+       rdata = fc_rport_create(lport, FC_FID_DIR_SERV);
        mutex_unlock(&lport->disc.disc_mutex);
        if (!rdata)
                goto err;
        fc_lport_state_enter(lport, LPORT_ST_FDMI);
 
        mutex_lock(&lport->disc.disc_mutex);
-       rdata = lport->tt.rport_create(lport, FC_FID_MGMT_SERV);
+       rdata = fc_rport_create(lport, FC_FID_MGMT_SERV);
        mutex_unlock(&lport->disc.disc_mutex);
        if (!rdata)
                goto err;
 
  *
  * Locking note:  must be called with the disc_mutex held.
  */
-static struct fc_rport_priv *fc_rport_create(struct fc_lport *lport,
-                                            u32 port_id)
+struct fc_rport_priv *fc_rport_create(struct fc_lport *lport, u32 port_id)
 {
        struct fc_rport_priv *rdata;
 
        }
        return rdata;
 }
+EXPORT_SYMBOL(fc_rport_create);
 
 /**
  * fc_rport_destroy() - Free a remote port after last reference is released
 
        disc = &lport->disc;
        mutex_lock(&disc->disc_mutex);
-       rdata = lport->tt.rport_create(lport, sid);
+       rdata = fc_rport_create(lport, sid);
        if (!rdata) {
                mutex_unlock(&disc->disc_mutex);
                rjt_data.reason = ELS_RJT_UNAB;
  */
 int fc_rport_init(struct fc_lport *lport)
 {
-       if (!lport->tt.rport_create)
-               lport->tt.rport_create = fc_rport_create;
-
        if (!lport->tt.rport_login)
                lport->tt.rport_login = fc_rport_login;
 
 
        void (*lport_set_port_id)(struct fc_lport *, u32 port_id,
                                  struct fc_frame *);
 
-       /*
-        * Create a remote port with a given port ID
-        *
-        * STATUS: OPTIONAL
-        */
-       struct fc_rport_priv *(*rport_create)(struct fc_lport *, u32);
-
        /*
         * Initiates the RP state machine. It is called from the LP module.
         * This function will issue the following commands to the N_Port
 void fc_rport_terminate_io(struct fc_rport *);
 struct fc_rport_priv *fc_rport_lookup(const struct fc_lport *lport,
                                      u32 port_id);
+struct fc_rport_priv *fc_rport_create(struct fc_lport *, u32);
 void fc_rport_destroy(struct kref *kref);
 
 /*