Merge branch 'wip-2.6.34' into old-private-masterarchived-private-master

12 files changed, 426 insertions, 390 deletions

diff --git a/drivers/scsi/fnic/fnic.h b/drivers/scsi/fnic/fnic.h
index e4c0a3d7d87b..3966c71d0095 100644
--- a/drivers/scsi/fnic/fnic.h
+++ b/drivers/scsi/fnic/fnic.h
@@ -22,6 +22,7 @@
 #include <linux/netdevice.h>
 #include <linux/workqueue.h>
 #include <scsi/libfc.h>
+#include <scsi/libfcoe.h>
 #include "fnic_io.h"
 #include "fnic_res.h"
 #include "vnic_dev.h"
@@ -35,7 +36,7 @@
 
 #define DRV_NAME                "fnic"
 #define DRV_DESCRIPTION         "Cisco FCoE HBA Driver"
-#define DRV_VERSION             "1.0.0.1121"
+#define DRV_VERSION             "1.4.0.98"
 #define PFX                     DRV_NAME ": "
 #define DFX                     DRV_NAME "%d: "
 
@@ -44,7 +45,7 @@
 #define FNIC_IO_LOCKS           64 /* IO locks: power of 2 */
 #define FNIC_DFLT_QUEUE_DEPTH   32
 #define FNIC_STATS_RATE_LIMIT   4 /* limit rate at which stats are pulled up */
-
+#define FNIC_MAX_CMD_LEN        16 /* Supported CDB length */
 /*
  * Tag bits used for special requests.
  */
@@ -145,6 +146,7 @@ struct mempool;
 /* Per-instance private data structure */
 struct fnic {
         struct fc_lport *lport;
+        struct fcoe_ctlr ctlr;          /* FIP FCoE controller structure */
         struct vnic_dev_bar bar0;
 
         struct msix_entry msix_entry[FNIC_MSIX_INTR_MAX];
@@ -162,23 +164,16 @@ struct fnic {
         unsigned int wq_count;
         unsigned int cq_count;
 
-        u32 fcoui_mode:1;               /* use fcoui address*/
         u32 vlan_hw_insert:1;           /* let hw insert the tag */
         u32 in_remove:1;                /* fnic device in removal */
         u32 stop_rx_link_events:1;      /* stop proc. rx frames, link events */
 
         struct completion *remove_wait; /* device remove thread blocks */
 
-        struct fc_frame *flogi;
-        struct fc_frame *flogi_resp;
-        u16 flogi_oxid;
-        unsigned long s_id;
         enum fnic_state state;
         spinlock_t fnic_lock;
 
         u16 vlan_id;                    /* VLAN tag including priority */
-        u8 mac_addr[ETH_ALEN];
-        u8 dest_addr[ETH_ALEN];
         u8 data_src_addr[ETH_ALEN];
         u64 fcp_input_bytes;            /* internal statistic */
         u64 fcp_output_bytes;           /* internal statistic */
@@ -205,6 +200,7 @@ struct fnic {
         struct work_struct link_work;
         struct work_struct frame_work;
         struct sk_buff_head frame_queue;
+        struct sk_buff_head tx_queue;
 
         /* copy work queue cache line section */
         ____cacheline_aligned struct vnic_wq_copy wq_copy[FNIC_WQ_COPY_MAX];
@@ -224,6 +220,11 @@ struct fnic {
         ____cacheline_aligned struct vnic_intr intr[FNIC_MSIX_INTR_MAX];
 };
 
+static inline struct fnic *fnic_from_ctlr(struct fcoe_ctlr *fip)
+{
+        return container_of(fip, struct fnic, ctlr);
+}
+
 extern struct workqueue_struct *fnic_event_queue;
 extern struct device_attribute *fnic_attrs[];
 
@@ -239,7 +240,11 @@ void fnic_handle_link(struct work_struct *work);
 int fnic_rq_cmpl_handler(struct fnic *fnic, int);
 int fnic_alloc_rq_frame(struct vnic_rq *rq);
 void fnic_free_rq_buf(struct vnic_rq *rq, struct vnic_rq_buf *buf);
-int fnic_send_frame(struct fnic *fnic, struct fc_frame *fp);
+void fnic_flush_tx(struct fnic *);
+void fnic_eth_send(struct fcoe_ctlr *, struct sk_buff *skb);
+void fnic_set_port_id(struct fc_lport *, u32, struct fc_frame *);
+void fnic_update_mac(struct fc_lport *, u8 *new);
+void fnic_update_mac_locked(struct fnic *, u8 *new);
 
 int fnic_queuecommand(struct scsi_cmnd *, void (*done)(struct scsi_cmnd *));
 int fnic_abort_cmd(struct scsi_cmnd *);
@@ -252,7 +257,7 @@ void fnic_empty_scsi_cleanup(struct fc_lport *);
 void fnic_exch_mgr_reset(struct fc_lport *, u32, u32);
 int fnic_wq_copy_cmpl_handler(struct fnic *fnic, int);
 int fnic_wq_cmpl_handler(struct fnic *fnic, int);
-int fnic_flogi_reg_handler(struct fnic *fnic);
+int fnic_flogi_reg_handler(struct fnic *fnic, u32);
 void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
                                   struct fcpio_host_req *desc);
 int fnic_fw_reset_handler(struct fnic *fnic);
diff --git a/drivers/scsi/fnic/fnic_fcs.c b/drivers/scsi/fnic/fnic_fcs.c
index 50db3e36a619..5259888fbfb1 100644
--- a/drivers/scsi/fnic/fnic_fcs.c
+++ b/drivers/scsi/fnic/fnic_fcs.c
@@ -17,12 +17,14 @@
  */
 #include <linux/errno.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 #include <linux/if_ether.h>
 #include <linux/if_vlan.h>
 #include <linux/workqueue.h>
+#include <scsi/fc/fc_fip.h>
 #include <scsi/fc/fc_els.h>
 #include <scsi/fc/fc_fcoe.h>
 #include <scsi/fc_frame.h>
@@ -34,6 +36,8 @@
 
 struct workqueue_struct *fnic_event_queue;
 
+static void fnic_set_eth_mode(struct fnic *);
+
 void fnic_handle_link(struct work_struct *work)
 {
         struct fnic *fnic = container_of(work, struct fnic, link_work);
@@ -64,10 +68,10 @@ void fnic_handle_link(struct work_struct *work)
                                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
                                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
                                              "link down\n");
-                                fc_linkdown(fnic->lport);
+                                fcoe_ctlr_link_down(&fnic->ctlr);
                                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
                                              "link up\n");
-                                fc_linkup(fnic->lport);
+                                fcoe_ctlr_link_up(&fnic->ctlr);
                         } else
                                 /* UP -> UP */
                                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
@@ -76,13 +80,13 @@ void fnic_handle_link(struct work_struct *work)
                 /* DOWN -> UP */
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "link up\n");
-                fc_linkup(fnic->lport);
+                fcoe_ctlr_link_up(&fnic->ctlr);
         } else {
                 /* UP -> DOWN */
                 fnic->lport->host_stats.link_failure_count++;
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "link down\n");
-                fc_linkdown(fnic->lport);
+                fcoe_ctlr_link_down(&fnic->ctlr);
         }
 
 }
@@ -107,197 +111,179 @@ void fnic_handle_frame(struct work_struct *work)
                         return;
                 }
                 fp = (struct fc_frame *)skb;
-                /* if Flogi resp frame, register the address */
-                if (fr_flags(fp)) {
-                        vnic_dev_add_addr(fnic->vdev,
-                                          fnic->data_src_addr);
-                        fr_flags(fp) = 0;
+
+                /*
+                 * If we're in a transitional state, just re-queue and return.
+                 * The queue will be serviced when we get to a stable state.
+                 */
+                if (fnic->state != FNIC_IN_FC_MODE &&
+                    fnic->state != FNIC_IN_ETH_MODE) {
+                        skb_queue_head(&fnic->frame_queue, skb);
+                        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                        return;
                 }
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
                 fc_exch_recv(lp, fp);
         }
-
-}
-
-static inline void fnic_import_rq_fc_frame(struct sk_buff *skb,
-                                           u32 len, u8 sof, u8 eof)
-{
-        struct fc_frame *fp = (struct fc_frame *)skb;
-
-        skb_trim(skb, len);
-        fr_eof(fp) = eof;
-        fr_sof(fp) = sof;
 }
 
