1 files changed, 152 insertions, 36 deletions

diff --git a/drivers/net/ixgbe/ixgbe_fcoe.c b/drivers/net/ixgbe/ixgbe_fcoe.c
index 072327c5e41a..05920726e824 100644
--- a/drivers/net/ixgbe/ixgbe_fcoe.c
+++ b/drivers/net/ixgbe/ixgbe_fcoe.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2010 Intel Corporation.
+  Copyright(c) 1999 - 2011 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -68,7 +68,7 @@ static inline bool ixgbe_rx_is_fcoe(union ixgbe_adv_rx_desc *rx_desc)
 static inline void ixgbe_fcoe_clear_ddp(struct ixgbe_fcoe_ddp *ddp)
 {
         ddp->len = 0;
-        ddp->err = 0;
+        ddp->err = 1;
         ddp->udl = NULL;
         ddp->udp = 0UL;
         ddp->sgl = NULL;
@@ -92,6 +92,7 @@ int ixgbe_fcoe_ddp_put(struct net_device *netdev, u16 xid)
         struct ixgbe_fcoe *fcoe;
         struct ixgbe_adapter *adapter;
         struct ixgbe_fcoe_ddp *ddp;
+        u32 fcbuff;
 
         if (!netdev)
                 goto out_ddp_put;
@@ -115,7 +116,14 @@ int ixgbe_fcoe_ddp_put(struct net_device *netdev, u16 xid)
                 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCBUFF, 0);
                 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCDMARW,
                                 (xid | IXGBE_FCDMARW_WE));
+
+                /* guaranteed to be invalidated after 100us */
+                IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCDMARW,
+                                (xid | IXGBE_FCDMARW_RE));
+                fcbuff = IXGBE_READ_REG(&adapter->hw, IXGBE_FCBUFF);
                 spin_unlock_bh(&fcoe->lock);
+                if (fcbuff & IXGBE_FCBUFF_VALID)
+                        udelay(100);
         }
         if (ddp->sgl)
                 pci_unmap_sg(adapter->pdev, ddp->sgl, ddp->sgc,
@@ -127,22 +135,19 @@ out_ddp_put:
         return len;
 }
 
+
 /**
- * ixgbe_fcoe_ddp_get - called to set up ddp context
+ * ixgbe_fcoe_ddp_setup - called to set up ddp context
  * @netdev: the corresponding net_device
  * @xid: the exchange id requesting ddp
  * @sgl: the scatter-gather list for this request
  * @sgc: the number of scatter-gather items
  *
- * This is the implementation of net_device_ops.ndo_fcoe_ddp_setup
- * and is expected to be called from ULD, e.g., FCP layer of libfc
- * to set up ddp for the corresponding xid of the given sglist for
- * the corresponding I/O.
- *
  * Returns : 1 for success and 0 for no ddp
  */