-
-static inline int fnic_import_rq_eth_pkt(struct sk_buff *skb, u32 len)
+/**
+ * fnic_import_rq_eth_pkt() - handle received FCoE or FIP frame.
+ * @fnic:       fnic instance.
+ * @skb:        Ethernet Frame.
+ */
+static inline int fnic_import_rq_eth_pkt(struct fnic *fnic, struct sk_buff *skb)
 {
         struct fc_frame *fp;
         struct ethhdr *eh;
-        struct vlan_ethhdr *vh;
         struct fcoe_hdr *fcoe_hdr;
         struct fcoe_crc_eof *ft;
-        u32    transport_len = 0;
 
+        /*
+         * Undo VLAN encapsulation if present.
+         */
         eh = (struct ethhdr *)skb->data;
-        vh = (struct vlan_ethhdr *)skb->data;
-        if (vh->h_vlan_proto == htons(ETH_P_8021Q) &&
-            vh->h_vlan_encapsulated_proto == htons(ETH_P_FCOE)) {
-                skb_pull(skb, sizeof(struct vlan_ethhdr));
-                transport_len += sizeof(struct vlan_ethhdr);
-        } else if (eh->h_proto == htons(ETH_P_FCOE)) {
-                transport_len += sizeof(struct ethhdr);
-                skb_pull(skb, sizeof(struct ethhdr));
-        } else
-                return -1;
+        if (eh->h_proto == htons(ETH_P_8021Q)) {
+                memmove((u8 *)eh + VLAN_HLEN, eh, ETH_ALEN * 2);
+                eh = (struct ethhdr *)skb_pull(skb, VLAN_HLEN);
+                skb_reset_mac_header(skb);
+        }
+        if (eh->h_proto == htons(ETH_P_FIP)) {
+                skb_pull(skb, sizeof(*eh));
+                fcoe_ctlr_recv(&fnic->ctlr, skb);
+                return 1;               /* let caller know packet was used */
+        }
+        if (eh->h_proto != htons(ETH_P_FCOE))
+                goto drop;
+        skb_set_network_header(skb, sizeof(*eh));
+        skb_pull(skb, sizeof(*eh));
 
         fcoe_hdr = (struct fcoe_hdr *)skb->data;
         if (FC_FCOE_DECAPS_VER(fcoe_hdr) != FC_FCOE_VER)
-                return -1;
+                goto drop;
 
         fp = (struct fc_frame *)skb;
         fc_frame_init(fp);
         fr_sof(fp) = fcoe_hdr->fcoe_sof;
         skb_pull(skb, sizeof(struct fcoe_hdr));
-        transport_len += sizeof(struct fcoe_hdr);
+        skb_reset_transport_header(skb);
 
-        ft = (struct fcoe_crc_eof *)(skb->data + len -
-                                     transport_len - sizeof(*ft));
+        ft = (struct fcoe_crc_eof *)(skb->data + skb->len - sizeof(*ft));
         fr_eof(fp) = ft->fcoe_eof;
-        skb_trim(skb, len - transport_len - sizeof(*ft));
+        skb_trim(skb, skb->len - sizeof(*ft));
         return 0;
+drop:
+        dev_kfree_skb_irq(skb);
+        return -1;
 }
 
-static inline int fnic_handle_flogi_resp(struct fnic *fnic,
-                                         struct fc_frame *fp)
+/**
+ * fnic_update_mac_locked() - set data MAC address and filters.
+ * @fnic:       fnic instance.
+ * @new:        newly-assigned FCoE MAC address.
+ *
+ * Called with the fnic lock held.
+ */
+void fnic_update_mac_locked(struct fnic *fnic, u8 *new)
 {
-        u8 mac[ETH_ALEN] = FC_FCOE_FLOGI_MAC;
-        struct ethhdr *eth_hdr;
-        struct fc_frame_header *fh;
-        int ret = 0;
-        unsigned long flags;
-        struct fc_frame *old_flogi_resp = NULL;
+        u8 *ctl = fnic->ctlr.ctl_src_addr;
+        u8 *data = fnic->data_src_addr;
 
-        fh = (struct fc_frame_header *)fr_hdr(fp);
+        if (is_zero_ether_addr(new))
+                new = ctl;
+        if (!compare_ether_addr(data, new))
+                return;
+        FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "update_mac %pM\n", new);
+        if (!is_zero_ether_addr(data) && compare_ether_addr(data, ctl))
+                vnic_dev_del_addr(fnic->vdev, data);
+        memcpy(data, new, ETH_ALEN);
+        if (compare_ether_addr(new, ctl))
+                vnic_dev_add_addr(fnic->vdev, new);
+}
 
-        spin_lock_irqsave(&fnic->fnic_lock, flags);
+/**
+ * fnic_update_mac() - set data MAC address and filters.
+ * @lport:      local port.
+ * @new:        newly-assigned FCoE MAC address.
+ */
+void fnic_update_mac(struct fc_lport *lport, u8 *new)
+{
+        struct fnic *fnic = lport_priv(lport);
 
-        if (fnic->state == FNIC_IN_ETH_MODE) {
+        spin_lock_irq(&fnic->fnic_lock);
+        fnic_update_mac_locked(fnic, new);
+        spin_unlock_irq(&fnic->fnic_lock);
+}
 
-                /*
-                 * Check if oxid matches on taking the lock. A new Flogi
-                 * issued by libFC might have changed the fnic cached oxid
-                 */
-                if (fnic->flogi_oxid != ntohs(fh->fh_ox_id)) {
-                        FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
-                                     "Flogi response oxid not"
-                                     " matching cached oxid, dropping frame"
-                                     "\n");
-                        ret = -1;
-                        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                        dev_kfree_skb_irq(fp_skb(fp));
-                        goto handle_flogi_resp_end;
-                }
+/**
+ * fnic_set_port_id() - set the port_ID after successful FLOGI.
+ * @lport:      local port.
+ * @port_id:    assigned FC_ID.
+ * @fp:         received frame containing the FLOGI accept or NULL.
+ *
+ * This is called from libfc when a new FC_ID has been assigned.
+ * This causes us to reset the firmware to FC_MODE and setup the new MAC
+ * address and FC_ID.
+ *
+ * It is also called with FC_ID 0 when we're logged off.
+ *
+ * If the FC_ID is due to point-to-point, fp may be NULL.
+ */
+void fnic_set_port_id(struct fc_lport *lport, u32 port_id, struct fc_frame *fp)
+{
+        struct fnic *fnic = lport_priv(lport);
+        u8 *mac;
+        int ret;
 
-                /* Drop older cached flogi response frame, cache this frame */
-                old_flogi_resp = fnic->flogi_resp;
-                fnic->flogi_resp = fp;
-                fnic->flogi_oxid = FC_XID_UNKNOWN;
+        FNIC_FCS_DBG(KERN_DEBUG, lport->host, "set port_id %x fp %p\n",
+                     port_id, fp);
 
-                /*
-                 * this frame is part of flogi get the src mac addr from this
-                 * frame if the src mac is fcoui based then we mark the
-                 * address mode flag to use fcoui base for dst mac addr
-                 * otherwise we have to store the fcoe gateway addr
-                 */
-                eth_hdr = (struct ethhdr *)skb_mac_header(fp_skb(fp));
-                memcpy(mac, eth_hdr->h_source, ETH_ALEN);
+        /*
+         * If we're clearing the FC_ID, change to use the ctl_src_addr.
+         * Set ethernet mode to send FLOGI.
+         */
+        if (!port_id) {
+                fnic_update_mac(lport, fnic->ctlr.ctl_src_addr);
+                fnic_set_eth_mode(fnic);
+                return;
+        }
 
-                if (ntoh24(mac) == FC_FCOE_OUI)
-                        fnic->fcoui_mode = 1;
-                else {
-                        fnic->fcoui_mode = 0;
-                        memcpy(fnic->dest_addr, mac, ETH_ALEN);
+        if (fp) {
+                mac = fr_cb(fp)->granted_mac;
+                if (is_zero_ether_addr(mac)) {
+                        /* non-FIP - FLOGI already accepted - ignore return */
+                        fcoe_ctlr_recv_flogi(&fnic->ctlr, lport, fp);
                 }
+                fnic_update_mac(lport, mac);
+        }
 
-                /*
-                 * Except for Flogi frame, all outbound frames from us have the
-                 * Eth Src address as FC_FCOE_OUI"our_sid". Flogi frame uses
-                 * the vnic MAC address as the Eth Src address
-                 */
-                fc_fcoe_set_mac(fnic->data_src_addr, fh->fh_d_id);
-
-                /* We get our s_id from the d_id of the flogi resp frame */
-                fnic->s_id = ntoh24(fh->fh_d_id);
-
-                /* Change state to reflect transition from Eth to FC mode */
+        /* Change state to reflect transition to FC mode */
+        spin_lock_irq(&fnic->fnic_lock);
+        if (fnic->state == FNIC_IN_ETH_MODE || fnic->state == FNIC_IN_FC_MODE)
                 fnic->state = FNIC_IN_ETH_TRANS_FC_MODE;
-
-        } else {
+        else {
                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
                              "Unexpected fnic state %s while"
                              " processing flogi resp\n",
                              fnic_state_to_str(fnic->state));
-                ret = -1;
-                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                dev_kfree_skb_irq(fp_skb(fp));
-                goto handle_flogi_resp_end;
+                spin_unlock_irq(&fnic->fnic_lock);
+                return;
         }
-
-        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-
-        /* Drop older cached frame */
-        if (old_flogi_resp)
-                dev_kfree_skb_irq(fp_skb(old_flogi_resp));
+        spin_unlock_irq(&fnic->fnic_lock);
 
         /*
-         * send flogi reg request to firmware, this will put the fnic in
-         * in FC mode
+         * Send FLOGI registration to firmware to set up FC mode.
+         * The new address will be set up when registration completes.
          */
-        ret = fnic_flogi_reg_handler(fnic);
+        ret = fnic_flogi_reg_handler(fnic, port_id);
 
         if (ret < 0) {
-                int free_fp = 1;
-                spin_lock_irqsave(&fnic->fnic_lock, flags);
-                /*
-                 * free the frame is some other thread is not
-                 * pointing to it
-                 */
-                if (fnic->flogi_resp != fp)
-                        free_fp = 0;
-                else
-                        fnic->flogi_resp = NULL;
-
+                spin_lock_irq(&fnic->fnic_lock);
                 if (fnic->state == FNIC_IN_ETH_TRANS_FC_MODE)
                         fnic->state = FNIC_IN_ETH_MODE;
-                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                if (free_fp)
-                        dev_kfree_skb_irq(fp_skb(fp));
+                spin_unlock_irq(&fnic->fnic_lock);
         }
-
- handle_flogi_resp_end:
-        return ret;
-}
-
-/* Returns 1 for a response that matches cached flogi oxid */
-static inline int is_matching_flogi_resp_frame(struct fnic *fnic,
-                                               struct fc_frame *fp)
-{
-        struct fc_frame_header *fh;
-        int ret = 0;
-        u32 f_ctl;
-
-        fh = fc_frame_header_get(fp);
-        f_ctl = ntoh24(fh->fh_f_ctl);
-
-        if (fnic->flogi_oxid == ntohs(fh->fh_ox_id) &&
-            fh->fh_r_ctl == FC_RCTL_ELS_REP &&
-            (f_ctl & (FC_FC_EX_CTX | FC_FC_SEQ_CTX)) == FC_FC_EX_CTX &&
-            fh->fh_type == FC_TYPE_ELS)
-                ret = 1;
-
-        return ret;
 }
 
 static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
@@ -326,6 +312,7 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
         pci_unmap_single(fnic->pdev, buf->dma_addr, buf->len,
                          PCI_DMA_FROMDEVICE);
         skb = buf->os_buf;
+        fp = (struct fc_frame *)skb;
         buf->os_buf = NULL;
 
         cq_desc_dec(cq_desc, &type, &color, &q_number, &completed_index);
@@ -338,6 +325,9 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
                                    &fcoe_enc_error, &fcs_ok, &vlan_stripped,
                                    &vlan);
                 eth_hdrs_stripped = 1;
+                skb_trim(skb, fcp_bytes_written);
+                fr_sof(fp) = sof;
+                fr_eof(fp) = eof;
 
         } else if (type == CQ_DESC_TYPE_RQ_ENET) {
                 cq_enet_rq_desc_dec((struct cq_enet_rq_desc *)cq_desc,
@@ -352,6 +342,14 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
                                     &ipv4_csum_ok, &ipv6, &ipv4,
                                     &ipv4_fragment, &fcs_ok);
                 eth_hdrs_stripped = 0;
+                skb_trim(skb, bytes_written);
+                if (!fcs_ok) {
+                        FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
+                                     "fcs error.  dropping packet.\n");
+                        goto drop;
+                }
+                if (fnic_import_rq_eth_pkt(fnic, skb))
+                        return;
 
         } else {
                 /* wrong CQ type*/
@@ -370,43 +368,11 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
                 goto drop;
         }
 
-        if (eth_hdrs_stripped)
-                fnic_import_rq_fc_frame(skb, fcp_bytes_written, sof, eof);
-        else if (fnic_import_rq_eth_pkt(skb, bytes_written))
-                goto drop;
-
-        fp = (struct fc_frame *)skb;
-
-        /*
-         * If frame is an ELS response that matches the cached FLOGI OX_ID,
-         * and is accept, issue flogi_reg_request copy wq request to firmware
-         * to register the S_ID and determine whether FC_OUI mode or GW mode.
-         */
-        if (is_matching_flogi_resp_frame(fnic, fp)) {
-                if (!eth_hdrs_stripped) {
-                        if (fc_frame_payload_op(fp) == ELS_LS_ACC) {
-                                fnic_handle_flogi_resp(fnic, fp);
-                                return;
-                        }
-                        /*
-                         * Recd. Flogi reject. No point registering
-                         * with fw, but forward to libFC
-                         */
-                        goto forward;
-                }
-                goto drop;
-        }
-        if (!eth_hdrs_stripped)
-                goto drop;
-
-forward:
         spin_lock_irqsave(&fnic->fnic_lock, flags);
         if (fnic->stop_rx_link_events) {
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
                 goto drop;
         }
-        /* Use fr_flags to indicate whether succ. flogi resp or not */
-        fr_flags(fp) = 0;
         fr_dev(fp) = fnic->lport;
         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
@@ -494,12 +460,49 @@ void fnic_free_rq_buf(struct vnic_rq *rq, struct vnic_rq_buf *buf)
         buf->os_buf = NULL;
 }
 
-static inline int is_flogi_frame(struct fc_frame_header *fh)
+/**
+ * fnic_eth_send() - Send Ethernet frame.
+ * @fip:        fcoe_ctlr instance.
+ * @skb:        Ethernet Frame, FIP, without VLAN encapsulation.
+ */
+void fnic_eth_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
 {
-        return fh->fh_r_ctl == FC_RCTL_ELS_REQ && *(u8 *)(fh + 1) == ELS_FLOGI;
+        struct fnic *fnic = fnic_from_ctlr(fip);
+        struct vnic_wq *wq = &fnic->wq[0];
+        dma_addr_t pa;
+        struct ethhdr *eth_hdr;
+        struct vlan_ethhdr *vlan_hdr;
+        unsigned long flags;
+
+        if (!fnic->vlan_hw_insert) {
+                eth_hdr = (struct ethhdr *)skb_mac_header(skb);
+                vlan_hdr = (struct vlan_ethhdr *)skb_push(skb,
+                                sizeof(*vlan_hdr) - sizeof(*eth_hdr));
+                memcpy(vlan_hdr, eth_hdr, 2 * ETH_ALEN);
+                vlan_hdr->h_vlan_proto = htons(ETH_P_8021Q);
+                vlan_hdr->h_vlan_encapsulated_proto = eth_hdr->h_proto;
+                vlan_hdr->h_vlan_TCI = htons(fnic->vlan_id);
+        }
+
+        pa = pci_map_single(fnic->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
+
+        spin_lock_irqsave(&fnic->wq_lock[0], flags);
+        if (!vnic_wq_desc_avail(wq)) {
+                pci_unmap_single(fnic->pdev, pa, skb->len, PCI_DMA_TODEVICE);
+                spin_unlock_irqrestore(&fnic->wq_lock[0], flags);
+                kfree_skb(skb);
+                return;
+        }
+
+        fnic_queue_wq_eth_desc(wq, skb, pa, skb->len,
+                               fnic->vlan_hw_insert, fnic->vlan_id, 1);
+        spin_unlock_irqrestore(&fnic->wq_lock[0], flags);
 }
 
-int fnic_send_frame(struct fnic *fnic, struct fc_frame *fp)
+/*
+ * Send FC frame.
+ */
+static int fnic_send_frame(struct fnic *fnic, struct fc_frame *fp)
 {
         struct vnic_wq *wq = &fnic->wq[0];
         struct sk_buff *skb;
@@ -515,6 +518,10 @@ int fnic_send_frame(struct fnic *fnic, struct fc_frame *fp)
         fh = fc_frame_header_get(fp);
         skb = fp_skb(fp);
 
+        if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ) &&
+            fcoe_ctlr_els_send(&fnic->ctlr, fnic->lport, skb))
+                return 0;
+
         if (!fnic->vlan_hw_insert) {
                 eth_hdr_len = sizeof(*vlan_hdr) + sizeof(*fcoe_hdr);
                 vlan_hdr = (struct vlan_ethhdr *)skb_push(skb, eth_hdr_len);
@@ -530,16 +537,11 @@ int fnic_send_frame(struct fnic *fnic, struct fc_frame *fp)
                 fcoe_hdr = (struct fcoe_hdr *)(eth_hdr + 1);
         }
 