-int ixgbe_fcoe_ddp_get(struct net_device *netdev, u16 xid,
-                       struct scatterlist *sgl, unsigned int sgc)
+static int ixgbe_fcoe_ddp_setup(struct net_device *netdev, u16 xid,
+                                struct scatterlist *sgl, unsigned int sgc,
+                                int target_mode)
 {
         struct ixgbe_adapter *adapter;
         struct ixgbe_hw *hw;
@@ -151,13 +156,13 @@ int ixgbe_fcoe_ddp_get(struct net_device *netdev, u16 xid,
         struct scatterlist *sg;
         unsigned int i, j, dmacount;
         unsigned int len;
-        static const unsigned int bufflen = 4096;
+        static const unsigned int bufflen = IXGBE_FCBUFF_MIN;
         unsigned int firstoff = 0;
         unsigned int lastsize;
         unsigned int thisoff = 0;
         unsigned int thislen = 0;
-        u32 fcbuff, fcdmarw, fcfltrw;
-        dma_addr_t addr;
+        u32 fcbuff, fcdmarw, fcfltrw, fcrxctl;
+        dma_addr_t addr = 0;
 
         if (!netdev || !sgl)
                 return 0;
@@ -168,6 +173,11 @@ int ixgbe_fcoe_ddp_get(struct net_device *netdev, u16 xid,
                 return 0;
         }
 
+        /* no DDP if we are already down or resetting */
+        if (test_bit(__IXGBE_DOWN, &adapter->state) ||
+            test_bit(__IXGBE_RESETTING, &adapter->state))
+                return 0;
+
         fcoe = &adapter->fcoe;
         if (!fcoe->pool) {
                 e_warn(drv, "xid=0x%x no ddp pool for fcoe\n", xid);
@@ -241,9 +251,30 @@ int ixgbe_fcoe_ddp_get(struct net_device *netdev, u16 xid,
         /* only the last buffer may have non-full bufflen */
         lastsize = thisoff + thislen;
 
+        /*
+         * lastsize can not be buffer len.
+         * If it is then adding another buffer with lastsize = 1.
+         */
+        if (lastsize == bufflen) {
+                if (j >= IXGBE_BUFFCNT_MAX) {
+                        e_err(drv, "xid=%x:%d,%d,%d:addr=%llx "
+                                "not enough user buffers. We need an extra "
+                                "buffer because lastsize is bufflen.\n",
+                                xid, i, j, dmacount, (u64)addr);
+                        goto out_noddp_free;
+                }
+
+                ddp->udl[j] = (u64)(fcoe->extra_ddp_buffer_dma);
+                j++;
+                lastsize = 1;
+        }
+
         fcbuff = (IXGBE_FCBUFF_4KB << IXGBE_FCBUFF_BUFFSIZE_SHIFT);
         fcbuff |= ((j & 0xff) << IXGBE_FCBUFF_BUFFCNT_SHIFT);
         fcbuff |= (firstoff << IXGBE_FCBUFF_OFFSET_SHIFT);
+        /* Set WRCONTX bit to allow DDP for target */
+        if (target_mode)
+                fcbuff |= (IXGBE_FCBUFF_WRCONTX);
         fcbuff |= (IXGBE_FCBUFF_VALID);
 
         fcdmarw = xid;
@@ -256,6 +287,16 @@ int ixgbe_fcoe_ddp_get(struct net_device *netdev, u16 xid,
         /* program DMA context */
         hw = &adapter->hw;
         spin_lock_bh(&fcoe->lock);
+
+        /* turn on last frame indication for target mode as FCP_RSPtarget is
+         * supposed to send FCP_RSP when it is done. */
+        if (target_mode && !test_bit(__IXGBE_FCOE_TARGET, &fcoe->mode)) {
+                set_bit(__IXGBE_FCOE_TARGET, &fcoe->mode);
+                fcrxctl = IXGBE_READ_REG(hw, IXGBE_FCRXCTRL);
+                fcrxctl |= IXGBE_FCRXCTRL_LASTSEQH;
+                IXGBE_WRITE_REG(hw, IXGBE_FCRXCTRL, fcrxctl);
+        }
+
         IXGBE_WRITE_REG(hw, IXGBE_FCPTRL, ddp->udp & DMA_BIT_MASK(32));
         IXGBE_WRITE_REG(hw, IXGBE_FCPTRH, (u64)ddp->udp >> 32);
         IXGBE_WRITE_REG(hw, IXGBE_FCBUFF, fcbuff);
@@ -264,6 +305,7 @@ int ixgbe_fcoe_ddp_get(struct net_device *netdev, u16 xid,
         IXGBE_WRITE_REG(hw, IXGBE_FCPARAM, 0);
         IXGBE_WRITE_REG(hw, IXGBE_FCFLT, IXGBE_FCFLT_VALID);
         IXGBE_WRITE_REG(hw, IXGBE_FCFLTRW, fcfltrw);
+
         spin_unlock_bh(&fcoe->lock);
 
         return 1;
@@ -278,6 +320,47 @@ out_noddp_unmap:
 }
 
 /**
+ * ixgbe_fcoe_ddp_get - called to set up ddp context in initiator mode
+ * @netdev: the corresponding net_device
+ * @xid: the exchange id requesting ddp
+ * @sgl: the scatter-gather list for this request
+ * @sgc: the number of scatter-gather items
+ *
+ * This is the implementation of net_device_ops.ndo_fcoe_ddp_setup
+ * and is expected to be called from ULD, e.g., FCP layer of libfc
+ * to set up ddp for the corresponding xid of the given sglist for
+ * the corresponding I/O.
+ *
+ * Returns : 1 for success and 0 for no ddp
+ */
+int ixgbe_fcoe_ddp_get(struct net_device *netdev, u16 xid,
+                       struct scatterlist *sgl, unsigned int sgc)
+{
+        return ixgbe_fcoe_ddp_setup(netdev, xid, sgl, sgc, 0);
+}
+
+/**
+ * ixgbe_fcoe_ddp_target - called to set up ddp context in target mode
+ * @netdev: the corresponding net_device
+ * @xid: the exchange id requesting ddp
+ * @sgl: the scatter-gather list for this request
+ * @sgc: the number of scatter-gather items
+ *
+ * This is the implementation of net_device_ops.ndo_fcoe_ddp_target
+ * and is expected to be called from ULD, e.g., FCP layer of libfc
+ * to set up ddp for the corresponding xid of the given sglist for
+ * the corresponding I/O. The DDP in target mode is a write I/O request
+ * from the initiator.
+ *
+ * Returns : 1 for success and 0 for no ddp
+ */
+int ixgbe_fcoe_ddp_target(struct net_device *netdev, u16 xid,
+                            struct scatterlist *sgl, unsigned int sgc)
+{
+        return ixgbe_fcoe_ddp_setup(netdev, xid, sgl, sgc, 1);
+}
+
+/**
  * ixgbe_fcoe_ddp - check ddp status and mark it done
  * @adapter: ixgbe adapter
  * @rx_desc: advanced rx descriptor
@@ -300,16 +383,18 @@ int ixgbe_fcoe_ddp(struct ixgbe_adapter *adapter,
         struct ixgbe_fcoe *fcoe;
         struct ixgbe_fcoe_ddp *ddp;
         struct fc_frame_header *fh;
+        struct fcoe_crc_eof *crc;
 
         if (!ixgbe_rx_is_fcoe(rx_desc))
                 goto ddp_out;
 
-        skb->ip_summed = CHECKSUM_UNNECESSARY;
         sterr = le32_to_cpu(rx_desc->wb.upper.status_error);
         fcerr = (sterr & IXGBE_RXDADV_ERR_FCERR);
         fceofe = (sterr & IXGBE_RXDADV_ERR_FCEOFE);
         if (fcerr == IXGBE_FCERR_BADCRC)
-                skb->ip_summed = CHECKSUM_NONE;
+                skb_checksum_none_assert(skb);
+        else
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
 
         if (eth_hdr(skb)->h_proto == htons(ETH_P_8021Q))
                 fh = (struct fc_frame_header *)(skb->data +
@@ -331,8 +416,7 @@ int ixgbe_fcoe_ddp(struct ixgbe_adapter *adapter,
         if (!ddp->udl)
                 goto ddp_out;
 
-        ddp->err = (fcerr | fceofe);
-        if (ddp->err)
+        if (fcerr | fceofe)
                 goto ddp_out;
 
         fcstat = (sterr & IXGBE_RXDADV_STAT_FCSTAT);
@@ -343,6 +427,7 @@ int ixgbe_fcoe_ddp(struct ixgbe_adapter *adapter,
                 if (fcstat == IXGBE_RXDADV_STAT_FCSTAT_FCPRSP) {
                         pci_unmap_sg(adapter->pdev, ddp->sgl,
                                      ddp->sgc, DMA_FROM_DEVICE);
+                        ddp->err = (fcerr | fceofe);
                         ddp->sgl = NULL;
                         ddp->sgc = 0;
                 }
@@ -352,7 +437,18 @@ int ixgbe_fcoe_ddp(struct ixgbe_adapter *adapter,
                 else if (ddp->len)
                         rc = ddp->len;
         }
-
+        /* In target mode, check the last data frame of the sequence.
+         * For DDP in target mode, data is already DDPed but the header
+         * indication of the last data frame ould allow is to tell if we
+         * got all the data and the ULP can send FCP_RSP back, as this is
+         * not a full fcoe frame, we fill the trailer here so it won't be
+         * dropped by the ULP stack.
+         */
+        if ((fh->fh_r_ctl == FC_RCTL_DD_SOL_DATA) &&
+            (fctl & FC_FC_END_SEQ)) {
+                crc = (struct fcoe_crc_eof *)skb_put(skb, sizeof(*crc));
+                crc->fcoe_eof = FC_EOF_T;
+        }
 ddp_out:
         return rc;
 }
@@ -471,7 +567,7 @@ int ixgbe_fso(struct ixgbe_adapter *adapter,
 
         /* write context desc */
         i = tx_ring->next_to_use;
-        context_desc = IXGBE_TX_CTXTDESC_ADV(*tx_ring, i);
+        context_desc = IXGBE_TX_CTXTDESC_ADV(tx_ring, i);
         context_desc->vlan_macip_lens   = cpu_to_le32(vlan_macip_lens);
         context_desc->seqnum_seed       = cpu_to_le32(fcoe_sof_eof);
         context_desc->type_tucmd_mlhl   = cpu_to_le32(type_tucmd);
@@ -518,6 +614,24 @@ void ixgbe_configure_fcoe(struct ixgbe_adapter *adapter)
                         e_err(drv, "failed to allocated FCoE DDP pool\n");
 
                 spin_lock_init(&fcoe->lock);
+
+                /* Extra buffer to be shared by all DDPs for HW work around */
+                fcoe->extra_ddp_buffer = kmalloc(IXGBE_FCBUFF_MIN, GFP_ATOMIC);
+                if (fcoe->extra_ddp_buffer == NULL) {
+                        e_err(drv, "failed to allocated extra DDP buffer\n");
+                        goto out_extra_ddp_buffer_alloc;
+                }
+
+                fcoe->extra_ddp_buffer_dma =
+                        dma_map_single(&adapter->pdev->dev,
+                                       fcoe->extra_ddp_buffer,
+                                       IXGBE_FCBUFF_MIN,
+                                       DMA_FROM_DEVICE);
+                if (dma_mapping_error(&adapter->pdev->dev,
+                                      fcoe->extra_ddp_buffer_dma)) {
+                        e_err(drv, "failed to map extra DDP buffer\n");
+                        goto out_extra_ddp_buffer_dma;
+                }
         }
 
         /* Enable L2 eth type filter for FCoE */
@@ -567,6 +681,14 @@ void ixgbe_configure_fcoe(struct ixgbe_adapter *adapter)
                 }
         }
 #endif
+
+        return;
+
+out_extra_ddp_buffer_dma:
+        kfree(fcoe->extra_ddp_buffer);
+out_extra_ddp_buffer_alloc:
+        pci_pool_destroy(fcoe->pool);
+        fcoe->pool = NULL;
 }
 
 /**
@@ -586,6 +708,11 @@ void ixgbe_cleanup_fcoe(struct ixgbe_adapter *adapter)
         if (fcoe->pool) {
                 for (i = 0; i < IXGBE_FCOE_DDP_MAX; i++)
                         ixgbe_fcoe_ddp_put(adapter->netdev, i);
+                dma_unmap_single(&adapter->pdev->dev,
+                                 fcoe->extra_ddp_buffer_dma,
+                                 IXGBE_FCBUFF_MIN,
+                                 DMA_FROM_DEVICE);
+                kfree(fcoe->extra_ddp_buffer);
                 pci_pool_destroy(fcoe->pool);
                 fcoe->pool = NULL;
         }
@@ -603,11 +730,13 @@ int ixgbe_fcoe_enable(struct net_device *netdev)
 {
         int rc = -EINVAL;
         struct ixgbe_adapter *adapter = netdev_priv(netdev);
+        struct ixgbe_fcoe *fcoe = &adapter->fcoe;
 
 
         if (!(adapter->flags & IXGBE_FLAG_FCOE_CAPABLE))
                 goto out_enable;
 
+        atomic_inc(&fcoe->refcnt);
         if (adapter->flags & IXGBE_FLAG_FCOE_ENABLED)
                 goto out_enable;
 
@@ -647,6 +776,7 @@ int ixgbe_fcoe_disable(struct net_device *netdev)
 {
         int rc = -EINVAL;
         struct ixgbe_adapter *adapter = netdev_priv(netdev);
+        struct ixgbe_fcoe *fcoe = &adapter->fcoe;
 
         if (!(adapter->flags & IXGBE_FLAG_FCOE_CAPABLE))
                 goto out_disable;
@@ -654,6 +784,9 @@ int ixgbe_fcoe_disable(struct net_device *netdev)
         if (!(adapter->flags & IXGBE_FLAG_FCOE_ENABLED))
                 goto out_disable;
 
+        if (!atomic_dec_and_test(&fcoe->refcnt))
+                goto out_disable;
+
         e_info(drv, "Disabling FCoE offload features.\n");
         netdev->features &= ~NETIF_F_FCOE_CRC;
         netdev->features &= ~NETIF_F_FSO;
@@ -680,21 +813,6 @@ out_disable:
 
 #ifdef CONFIG_IXGBE_DCB
 /**
- * ixgbe_fcoe_getapp - retrieves current user priority bitmap for FCoE
- * @adapter : ixgbe adapter
- *
- * Finds out the corresponding user priority bitmap from the current
- * traffic class that FCoE belongs to. Returns 0 as the invalid user
- * priority bitmap to indicate an error.
- *
- * Returns : 802.1p user priority bitmap for FCoE
- */
-u8 ixgbe_fcoe_getapp(struct ixgbe_adapter *adapter)
-{
-        return 1 << adapter->fcoe.up;
-}
-
-/**
  * ixgbe_fcoe_setapp - sets the user priority bitmap for FCoE
  * @adapter : ixgbe adapter
  * @up : 802.1p user priority bitmap
@@ -771,5 +889,3 @@ int ixgbe_fcoe_get_wwn(struct net_device *netdev, u64 *wwn, int type)
         }
         return rc;
 }
-
-