-        if (is_flogi_frame(fh)) {
+        if (fnic->ctlr.map_dest)
                 fc_fcoe_set_mac(eth_hdr->h_dest, fh->fh_d_id);
-                memcpy(eth_hdr->h_source, fnic->mac_addr, ETH_ALEN);
-        } else {
-                if (fnic->fcoui_mode)
-                        fc_fcoe_set_mac(eth_hdr->h_dest, fh->fh_d_id);
-                else
-                        memcpy(eth_hdr->h_dest, fnic->dest_addr, ETH_ALEN);
-                memcpy(eth_hdr->h_source, fnic->data_src_addr, ETH_ALEN);
-        }
+        else
+                memcpy(eth_hdr->h_dest, fnic->ctlr.dest_addr, ETH_ALEN);
+        memcpy(eth_hdr->h_source, fnic->data_src_addr, ETH_ALEN);
 
         tot_len = skb->len;
         BUG_ON(tot_len % 4);
@@ -578,109 +580,85 @@ fnic_send_frame_end:
 int fnic_send(struct fc_lport *lp, struct fc_frame *fp)
 {
         struct fnic *fnic = lport_priv(lp);
-        struct fc_frame_header *fh;
-        int ret = 0;
-        enum fnic_state old_state;
         unsigned long flags;
-        struct fc_frame *old_flogi = NULL;
-        struct fc_frame *old_flogi_resp = NULL;
 
         if (fnic->in_remove) {
                 dev_kfree_skb(fp_skb(fp));
-                ret = -1;
-                goto fnic_send_end;
+                return -1;
         }
 
-        fh = fc_frame_header_get(fp);
-        /* if not an Flogi frame, send it out, this is the common case */
-        if (!is_flogi_frame(fh))
-                return fnic_send_frame(fnic, fp);
+        /*
+         * Queue frame if in a transitional state.
+         * This occurs while registering the Port_ID / MAC address after FLOGI.
+         */
+        spin_lock_irqsave(&fnic->fnic_lock, flags);
+        if (fnic->state != FNIC_IN_FC_MODE && fnic->state != FNIC_IN_ETH_MODE) {
+                skb_queue_tail(&fnic->tx_queue, fp_skb(fp));
+                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                return 0;
+        }
+        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
-        /* Flogi frame, now enter the state machine */
+        return fnic_send_frame(fnic, fp);
+}
 
-        spin_lock_irqsave(&fnic->fnic_lock, flags);
-again:
-        /* Get any old cached frames, free them after dropping lock */
-        old_flogi = fnic->flogi;
-        fnic->flogi = NULL;
-        old_flogi_resp = fnic->flogi_resp;
-        fnic->flogi_resp = NULL;
+/**
+ * fnic_flush_tx() - send queued frames.
+ * @fnic: fnic device
+ *
+ * Send frames that were waiting to go out in FC or Ethernet mode.
+ * Whenever changing modes we purge queued frames, so these frames should
+ * be queued for the stable mode that we're in, either FC or Ethernet.
+ *
+ * Called without fnic_lock held.
+ */
+void fnic_flush_tx(struct fnic *fnic)
+{
+        struct sk_buff *skb;
+        struct fc_frame *fp;
 
-        fnic->flogi_oxid = FC_XID_UNKNOWN;
+        while ((skb = skb_dequeue(&fnic->frame_queue))) {
+                fp = (struct fc_frame *)skb;
+                fnic_send_frame(fnic, fp);
+        }
+}
 
+/**
+ * fnic_set_eth_mode() - put fnic into ethernet mode.
+ * @fnic: fnic device
+ *
+ * Called without fnic lock held.
+ */
+static void fnic_set_eth_mode(struct fnic *fnic)
+{
+        unsigned long flags;
+        enum fnic_state old_state;
+        int ret;
+
+        spin_lock_irqsave(&fnic->fnic_lock, flags);
+again:
         old_state = fnic->state;
         switch (old_state) {
         case FNIC_IN_FC_MODE:
         case FNIC_IN_ETH_TRANS_FC_MODE:
         default:
                 fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;
-                vnic_dev_del_addr(fnic->vdev, fnic->data_src_addr);
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
-                if (old_flogi) {
-                        dev_kfree_skb(fp_skb(old_flogi));
-                        old_flogi = NULL;
-                }
-                if (old_flogi_resp) {
-                        dev_kfree_skb(fp_skb(old_flogi_resp));
-                        old_flogi_resp = NULL;
-                }
-
                 ret = fnic_fw_reset_handler(fnic);
 
                 spin_lock_irqsave(&fnic->fnic_lock, flags);
                 if (fnic->state != FNIC_IN_FC_TRANS_ETH_MODE)
                         goto again;
-                if (ret) {
+                if (ret)
                         fnic->state = old_state;
-                        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                        dev_kfree_skb(fp_skb(fp));
-                        goto fnic_send_end;
-                }
-                old_flogi = fnic->flogi;
-                fnic->flogi = fp;
-                fnic->flogi_oxid = ntohs(fh->fh_ox_id);
-                old_flogi_resp = fnic->flogi_resp;
-                fnic->flogi_resp = NULL;
-                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
                 break;
 
         case FNIC_IN_FC_TRANS_ETH_MODE:
-                /*
-                 * A reset is pending with the firmware. Store the flogi
-                 * and its oxid. The transition out of this state happens
-                 * only when Firmware completes the reset, either with
-                 * success or failed. If success, transition to
-                 * FNIC_IN_ETH_MODE, if fail, then transition to
-                 * FNIC_IN_FC_MODE
-                 */
-                fnic->flogi = fp;
-                fnic->flogi_oxid = ntohs(fh->fh_ox_id);
-                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                break;
-
         case FNIC_IN_ETH_MODE:
-                /*
-                 * The fw/hw is already in eth mode. Store the oxid,
-                 * and send the flogi frame out. The transition out of this
-                 * state happens only we receive flogi response from the
-                 * network, and the oxid matches the cached oxid when the
-                 * flogi frame was sent out. If they match, then we issue
-                 * a flogi_reg request and transition to state
-                 * FNIC_IN_ETH_TRANS_FC_MODE
-                 */
-                fnic->flogi_oxid = ntohs(fh->fh_ox_id);
-                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                ret = fnic_send_frame(fnic, fp);
                 break;
         }
-
-fnic_send_end:
-        if (old_flogi)
-                dev_kfree_skb(fp_skb(old_flogi));
-        if (old_flogi_resp)
-                dev_kfree_skb(fp_skb(old_flogi_resp));
-        return ret;
+        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 }
 
 static void fnic_wq_complete_frame_send(struct vnic_wq *wq,
diff --git a/drivers/scsi/fnic/fnic_isr.c b/drivers/scsi/fnic/fnic_isr.c
index 2b3064828aea..5c1f223cabce 100644
--- a/drivers/scsi/fnic/fnic_isr.c
+++ b/drivers/scsi/fnic/fnic_isr.c
@@ -48,9 +48,9 @@ static irqreturn_t fnic_isr_legacy(int irq, void *data)
         }
 
         if (pba & (1 << FNIC_INTX_WQ_RQ_COPYWQ)) {
-                work_done += fnic_wq_copy_cmpl_handler(fnic, 8);
-                work_done += fnic_wq_cmpl_handler(fnic, 4);
-                work_done += fnic_rq_cmpl_handler(fnic, 4);
+                work_done += fnic_wq_copy_cmpl_handler(fnic, -1);
+                work_done += fnic_wq_cmpl_handler(fnic, -1);
+                work_done += fnic_rq_cmpl_handler(fnic, -1);
 
                 vnic_intr_return_credits(&fnic->intr[FNIC_INTX_WQ_RQ_COPYWQ],
                                          work_done,
@@ -66,9 +66,9 @@ static irqreturn_t fnic_isr_msi(int irq, void *data)
         struct fnic *fnic = data;
         unsigned long work_done = 0;
 
-        work_done += fnic_wq_copy_cmpl_handler(fnic, 8);
-        work_done += fnic_wq_cmpl_handler(fnic, 4);
-        work_done += fnic_rq_cmpl_handler(fnic, 4);
+        work_done += fnic_wq_copy_cmpl_handler(fnic, -1);
+        work_done += fnic_wq_cmpl_handler(fnic, -1);
+        work_done += fnic_rq_cmpl_handler(fnic, -1);
 
         vnic_intr_return_credits(&fnic->intr[0],
                                  work_done,
@@ -83,7 +83,7 @@ static irqreturn_t fnic_isr_msix_rq(int irq, void *data)
         struct fnic *fnic = data;
         unsigned long rq_work_done = 0;
 
-        rq_work_done = fnic_rq_cmpl_handler(fnic, 4);
+        rq_work_done = fnic_rq_cmpl_handler(fnic, -1);
         vnic_intr_return_credits(&fnic->intr[FNIC_MSIX_RQ],
                                  rq_work_done,
                                  1 /* unmask intr */,
@@ -97,7 +97,7 @@ static irqreturn_t fnic_isr_msix_wq(int irq, void *data)
         struct fnic *fnic = data;
         unsigned long wq_work_done = 0;
 
-        wq_work_done = fnic_wq_cmpl_handler(fnic, 4);
+        wq_work_done = fnic_wq_cmpl_handler(fnic, -1);
         vnic_intr_return_credits(&fnic->intr[FNIC_MSIX_WQ],
                                  wq_work_done,
                                  1 /* unmask intr */,
@@ -110,7 +110,7 @@ static irqreturn_t fnic_isr_msix_wq_copy(int irq, void *data)
         struct fnic *fnic = data;
         unsigned long wq_copy_work_done = 0;
 
-        wq_copy_work_done = fnic_wq_copy_cmpl_handler(fnic, 8);
+        wq_copy_work_done = fnic_wq_copy_cmpl_handler(fnic, -1);
         vnic_intr_return_credits(&fnic->intr[FNIC_MSIX_WQ_COPY],
                                  wq_copy_work_done,
                                  1 /* unmask intr */,
diff --git a/drivers/scsi/fnic/fnic_main.c b/drivers/scsi/fnic/fnic_main.c
index 71c7bbe26d05..97b212570bcc 100644
--- a/drivers/scsi/fnic/fnic_main.c
+++ b/drivers/scsi/fnic/fnic_main.c
@@ -18,6 +18,7 @@
 #include <linux/module.h>
 #include <linux/mempool.h>
 #include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/pci.h>
@@ -25,6 +26,8 @@
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
+#include <linux/if_ether.h>
+#include <scsi/fc/fc_fip.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_transport.h>
 #include <scsi/scsi_transport_fc.h>
@@ -68,6 +71,7 @@ MODULE_PARM_DESC(fnic_log_level, "bit mask of fnic logging levels");
 
 static struct libfc_function_template fnic_transport_template = {
         .frame_send = fnic_send,
+        .lport_set_port_id = fnic_set_port_id,
         .fcp_abort_io = fnic_empty_scsi_cleanup,
         .fcp_cleanup = fnic_empty_scsi_cleanup,
         .exch_mgr_reset = fnic_exch_mgr_reset
@@ -140,6 +144,7 @@ static struct fc_function_template fnic_fc_functions = {
         .get_fc_host_stats = fnic_get_stats,
         .dd_fcrport_size = sizeof(struct fc_rport_libfc_priv),
         .terminate_rport_io = fnic_terminate_rport_io,
+        .bsg_request = fc_lport_bsg_request,
 };
 
 static void fnic_get_host_speed(struct Scsi_Host *shost)
@@ -324,9 +329,6 @@ static int fnic_cleanup(struct fnic *fnic)
 {
         unsigned int i;
         int err;
-        unsigned long flags;
-        struct fc_frame *flogi = NULL;
-        struct fc_frame *flogi_resp = NULL;
 
         vnic_dev_disable(fnic->vdev);
         for (i = 0; i < fnic->intr_count; i++)
@@ -367,24 +369,6 @@ static int fnic_cleanup(struct fnic *fnic)
         for (i = 0; i < fnic->intr_count; i++)
                 vnic_intr_clean(&fnic->intr[i]);
 
-        /*
-         * Remove cached flogi and flogi resp frames if any
-         * These frames are not in any queue, and therefore queue
-         * cleanup does not clean them. So clean them explicitly
-         */
-        spin_lock_irqsave(&fnic->fnic_lock, flags);
-        flogi = fnic->flogi;
-        fnic->flogi = NULL;
-        flogi_resp = fnic->flogi_resp;
-        fnic->flogi_resp = NULL;
-        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-
-        if (flogi)
-                dev_kfree_skb(fp_skb(flogi));
-
-        if (flogi_resp)
-                dev_kfree_skb(fp_skb(flogi_resp));
-
         mempool_destroy(fnic->io_req_pool);
         for (i = 0; i < FNIC_SGL_NUM_CACHES; i++)
                 mempool_destroy(fnic->io_sgl_pool[i]);
@@ -409,6 +393,17 @@ static void *fnic_alloc_slab_dma(gfp_t gfp_mask, void *pool_data)
         return kmem_cache_alloc(mem, gfp_mask | GFP_ATOMIC | GFP_DMA);
 }
 
+/**
+ * fnic_get_mac() - get assigned data MAC address for FIP code.
+ * @lport:      local port.
+ */
+static u8 *fnic_get_mac(struct fc_lport *lport)
+{
+        struct fnic *fnic = lport_priv(lport);
+
+        return fnic->data_src_addr;
+}
+
 static int __devinit fnic_probe(struct pci_dev *pdev,
                                 const struct pci_device_id *ent)
 {
@@ -424,17 +419,16 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
          * Allocate SCSI Host and set up association between host,
          * local port, and fnic
          */
-        host = scsi_host_alloc(&fnic_host_template,
-                               sizeof(struct fc_lport) + sizeof(struct fnic));
-        if (!host) {
-                printk(KERN_ERR PFX "Unable to alloc SCSI host\n");
+        lp = libfc_host_alloc(&fnic_host_template, sizeof(struct fnic));
+        if (!lp) {
+                printk(KERN_ERR PFX "Unable to alloc libfc local port\n");
                 err = -ENOMEM;
                 goto err_out;
         }
-        lp = shost_priv(host);
-        lp->host = host;
+        host = lp->host;
         fnic = lport_priv(lp);
         fnic->lport = lp;
+        fnic->ctlr.lp = lp;
 
         snprintf(fnic->name, sizeof(fnic->name) - 1, "%s%d", DRV_NAME,
                  host->host_no);
@@ -543,12 +537,14 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
                 goto err_out_dev_close;
         }
 
-        err = vnic_dev_mac_addr(fnic->vdev, fnic->mac_addr);
+        err = vnic_dev_mac_addr(fnic->vdev, fnic->ctlr.ctl_src_addr);
         if (err) {
                 shost_printk(KERN_ERR, fnic->lport->host,
                              "vNIC get MAC addr failed \n");
                 goto err_out_dev_close;
         }
+        /* set data_src for point-to-point mode and to keep it non-zero */
+        memcpy(fnic->data_src_addr, fnic->ctlr.ctl_src_addr, ETH_ALEN);
 
         /* Get vNIC configuration */
         err = fnic_get_vnic_config(fnic);
@@ -560,6 +556,7 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
         }
         host->max_lun = fnic->config.luns_per_tgt;
         host->max_id = FNIC_MAX_FCP_TARGET;
+        host->max_cmd_len = FNIC_MAX_CMD_LEN;
 
         fnic_get_res_counts(fnic);
 
@@ -571,19 +568,12 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
                 goto err_out_dev_close;
         }
 
-        err = fnic_request_intr(fnic);
-        if (err) {
-                shost_printk(KERN_ERR, fnic->lport->host,
-                             "Unable to request irq.\n");
-                goto err_out_clear_intr;
-        }
-
         err = fnic_alloc_vnic_resources(fnic);
         if (err) {
                 shost_printk(KERN_ERR, fnic->lport->host,
                              "Failed to alloc vNIC resources, "
                              "aborting.\n");
-                goto err_out_free_intr;
+                goto err_out_clear_intr;
         }
 
 
@@ -623,9 +613,23 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
         fnic->vlan_hw_insert = 1;
         fnic->vlan_id = 0;
 
-        fnic->flogi_oxid = FC_XID_UNKNOWN;
-        fnic->flogi = NULL;
-        fnic->flogi_resp = NULL;
+        /* Initialize the FIP fcoe_ctrl struct */
+        fnic->ctlr.send = fnic_eth_send;
+        fnic->ctlr.update_mac = fnic_update_mac;
+        fnic->ctlr.get_src_addr = fnic_get_mac;
+        fcoe_ctlr_init(&fnic->ctlr);
+        if (fnic->config.flags & VFCF_FIP_CAPABLE) {
+                shost_printk(KERN_INFO, fnic->lport->host,
+                             "firmware supports FIP\n");
+                /* enable directed and multicast */
+                vnic_dev_packet_filter(fnic->vdev, 1, 1, 0, 0, 0);
+                vnic_dev_add_addr(fnic->vdev, FIP_ALL_ENODE_MACS);
+                vnic_dev_add_addr(fnic->vdev, fnic->ctlr.ctl_src_addr);
+        } else {
+                shost_printk(KERN_INFO, fnic->lport->host,
+                             "firmware uses non-FIP mode\n");
+                fnic->ctlr.mode = FIP_ST_NON_FIP;
+        }
         fnic->state = FNIC_IN_FC_MODE;
 
         /* Enable hardware stripping of vlan header on ingress */
@@ -697,6 +701,8 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
                 goto err_out_remove_scsi_host;
         }
 
+        fc_lport_init_stats(lp);
+
         fc_lport_config(lp);
 
         if (fc_set_mfs(lp, fnic->config.maxdatafieldsize +
@@ -716,6 +722,7 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
         INIT_WORK(&fnic->link_work, fnic_handle_link);
         INIT_WORK(&fnic->frame_work, fnic_handle_frame);
         skb_queue_head_init(&fnic->frame_queue);
+        skb_queue_head_init(&fnic->tx_queue);
 
         /* Enable all queues */
         for (i = 0; i < fnic->raw_wq_count; i++)
@@ -728,6 +735,14 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
         fc_fabric_login(lp);
 
         vnic_dev_enable(fnic->vdev);
+
+        err = fnic_request_intr(fnic);
+        if (err) {
+                shost_printk(KERN_ERR, fnic->lport->host,
+                             "Unable to request irq.\n");
+                goto err_out_free_exch_mgr;
+        }
+
         for (i = 0; i < fnic->intr_count; i++)
                 vnic_intr_unmask(&fnic->intr[i]);
 
@@ -738,8 +753,8 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
 err_out_free_exch_mgr:
         fc_exch_mgr_free(lp);
 err_out_remove_scsi_host:
-        fc_remove_host(fnic->lport->host);
-        scsi_remove_host(fnic->lport->host);
+        fc_remove_host(lp->host);
+        scsi_remove_host(lp->host);
 err_out_free_rq_buf:
         for (i = 0; i < fnic->rq_count; i++)
                 vnic_rq_clean(&fnic->rq[i], fnic_free_rq_buf);
@@ -752,8 +767,6 @@ err_out_free_ioreq_pool:
         mempool_destroy(fnic->io_req_pool);
 err_out_free_resources:
         fnic_free_vnic_resources(fnic);
-err_out_free_intr:
-        fnic_free_intr(fnic);
 err_out_clear_intr:
         fnic_clear_intr_mode(fnic);
 err_out_dev_close:
@@ -775,6 +788,7 @@ err_out:
 static void __devexit fnic_remove(struct pci_dev *pdev)
 {
         struct fnic *fnic = pci_get_drvdata(pdev);
+        struct fc_lport *lp = fnic->lport;
         unsigned long flags;
 
         /*
@@ -796,6 +810,7 @@ static void __devexit fnic_remove(struct pci_dev *pdev)
          */
         flush_workqueue(fnic_event_queue);
         skb_queue_purge(&fnic->frame_queue);
+        skb_queue_purge(&fnic->tx_queue);
 
         /*
          * Log off the fabric. This stops all remote ports, dns port,
@@ -808,7 +823,8 @@ static void __devexit fnic_remove(struct pci_dev *pdev)
         fnic->in_remove = 1;
         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
-        fc_lport_destroy(fnic->lport);
+        fcoe_ctlr_destroy(&fnic->ctlr);
+        fc_lport_destroy(lp);
 
         /*
          * This stops the fnic device, masks all interrupts. Completed
@@ -818,6 +834,7 @@ static void __devexit fnic_remove(struct pci_dev *pdev)
         fnic_cleanup(fnic);
 
         BUG_ON(!skb_queue_empty(&fnic->frame_queue));
+        BUG_ON(!skb_queue_empty(&fnic->tx_queue));
 
         spin_lock_irqsave(&fnic_list_lock, flags);
         list_del(&fnic->list);
@@ -827,8 +844,8 @@ static void __devexit fnic_remove(struct pci_dev *pdev)
         scsi_remove_host(fnic->lport->host);
         fc_exch_mgr_free(fnic->lport);
         vnic_dev_notify_unset(fnic->vdev);
-        fnic_free_vnic_resources(fnic);
         fnic_free_intr(fnic);
+        fnic_free_vnic_resources(fnic);
         fnic_clear_intr_mode(fnic);
         vnic_dev_close(fnic->vdev);
         vnic_dev_unregister(fnic->vdev);
@@ -836,7 +853,7 @@ static void __devexit fnic_remove(struct pci_dev *pdev)
         pci_release_regions(pdev);
         pci_disable_device(pdev);
         pci_set_drvdata(pdev, NULL);
-        scsi_host_put(fnic->lport->host);
+        scsi_host_put(lp->host);
 }
 
 static struct pci_driver fnic_driver = {
diff --git a/drivers/scsi/fnic/fnic_res.c b/drivers/scsi/fnic/fnic_res.c
index 7ba61ec715d2..50488f8e169d 100644
--- a/drivers/scsi/fnic/fnic_res.c
+++ b/drivers/scsi/fnic/fnic_res.c
@@ -144,10 +144,9 @@ int fnic_get_vnic_config(struct fnic *fnic)
         c->intr_timer_type = c->intr_timer_type;
 
         shost_printk(KERN_INFO, fnic->lport->host,
-                     "vNIC MAC addr %02x:%02x:%02x:%02x:%02x:%02x "
+                     "vNIC MAC addr %pM "
                      "wq/wq_copy/rq %d/%d/%d\n",
-                     fnic->mac_addr[0], fnic->mac_addr[1], fnic->mac_addr[2],
-                     fnic->mac_addr[3], fnic->mac_addr[4], fnic->mac_addr[5],
+                     fnic->ctlr.ctl_src_addr,
                      c->wq_enet_desc_count, c->wq_copy_desc_count,
                      c->rq_desc_count);
         shost_printk(KERN_INFO, fnic->lport->host,
diff --git a/drivers/scsi/fnic/fnic_res.h b/drivers/scsi/fnic/fnic_res.h
index b6f310262534..ef8aaf2156dd 100644
--- a/drivers/scsi/fnic/fnic_res.h
+++ b/drivers/scsi/fnic/fnic_res.h
@@ -51,6 +51,31 @@ static inline void fnic_queue_wq_desc(struct vnic_wq *wq,
         vnic_wq_post(wq, os_buf, dma_addr, len, sop, eop);
 }
 
+static inline void fnic_queue_wq_eth_desc(struct vnic_wq *wq,
+                                      void *os_buf, dma_addr_t dma_addr,
+                                      unsigned int len,
+                                      int vlan_tag_insert,
+                                      unsigned int vlan_tag,
+                                      int cq_entry)
+{
+        struct wq_enet_desc *desc = vnic_wq_next_desc(wq);
+
+        wq_enet_desc_enc(desc,
+                         (u64)dma_addr | VNIC_PADDR_TARGET,
+                         (u16)len,
+                         0, /* mss_or_csum_offset */
+                         0, /* fc_eof */
+                         0, /* offload_mode */
+                         1, /* eop */
+                         (u8)cq_entry,
+                         0, /* fcoe_encap */
+                         (u8)vlan_tag_insert,
+                         (u16)vlan_tag,
+                         0 /* loopback */);
+
+        vnic_wq_post(wq, os_buf, dma_addr, len, 1, 1);
+}
+
 static inline void fnic_queue_wq_copy_desc_icmnd_16(struct vnic_wq_copy *wq,
                                                     u32 req_id,
                                                     u32 lunmap_id, u8 spl_flags,
@@ -58,6 +83,7 @@ static inline void fnic_queue_wq_copy_desc_icmnd_16(struct vnic_wq_copy *wq,
                                                     u64 sgl_addr, u64 sns_addr,
                                                     u8 crn, u8 pri_ta,
                                                     u8 flags, u8 *scsi_cdb,
+                                                    u8 cdb_len,
                                                     u32 data_len, u8 *lun,
                                                     u32 d_id, u16 mss,
                                                     u32 ratov, u32 edtov)
@@ -82,7 +108,8 @@ static inline void fnic_queue_wq_copy_desc_icmnd_16(struct vnic_wq_copy *wq,
         desc->u.icmnd_16.pri_ta = pri_ta;       /* SCSI Pri & Task attribute */
         desc->u.icmnd_16._resvd1 = 0;           /* reserved: should be 0 */
         desc->u.icmnd_16.flags = flags;         /* command flags */
-        memcpy(desc->u.icmnd_16.scsi_cdb, scsi_cdb, CDB_16);    /* SCSI CDB */
+        memset(desc->u.icmnd_16.scsi_cdb, 0, CDB_16);
+        memcpy(desc->u.icmnd_16.scsi_cdb, scsi_cdb, cdb_len);    /* SCSI CDB */
         desc->u.icmnd_16.data_len = data_len;   /* length of data expected */
         memcpy(desc->u.icmnd_16.lun, lun, LUN_ADDRESS);  /* LUN address */
         desc->u.icmnd_16._resvd2 = 0;           /* reserved */
@@ -132,12 +159,37 @@ static inline void fnic_queue_wq_copy_desc_flogi_reg(struct vnic_wq_copy *wq,
         desc->hdr.tag.u.req_id = req_id;      /* id for this request */
 
         desc->u.flogi_reg.format = format;
+        desc->u.flogi_reg._resvd = 0;
         hton24(desc->u.flogi_reg.s_id, s_id);
         memcpy(desc->u.flogi_reg.gateway_mac, gw_mac, ETH_ALEN);
 
         vnic_wq_copy_post(wq);
 }
 
+static inline void fnic_queue_wq_copy_desc_fip_reg(struct vnic_wq_copy *wq,
+                                                   u32 req_id, u32 s_id,
+                                                   u8 *fcf_mac, u8 *ha_mac,
+                                                   u32 r_a_tov, u32 e_d_tov)
+{
+        struct fcpio_host_req *desc = vnic_wq_copy_next_desc(wq);
+
+        desc->hdr.type = FCPIO_FLOGI_FIP_REG; /* enum fcpio_type */
+        desc->hdr.status = 0;                 /* header status entry */
+        desc->hdr._resvd = 0;                 /* reserved */
+        desc->hdr.tag.u.req_id = req_id;      /* id for this request */
+
+        desc->u.flogi_fip_reg._resvd0 = 0;
+        hton24(desc->u.flogi_fip_reg.s_id, s_id);
+        memcpy(desc->u.flogi_fip_reg.fcf_mac, fcf_mac, ETH_ALEN);
+        desc->u.flogi_fip_reg._resvd1 = 0;
+        desc->u.flogi_fip_reg.r_a_tov = r_a_tov;
+        desc->u.flogi_fip_reg.e_d_tov = e_d_tov;
+        memcpy(desc->u.flogi_fip_reg.ha_mac, ha_mac, ETH_ALEN);
+        desc->u.flogi_fip_reg._resvd2 = 0;
+
+        vnic_wq_copy_post(wq);
+}
+
 static inline void fnic_queue_wq_copy_desc_fw_reset(struct vnic_wq_copy *wq,
                                                     u32 req_id)
 {
diff --git a/drivers/scsi/fnic/fnic_scsi.c b/drivers/scsi/fnic/fnic_scsi.c
index bfc996971b81..3cc47c6e1ada 100644
--- a/drivers/scsi/fnic/fnic_scsi.c
+++ b/drivers/scsi/fnic/fnic_scsi.c
@@ -26,6 +26,7 @@
 #include <linux/if_ether.h>
 #include <linux/if_vlan.h>
 #include <linux/delay.h>
+#include <linux/gfp.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
@@ -174,6 +175,9 @@ int fnic_fw_reset_handler(struct fnic *fnic)
         int ret = 0;
         unsigned long flags;
 
+        skb_queue_purge(&fnic->frame_queue);
+        skb_queue_purge(&fnic->tx_queue);
+
         spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
 
         if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
@@ -200,9 +204,11 @@ int fnic_fw_reset_handler(struct fnic *fnic)
  * fnic_flogi_reg_handler
  * Routine to send flogi register msg to fw
  */
-int fnic_flogi_reg_handler(struct fnic *fnic)
+int fnic_flogi_reg_handler(struct fnic *fnic, u32 fc_id)
 {
         struct vnic_wq_copy *wq = &fnic->wq_copy[0];
+        enum fcpio_flogi_reg_format_type format;
+        struct fc_lport *lp = fnic->lport;
         u8 gw_mac[ETH_ALEN];
         int ret = 0;
         unsigned long flags;
@@ -217,23 +223,32 @@ int fnic_flogi_reg_handler(struct fnic *fnic)
                 goto flogi_reg_ioreq_end;
         }
 
-        if (fnic->fcoui_mode)
+        if (fnic->ctlr.map_dest) {
                 memset(gw_mac, 0xff, ETH_ALEN);
-        else
-                memcpy(gw_mac, fnic->dest_addr, ETH_ALEN);
+                format = FCPIO_FLOGI_REG_DEF_DEST;
+        } else {
+                memcpy(gw_mac, fnic->ctlr.dest_addr, ETH_ALEN);
+                format = FCPIO_FLOGI_REG_GW_DEST;
+        }
 
-        fnic_queue_wq_copy_desc_flogi_reg(wq, SCSI_NO_TAG,
-                                          FCPIO_FLOGI_REG_GW_DEST,
-                                          fnic->s_id,
-                                          gw_mac);
+        if ((fnic->config.flags & VFCF_FIP_CAPABLE) && !fnic->ctlr.map_dest) {
+                fnic_queue_wq_copy_desc_fip_reg(wq, SCSI_NO_TAG,
+                                                fc_id, gw_mac,
+                                                fnic->data_src_addr,
+                                                lp->r_a_tov, lp->e_d_tov);
+                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
+                              "FLOGI FIP reg issued fcid %x src %pM dest %pM\n",
+                              fc_id, fnic->data_src_addr, gw_mac);
+        } else {
+                fnic_queue_wq_copy_desc_flogi_reg(wq, SCSI_NO_TAG,
+                                                  format, fc_id, gw_mac);
+                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
+                              "FLOGI reg issued fcid %x map %d dest %pM\n",
+                              fc_id, fnic->ctlr.map_dest, gw_mac);
+        }
 
 flogi_reg_ioreq_end:
         spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
-
-        if (!ret)
-                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
-                              "flog reg issued\n");
-
         return ret;
 }
 
@@ -319,7 +334,8 @@ static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
                                          0, /* scsi cmd ref, always 0 */
                                          pri_tag, /* scsi pri and tag */
                                          flags, /* command flags */
-                                         sc->cmnd, scsi_bufflen(sc),
+                                         sc->cmnd, sc->cmd_len,
+                                         scsi_bufflen(sc),
                                          fc_lun.scsi_lun, io_req->port_id,
                                          rport->maxframe_size, rp->r_a_tov,
                                          rp->e_d_tov);
@@ -452,7 +468,6 @@ static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic *fnic,
         u8 hdr_status;
         struct fcpio_tag tag;
         int ret = 0;
-        struct fc_frame *flogi;
         unsigned long flags;
 
         fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
@@ -462,9 +477,6 @@ static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic *fnic,
 
         spin_lock_irqsave(&fnic->fnic_lock, flags);
 
-        flogi = fnic->flogi;
-        fnic->flogi = NULL;
-
         /* fnic should be in FC_TRANS_ETH_MODE */
         if (fnic->state == FNIC_IN_FC_TRANS_ETH_MODE) {
                 /* Check status of reset completion */
@@ -505,17 +517,14 @@ static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic *fnic,
          * free the flogi frame. Else, send it out
          */
         if (fnic->remove_wait || ret) {
-                fnic->flogi_oxid = FC_XID_UNKNOWN;
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                if (flogi)
-                        dev_kfree_skb_irq(fp_skb(flogi));
+                skb_queue_purge(&fnic->tx_queue);
                 goto reset_cmpl_handler_end;
         }
 
         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
-        if (flogi)
-                ret = fnic_send_frame(fnic, flogi);
+        fnic_flush_tx(fnic);
 
  reset_cmpl_handler_end:
         return ret;
@@ -532,18 +541,13 @@ static int fnic_fcpio_flogi_reg_cmpl_handler(struct fnic *fnic,
         u8 hdr_status;
         struct fcpio_tag tag;
         int ret = 0;
-        struct fc_frame *flogi_resp = NULL;
         unsigned long flags;
-        struct sk_buff *skb;
 
         fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
 
         /* Update fnic state based on status of flogi reg completion */
         spin_lock_irqsave(&fnic->fnic_lock, flags);
 
-        flogi_resp = fnic->flogi_resp;
-        fnic->flogi_resp = NULL;
-
         if (fnic->state == FNIC_IN_ETH_TRANS_FC_MODE) {
 
                 /* Check flogi registration completion status */
@@ -567,25 +571,17 @@ static int fnic_fcpio_flogi_reg_cmpl_handler(struct fnic *fnic,
                 ret = -1;
         }
 
-        /* Successful flogi reg cmpl, pass frame to LibFC */
-        if (!ret && flogi_resp) {
+        if (!ret) {
                 if (fnic->stop_rx_link_events) {
                         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
                         goto reg_cmpl_handler_end;
                 }
-                skb = (struct sk_buff *)flogi_resp;
-                /* Use fr_flags to indicate whether flogi resp or not */
-                fr_flags(flogi_resp) = 1;
-                fr_dev(flogi_resp) = fnic->lport;
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
-                skb_queue_tail(&fnic->frame_queue, skb);
+                fnic_flush_tx(fnic);
                 queue_work(fnic_event_queue, &fnic->frame_work);
-
         } else {
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                if (flogi_resp)
-                        dev_kfree_skb_irq(fp_skb(flogi_resp));
         }
 
 reg_cmpl_handler_end:
@@ -907,6 +903,7 @@ static int fnic_fcpio_cmpl_handler(struct vnic_dev *vdev,
                 break;
 
         case FCPIO_FLOGI_REG_CMPL: /* fw completed flogi_reg */
+        case FCPIO_FLOGI_FIP_REG_CMPL: /* fw completed flogi_fip_reg */
                 ret = fnic_fcpio_flogi_reg_cmpl_handler(fnic, desc);
                 break;
 
@@ -1224,22 +1221,6 @@ void fnic_terminate_rport_io(struct fc_rport *rport)
 
 }
 
-static void fnic_block_error_handler(struct scsi_cmnd *sc)
-{
-        struct Scsi_Host *shost = sc->device->host;
-        struct fc_rport *rport = starget_to_rport(scsi_target(sc->device));
-        unsigned long flags;
-
-        spin_lock_irqsave(shost->host_lock, flags);
-        while (rport->port_state == FC_PORTSTATE_BLOCKED) {
-                spin_unlock_irqrestore(shost->host_lock, flags);
-                msleep(1000);
-                spin_lock_irqsave(shost->host_lock, flags);
-        }
-        spin_unlock_irqrestore(shost->host_lock, flags);
-
-}
-
 /*
  * This function is exported to SCSI for sending abort cmnds.
  * A SCSI IO is represented by a io_req in the driver.
@@ -1259,7 +1240,7 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
         DECLARE_COMPLETION_ONSTACK(tm_done);
 
         /* Wait for rport to unblock */
-        fnic_block_error_handler(sc);
+        fc_block_scsi_eh(sc);
 
         /* Get local-port, check ready and link up */
         lp = shost_priv(sc->device->host);
@@ -1541,7 +1522,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
         DECLARE_COMPLETION_ONSTACK(tm_done);
 
         /* Wait for rport to unblock */
-        fnic_block_error_handler(sc);
+        fc_block_scsi_eh(sc);
 
         /* Get local-port, check ready and link up */
         lp = shost_priv(sc->device->host);
@@ -1762,7 +1743,7 @@ void fnic_scsi_abort_io(struct fc_lport *lp)
         fnic->remove_wait = &remove_wait;
         old_state = fnic->state;
         fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;
-        vnic_dev_del_addr(fnic->vdev, fnic->data_src_addr);
+        fnic_update_mac_locked(fnic, fnic->ctlr.ctl_src_addr);
         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
         err = fnic_fw_reset_handler(fnic);
@@ -1802,7 +1783,7 @@ void fnic_scsi_cleanup(struct fc_lport *lp)
         spin_lock_irqsave(&fnic->fnic_lock, flags);
         old_state = fnic->state;
         fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;
-        vnic_dev_del_addr(fnic->vdev, fnic->data_src_addr);
+        fnic_update_mac_locked(fnic, fnic->ctlr.ctl_src_addr);
         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
         if (fnic_fw_reset_handler(fnic)) {
diff --git a/drivers/scsi/fnic/vnic_dev.c b/drivers/scsi/fnic/vnic_dev.c
index 566770645086..db710148d156 100644
--- a/drivers/scsi/fnic/vnic_dev.c
+++ b/drivers/scsi/fnic/vnic_dev.c
@@ -22,6 +22,7 @@
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/if_ether.h>
+#include <linux/slab.h>
 #include "vnic_resource.h"
 #include "vnic_devcmd.h"
 #include "vnic_dev.h"
diff --git a/drivers/scsi/fnic/vnic_devcmd.h b/drivers/scsi/fnic/vnic_devcmd.h
index d62b9061bf12..7c9ccbd4134b 100644
--- a/drivers/scsi/fnic/vnic_devcmd.h
+++ b/drivers/scsi/fnic/vnic_devcmd.h
@@ -94,7 +94,7 @@ enum vnic_devcmd_cmd {
         CMD_STATS_DUMP          = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 4),
 
         /* set Rx packet filter: (u32)a0=filters (see CMD_PFILTER_*) */
-        CMD_PACKET_FILTER       = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 7),
+        CMD_PACKET_FILTER       = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 7),
 
         /* hang detection notification */
         CMD_HANG_NOTIFY         = _CMDC(_CMD_DIR_NONE, _CMD_VTYPE_ALL, 8),
diff --git a/drivers/scsi/fnic/vnic_rq.c b/drivers/scsi/fnic/vnic_rq.c
index bedd0d285630..fd2068f5ae16 100644
--- a/drivers/scsi/fnic/vnic_rq.c
+++ b/drivers/scsi/fnic/vnic_rq.c
@@ -20,6 +20,7 @@
 #include <linux/types.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include "vnic_dev.h"
 #include "vnic_rq.h"
 
diff --git a/drivers/scsi/fnic/vnic_scsi.h b/drivers/scsi/fnic/vnic_scsi.h
index 46baa5254001..fbb55364e272 100644
--- a/drivers/scsi/fnic/vnic_scsi.h
+++ b/drivers/scsi/fnic/vnic_scsi.h
@@ -95,5 +95,6 @@ struct vnic_fc_config {
 
 #define VFCF_FCP_SEQ_LVL_ERR    0x1     /* Enable FCP-2 Error Recovery */
 #define VFCF_PERBI              0x2     /* persistent binding info available */
+#define VFCF_FIP_CAPABLE        0x4     /* firmware can handle FIP */
 
 #endif /* _VNIC_SCSI_H_ */
diff --git a/drivers/scsi/fnic/vnic_wq.c b/drivers/scsi/fnic/vnic_wq.c
index 1f9ea790d130..a414135460db 100644
--- a/drivers/scsi/fnic/vnic_wq.c
+++ b/drivers/scsi/fnic/vnic_wq.c
@@ -20,6 +20,7 @@
 #include <linux/types.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include "vnic_dev.h"
 #include "vnic_wq.h"