drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 1999 - 2018 Intel Corporation. */
   3
   4 #include "ixgbe.h"
   5 #include <linux/if_ether.h>
   6 #include <linux/gfp.h>
   7 #include <linux/if_vlan.h>
   8 #include <generated/utsrelease.h>
   9 #include <scsi/scsi_cmnd.h>
  10 #include <scsi/scsi_device.h>
  11 #include <scsi/fc/fc_fs.h>
  12 #include <scsi/fc/fc_fcoe.h>
  13 #include <scsi/libfc.h>
  14 #include <scsi/libfcoe.h>
  15
  16 /**
  17  * ixgbe_fcoe_clear_ddp - clear the given ddp context
  18  * @ddp: ptr to the ixgbe_fcoe_ddp
  19  *
  20  * Returns : none
  21  *
  22  */
  23 static inline void ixgbe_fcoe_clear_ddp(struct ixgbe_fcoe_ddp *ddp)
  24 {
  25         ddp->len = 0;
  26         ddp->err = 1;
  27         ddp->udl = NULL;
  28         ddp->udp = 0UL;
  29         ddp->sgl = NULL;
  30         ddp->sgc = 0;
  31 }
  32
  33 /**
  34  * ixgbe_fcoe_ddp_put - free the ddp context for a given xid
  35  * @netdev: the corresponding net_device
  36  * @xid: the xid that corresponding ddp will be freed
  37  *
  38  * This is the implementation of net_device_ops.ndo_fcoe_ddp_done
  39  * and it is expected to be called by ULD, i.e., FCP layer of libfc
  40  * to release the corresponding ddp context when the I/O is done.
  41  *
  42  * Returns : data length already ddp-ed in bytes
  43  */
  44 int ixgbe_fcoe_ddp_put(struct net_device *netdev, u16 xid)
  45 {
  46         int len;
  47         struct ixgbe_fcoe *fcoe;
  48         struct ixgbe_adapter *adapter;
  49         struct ixgbe_fcoe_ddp *ddp;
  50         struct ixgbe_hw *hw;
  51         u32 fcbuff;
  52
  53         if (!netdev)
  54                 return 0;
  55
  56         if (xid >= netdev->fcoe_ddp_xid)
  57                 return 0;
  58
  59         adapter = netdev_priv(netdev);
  60         fcoe = &adapter->fcoe;
  61         ddp = &fcoe->ddp[xid];
  62         if (!ddp->udl)
  63                 return 0;
  64
  65         hw = &adapter->hw;
  66         len = ddp->len;
  67         /* if no error then skip ddp context invalidation */
  68         if (!ddp->err)
  69                 goto skip_ddpinv;
  70
  71         if (hw->mac.type == ixgbe_mac_X550) {
  72                 /* X550 does not require DDP FCoE lock */
  73
  74                 IXGBE_WRITE_REG(hw, IXGBE_FCDFC(0, xid), 0);
  75                 IXGBE_WRITE_REG(hw, IXGBE_FCDFC(3, xid),
  76                                 (xid | IXGBE_FCFLTRW_WE));
  77
  78                 /* program FCBUFF */
  79                 IXGBE_WRITE_REG(hw, IXGBE_FCDDC(2, xid), 0);
  80
  81                 /* program FCDMARW */
  82                 IXGBE_WRITE_REG(hw, IXGBE_FCDDC(3, xid),
  83                                 (xid | IXGBE_FCDMARW_WE));
  84
  85                 /* read FCBUFF to check context invalidated */
  86                 IXGBE_WRITE_REG(hw, IXGBE_FCDDC(3, xid),
  87                                 (xid | IXGBE_FCDMARW_RE));
  88                 fcbuff = IXGBE_READ_REG(hw, IXGBE_FCDDC(2, xid));
  89         } else {
  90                 /* other hardware requires DDP FCoE lock */
  91                 spin_lock_bh(&fcoe->lock);
  92                 IXGBE_WRITE_REG(hw, IXGBE_FCFLT, 0);
  93                 IXGBE_WRITE_REG(hw, IXGBE_FCFLTRW,
  94                                 (xid | IXGBE_FCFLTRW_WE));
  95                 IXGBE_WRITE_REG(hw, IXGBE_FCBUFF, 0);
  96                 IXGBE_WRITE_REG(hw, IXGBE_FCDMARW,
  97                                 (xid | IXGBE_FCDMARW_WE));
  98
  99                 /* guaranteed to be invalidated after 100us */
 100                 IXGBE_WRITE_REG(hw, IXGBE_FCDMARW,
 101                                 (xid | IXGBE_FCDMARW_RE));
 102                 fcbuff = IXGBE_READ_REG(hw, IXGBE_FCBUFF);
 103                 spin_unlock_bh(&fcoe->lock);
 104                 }
 105
 106         if (fcbuff & IXGBE_FCBUFF_VALID)
 107                 usleep_range(100, 150);
 108
 109 skip_ddpinv:
 110         if (ddp->sgl)
 111                 dma_unmap_sg(&adapter->pdev->dev, ddp->sgl, ddp->sgc,
 112                              DMA_FROM_DEVICE);
 113         if (ddp->pool) {
 114                 dma_pool_free(ddp->pool, ddp->udl, ddp->udp);
 115                 ddp->pool = NULL;
 116         }
 117
 118         ixgbe_fcoe_clear_ddp(ddp);
 119
 120         return len;
 121 }
 122
 123 /**
 124  * ixgbe_fcoe_ddp_setup - called to set up ddp context
 125  * @netdev: the corresponding net_device
 126  * @xid: the exchange id requesting ddp
 127  * @sgl: the scatter-gather list for this request
 128  * @sgc: the number of scatter-gather items
 129  * @target_mode: 1 to setup target mode, 0 to setup initiator mode
 130  *
 131  * Returns : 1 for success and 0 for no ddp
 132  */
 133 static int ixgbe_fcoe_ddp_setup(struct net_device *netdev, u16 xid,
 134                                 struct scatterlist *sgl, unsigned int sgc,
 135                                 int target_mode)
 136 {
 137         struct ixgbe_adapter *adapter;
 138         struct ixgbe_hw *hw;
 139         struct ixgbe_fcoe *fcoe;
 140         struct ixgbe_fcoe_ddp *ddp;
 141         struct ixgbe_fcoe_ddp_pool *ddp_pool;
 142         struct scatterlist *sg;
 143         unsigned int i, j, dmacount;
 144         unsigned int len;
 145         static const unsigned int bufflen = IXGBE_FCBUFF_MIN;
 146         unsigned int firstoff = 0;
 147         unsigned int lastsize;
 148         unsigned int thisoff = 0;
 149         unsigned int thislen = 0;
 150         u32 fcbuff, fcdmarw, fcfltrw, fcrxctl;
 151         dma_addr_t addr = 0;
 152
 153         if (!netdev || !sgl)
 154                 return 0;
 155
 156         adapter = netdev_priv(netdev);
 157         if (xid >= netdev->fcoe_ddp_xid) {
 158                 e_warn(drv, "xid=0x%x out-of-range\n", xid);
 159                 return 0;
 160         }
 161
 162         /* no DDP if we are already down or resetting */
 163         if (test_bit(__IXGBE_DOWN, &adapter->state) ||
 164             test_bit(__IXGBE_RESETTING, &adapter->state))
 165                 return 0;
 166
 167         fcoe = &adapter->fcoe;
 168         ddp = &fcoe->ddp[xid];
 169         if (ddp->sgl) {
 170                 e_err(drv, "xid 0x%x w/ non-null sgl=%p nents=%d\n",
 171                       xid, ddp->sgl, ddp->sgc);
 172                 return 0;
 173         }
 174         ixgbe_fcoe_clear_ddp(ddp);
 175
 176
 177         if (!fcoe->ddp_pool) {
 178                 e_warn(drv, "No ddp_pool resources allocated\n");
 179                 return 0;
 180         }
 181
 182         ddp_pool = per_cpu_ptr(fcoe->ddp_pool, get_cpu());
 183         if (!ddp_pool->pool) {
 184                 e_warn(drv, "xid=0x%x no ddp pool for fcoe\n", xid);
 185                 goto out_noddp;
 186         }
 187
 188         /* setup dma from scsi command sgl */
 189         dmacount = dma_map_sg(&adapter->pdev->dev, sgl, sgc, DMA_FROM_DEVICE);
 190         if (dmacount == 0) {
 191                 e_err(drv, "xid 0x%x DMA map error\n", xid);
 192                 goto out_noddp;
 193         }
 194
 195         /* alloc the udl from per cpu ddp pool */
 196         ddp->udl = dma_pool_alloc(ddp_pool->pool, GFP_ATOMIC, &ddp->udp);
 197         if (!ddp->udl) {
 198                 e_err(drv, "failed allocated ddp context\n");
 199                 goto out_noddp_unmap;
 200         }
 201         ddp->pool = ddp_pool->pool;
 202         ddp->sgl = sgl;
 203         ddp->sgc = sgc;
 204
 205         j = 0;
 206         for_each_sg(sgl, sg, dmacount, i) {
 207                 addr = sg_dma_address(sg);
 208                 len = sg_dma_len(sg);
 209                 while (len) {
 210                         /* max number of buffers allowed in one DDP context */
 211                         if (j >= IXGBE_BUFFCNT_MAX) {
 212                                 ddp_pool->noddp++;
 213                                 goto out_noddp_free;
 214                         }
 215
 216                         /* get the offset of length of current buffer */
 217                         thisoff = addr & ((dma_addr_t)bufflen - 1);
 218                         thislen = min((bufflen - thisoff), len);
 219                         /*
 220                          * all but the 1st buffer (j == 0)
 221                          * must be aligned on bufflen
 222                          */
 223                         if ((j != 0) && (thisoff))
 224                                 goto out_noddp_free;
 225                         /*
 226                          * all but the last buffer
 227                          * ((i == (dmacount - 1)) && (thislen == len))
 228                          * must end at bufflen
 229                          */
 230                         if (((i != (dmacount - 1)) || (thislen != len))
 231                             && ((thislen + thisoff) != bufflen))
 232                                 goto out_noddp_free;
 233
 234                         ddp->udl[j] = (u64)(addr - thisoff);
 235                         /* only the first buffer may have none-zero offset */
 236                         if (j == 0)
 237                                 firstoff = thisoff;
 238                         len -= thislen;
 239                         addr += thislen;
 240                         j++;
 241                 }
 242         }
 243         /* only the last buffer may have non-full bufflen */
 244         lastsize = thisoff + thislen;
 245
 246         /*
 247          * lastsize can not be buffer len.
 248          * If it is then adding another buffer with lastsize = 1.
 249          */
 250         if (lastsize == bufflen) {
 251                 if (j >= IXGBE_BUFFCNT_MAX) {
 252                         ddp_pool->noddp_ext_buff++;
 253                         goto out_noddp_free;
 254                 }
 255
 256                 ddp->udl[j] = (u64)(fcoe->extra_ddp_buffer_dma);
 257                 j++;
 258                 lastsize = 1;
 259         }
 260         put_cpu();
 261
 262         fcbuff = (IXGBE_FCBUFF_4KB << IXGBE_FCBUFF_BUFFSIZE_SHIFT);
 263         fcbuff |= ((j & 0xff) << IXGBE_FCBUFF_BUFFCNT_SHIFT);
 264         fcbuff |= (firstoff << IXGBE_FCBUFF_OFFSET_SHIFT);
 265         /* Set WRCONTX bit to allow DDP for target */
 266         if (target_mode)
 267                 fcbuff |= (IXGBE_FCBUFF_WRCONTX);
 268         fcbuff |= (IXGBE_FCBUFF_VALID);
 269
 270         fcdmarw = xid;
 271         fcdmarw |= IXGBE_FCDMARW_WE;
 272         fcdmarw |= (lastsize << IXGBE_FCDMARW_LASTSIZE_SHIFT);
 273
 274         fcfltrw = xid;
 275         fcfltrw |= IXGBE_FCFLTRW_WE;
 276
 277         /* program DMA context */
 278         hw = &adapter->hw;
 279
 280         /* turn on last frame indication for target mode as FCP_RSPtarget is
 281          * supposed to send FCP_RSP when it is done. */
 282         if (target_mode && !test_bit(__IXGBE_FCOE_TARGET, &fcoe->mode)) {
 283                 set_bit(__IXGBE_FCOE_TARGET, &fcoe->mode);
 284                 fcrxctl = IXGBE_READ_REG(hw, IXGBE_FCRXCTRL);
 285                 fcrxctl |= IXGBE_FCRXCTRL_LASTSEQH;
 286                 IXGBE_WRITE_REG(hw, IXGBE_FCRXCTRL, fcrxctl);
 287         }
 288
 289         if (hw->mac.type == ixgbe_mac_X550) {
 290                 /* X550 does not require DDP lock */
 291
 292                 IXGBE_WRITE_REG(hw, IXGBE_FCDDC(0, xid),
 293                                 ddp->udp & DMA_BIT_MASK(32));
 294                 IXGBE_WRITE_REG(hw, IXGBE_FCDDC(1, xid), (u64)ddp->udp >> 32);
 295                 IXGBE_WRITE_REG(hw, IXGBE_FCDDC(2, xid), fcbuff);
 296                 IXGBE_WRITE_REG(hw, IXGBE_FCDDC(3, xid), fcdmarw);
 297                 /* program filter context */
 298                 IXGBE_WRITE_REG(hw, IXGBE_FCDFC(0, xid), IXGBE_FCFLT_VALID);
 299                 IXGBE_WRITE_REG(hw, IXGBE_FCDFC(1, xid), 0);
 300                 IXGBE_WRITE_REG(hw, IXGBE_FCDFC(3, xid), fcfltrw);
 301         } else {
 302                 /* DDP lock for indirect DDP context access */
 303                 spin_lock_bh(&fcoe->lock);
 304
 305                 IXGBE_WRITE_REG(hw, IXGBE_FCPTRL, ddp->udp & DMA_BIT_MASK(32));
 306                 IXGBE_WRITE_REG(hw, IXGBE_FCPTRH, (u64)ddp->udp >> 32);
 307                 IXGBE_WRITE_REG(hw, IXGBE_FCBUFF, fcbuff);
 308                 IXGBE_WRITE_REG(hw, IXGBE_FCDMARW, fcdmarw);
 309                 /* program filter context */
 310                 IXGBE_WRITE_REG(hw, IXGBE_FCPARAM, 0);
 311                 IXGBE_WRITE_REG(hw, IXGBE_FCFLT, IXGBE_FCFLT_VALID);
 312                 IXGBE_WRITE_REG(hw, IXGBE_FCFLTRW, fcfltrw);
 313
 314                 spin_unlock_bh(&fcoe->lock);
 315         }
 316
 317         return 1;
 318
 319 out_noddp_free:
 320         dma_pool_free(ddp->pool, ddp->udl, ddp->udp);
 321         ixgbe_fcoe_clear_ddp(ddp);
 322
 323 out_noddp_unmap:
 324         dma_unmap_sg(&adapter->pdev->dev, sgl, sgc, DMA_FROM_DEVICE);
 325 out_noddp:
 326         put_cpu();
 327         return 0;
 328 }
 329
 330 /**
 331  * ixgbe_fcoe_ddp_get - called to set up ddp context in initiator mode
 332  * @netdev: the corresponding net_device
 333  * @xid: the exchange id requesting ddp
 334  * @sgl: the scatter-gather list for this request
 335  * @sgc: the number of scatter-gather items
 336  *
 337  * This is the implementation of net_device_ops.ndo_fcoe_ddp_setup
 338  * and is expected to be called from ULD, e.g., FCP layer of libfc
 339  * to set up ddp for the corresponding xid of the given sglist for
 340  * the corresponding I/O.
 341  *
 342  * Returns : 1 for success and 0 for no ddp
 343  */
 344 int ixgbe_fcoe_ddp_get(struct net_device *netdev, u16 xid,
 345                        struct scatterlist *sgl, unsigned int sgc)
 346 {
 347         return ixgbe_fcoe_ddp_setup(netdev, xid, sgl, sgc, 0);
 348 }
 349
 350 /**
 351  * ixgbe_fcoe_ddp_target - called to set up ddp context in target mode
 352  * @netdev: the corresponding net_device
 353  * @xid: the exchange id requesting ddp
 354  * @sgl: the scatter-gather list for this request
 355  * @sgc: the number of scatter-gather items
 356  *
 357  * This is the implementation of net_device_ops.ndo_fcoe_ddp_target
 358  * and is expected to be called from ULD, e.g., FCP layer of libfc
 359  * to set up ddp for the corresponding xid of the given sglist for
 360  * the corresponding I/O. The DDP in target mode is a write I/O request
 361  * from the initiator.
 362  *
 363  * Returns : 1 for success and 0 for no ddp
 364  */
 365 int ixgbe_fcoe_ddp_target(struct net_device *netdev, u16 xid,
 366                             struct scatterlist *sgl, unsigned int sgc)
 367 {
 368         return ixgbe_fcoe_ddp_setup(netdev, xid, sgl, sgc, 1);
 369 }
 370
 371 /**
 372  * ixgbe_fcoe_ddp - check ddp status and mark it done
 373  * @adapter: ixgbe adapter
 374  * @rx_desc: advanced rx descriptor
 375  * @skb: the skb holding the received data
 376  *
 377  * This checks ddp status.
 378  *
 379  * Returns : < 0 indicates an error or not a FCiE ddp, 0 indicates
 380  * not passing the skb to ULD, > 0 indicates is the length of data
 381  * being ddped.
 382  */
 383 int ixgbe_fcoe_ddp(struct ixgbe_adapter *adapter,
 384                    union ixgbe_adv_rx_desc *rx_desc,
 385                    struct sk_buff *skb)
 386 {
 387         int rc = -EINVAL;
 388         struct ixgbe_fcoe *fcoe;
 389         struct ixgbe_fcoe_ddp *ddp;
 390         struct fc_frame_header *fh;
 391         struct fcoe_crc_eof *crc;
 392         __le32 fcerr = ixgbe_test_staterr(rx_desc, IXGBE_RXDADV_ERR_FCERR);
 393         __le32 ddp_err;
 394         int ddp_max;
 395         u32 fctl;
 396         u16 xid;
 397
 398         if (fcerr == cpu_to_le32(IXGBE_FCERR_BADCRC))
 399                 skb->ip_summed = CHECKSUM_NONE;
 400         else
 401                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 402
 403         if (eth_hdr(skb)->h_proto == htons(ETH_P_8021Q))
 404                 fh = (struct fc_frame_header *)(skb->data +
 405                         sizeof(struct vlan_hdr) + sizeof(struct fcoe_hdr));
 406         else
 407                 fh = (struct fc_frame_header *)(skb->data +
 408                         sizeof(struct fcoe_hdr));
 409
 410         fctl = ntoh24(fh->fh_f_ctl);
 411         if (fctl & FC_FC_EX_CTX)
 412                 xid =  be16_to_cpu(fh->fh_ox_id);
 413         else
 414                 xid =  be16_to_cpu(fh->fh_rx_id);
 415
 416         ddp_max = IXGBE_FCOE_DDP_MAX;
 417         /* X550 has different DDP Max limit */
 418         if (adapter->hw.mac.type == ixgbe_mac_X550)
 419                 ddp_max = IXGBE_FCOE_DDP_MAX_X550;
 420         if (xid >= ddp_max)
 421                 return -EINVAL;
 422
 423         fcoe = &adapter->fcoe;
 424         ddp = &fcoe->ddp[xid];
 425         if (!ddp->udl)
 426                 return -EINVAL;
 427
 428         ddp_err = ixgbe_test_staterr(rx_desc, IXGBE_RXDADV_ERR_FCEOFE |
 429                                               IXGBE_RXDADV_ERR_FCERR);
 430         if (ddp_err)
 431                 return -EINVAL;
 432
 433         switch (ixgbe_test_staterr(rx_desc, IXGBE_RXDADV_STAT_FCSTAT)) {
 434         /* return 0 to bypass going to ULD for DDPed data */
 435         case cpu_to_le32(IXGBE_RXDADV_STAT_FCSTAT_DDP):
 436                 /* update length of DDPed data */
 437                 ddp->len = le32_to_cpu(rx_desc->wb.lower.hi_dword.rss);
 438                 rc = 0;
 439                 break;
 440         /* unmap the sg list when FCPRSP is received */
 441         case cpu_to_le32(IXGBE_RXDADV_STAT_FCSTAT_FCPRSP):
 442                 dma_unmap_sg(&adapter->pdev->dev, ddp->sgl,
 443                              ddp->sgc, DMA_FROM_DEVICE);
 444                 ddp->err = (__force u32)ddp_err;
 445                 ddp->sgl = NULL;
 446                 ddp->sgc = 0;
 447                 fallthrough;
 448         /* if DDP length is present pass it through to ULD */
 449         case cpu_to_le32(IXGBE_RXDADV_STAT_FCSTAT_NODDP):
 450                 /* update length of DDPed data */
 451                 ddp->len = le32_to_cpu(rx_desc->wb.lower.hi_dword.rss);
 452                 if (ddp->len)
 453                         rc = ddp->len;
 454                 break;
 455         /* no match will return as an error */
 456         case cpu_to_le32(IXGBE_RXDADV_STAT_FCSTAT_NOMTCH):
 457         default:
 458                 break;
 459         }
 460
 461         /* In target mode, check the last data frame of the sequence.
 462          * For DDP in target mode, data is already DDPed but the header
 463          * indication of the last data frame ould allow is to tell if we
 464          * got all the data and the ULP can send FCP_RSP back, as this is
 465          * not a full fcoe frame, we fill the trailer here so it won't be
 466          * dropped by the ULP stack.
 467          */
 468         if ((fh->fh_r_ctl == FC_RCTL_DD_SOL_DATA) &&
 469             (fctl & FC_FC_END_SEQ)) {
 470                 skb_linearize(skb);
 471                 crc = skb_put(skb, sizeof(*crc));
 472                 crc->fcoe_eof = FC_EOF_T;
 473         }
 474
 475         return rc;
 476 }
 477
 478 /**
 479  * ixgbe_fso - ixgbe FCoE Sequence Offload (FSO)
 480  * @tx_ring: tx desc ring
 481  * @first: first tx_buffer structure containing skb, tx_flags, and protocol
 482  * @hdr_len: hdr_len to be returned
 483  *
 484  * This sets up large send offload for FCoE
 485  *
 486  * Returns : 0 indicates success, < 0 for error
 487  */
 488 int ixgbe_fso(struct ixgbe_ring *tx_ring,
 489               struct ixgbe_tx_buffer *first,
 490               u8 *hdr_len)
 491 {
 492         struct sk_buff *skb = first->skb;
 493         struct fc_frame_header *fh;
 494         u32 vlan_macip_lens;
 495         u32 fcoe_sof_eof = 0;
 496         u32 mss_l4len_idx;
 497         u32 type_tucmd = IXGBE_ADVTXT_TUCMD_FCOE;
 498         u8 sof, eof;
 499
 500         if (skb_is_gso(skb) && (skb_shinfo(skb)->gso_type != SKB_GSO_FCOE)) {
 501                 dev_err(tx_ring->dev, "Wrong gso type %d:expecting SKB_GSO_FCOE\n",
 502                         skb_shinfo(skb)->gso_type);
 503                 return -EINVAL;
 504         }
 505
 506         /* resets the header to point fcoe/fc */
 507         skb_set_network_header(skb, skb->mac_len);
 508         skb_set_transport_header(skb, skb->mac_len +
 509                                  sizeof(struct fcoe_hdr));
 510
 511         /* sets up SOF and ORIS */
 512         sof = ((struct fcoe_hdr *)skb_network_header(skb))->fcoe_sof;
 513         switch (sof) {
 514         case FC_SOF_I2:
 515                 fcoe_sof_eof = IXGBE_ADVTXD_FCOEF_ORIS;
 516                 break;
 517         case FC_SOF_I3:
 518                 fcoe_sof_eof = IXGBE_ADVTXD_FCOEF_SOF |
 519                                IXGBE_ADVTXD_FCOEF_ORIS;
 520                 break;
 521         case FC_SOF_N2:
 522                 break;
 523         case FC_SOF_N3:
 524                 fcoe_sof_eof = IXGBE_ADVTXD_FCOEF_SOF;
 525                 break;
 526         default:
 527                 dev_warn(tx_ring->dev, "unknown sof = 0x%x\n", sof);
 528                 return -EINVAL;
 529         }
 530
 531         /* the first byte of the last dword is EOF */
 532         skb_copy_bits(skb, skb->len - 4, &eof, 1);
 533         /* sets up EOF and ORIE */
 534         switch (eof) {
 535         case FC_EOF_N:
 536                 fcoe_sof_eof |= IXGBE_ADVTXD_FCOEF_EOF_N;
 537                 break;
 538         case FC_EOF_T:
 539                 /* lso needs ORIE */
 540                 if (skb_is_gso(skb))
 541                         fcoe_sof_eof |= IXGBE_ADVTXD_FCOEF_EOF_N |
 542                                         IXGBE_ADVTXD_FCOEF_ORIE;
 543                 else
 544                         fcoe_sof_eof |= IXGBE_ADVTXD_FCOEF_EOF_T;
 545                 break;
 546         case FC_EOF_NI:
 547                 fcoe_sof_eof |= IXGBE_ADVTXD_FCOEF_EOF_NI;
 548                 break;
 549         case FC_EOF_A:
 550                 fcoe_sof_eof |= IXGBE_ADVTXD_FCOEF_EOF_A;
 551                 break;
 552         default:
 553                 dev_warn(tx_ring->dev, "unknown eof = 0x%x\n", eof);
 554                 return -EINVAL;
 555         }
 556
 557         /* sets up PARINC indicating data offset */
 558         fh = (struct fc_frame_header *)skb_transport_header(skb);
 559         if (fh->fh_f_ctl[2] & FC_FC_REL_OFF)
 560                 fcoe_sof_eof |= IXGBE_ADVTXD_FCOEF_PARINC;
 561
 562         /* include trailer in headlen as it is replicated per frame */
 563         *hdr_len = sizeof(struct fcoe_crc_eof);
 564
 565         /* hdr_len includes fc_hdr if FCoE LSO is enabled */
 566         if (skb_is_gso(skb)) {
 567                 *hdr_len += skb_transport_offset(skb) +
 568                             sizeof(struct fc_frame_header);
 569                 /* update gso_segs and bytecount */
 570                 first->gso_segs = DIV_ROUND_UP(skb->len - *hdr_len,
 571                                                skb_shinfo(skb)->gso_size);
 572                 first->bytecount += (first->gso_segs - 1) * *hdr_len;
 573                 first->tx_flags |= IXGBE_TX_FLAGS_TSO;
 574                 /* Hardware expects L4T to be RSV for FCoE TSO */
 575                 type_tucmd |= IXGBE_ADVTXD_TUCMD_L4T_RSV;
 576         }
 577
 578         /* set flag indicating FCOE to ixgbe_tx_map call */
 579         first->tx_flags |= IXGBE_TX_FLAGS_FCOE | IXGBE_TX_FLAGS_CC;
 580
 581         /* mss_l4len_id: use 0 for FSO as TSO, no need for L4LEN */
 582         mss_l4len_idx = skb_shinfo(skb)->gso_size << IXGBE_ADVTXD_MSS_SHIFT;
 583
 584         /* vlan_macip_lens: HEADLEN, MACLEN, VLAN tag */
 585         vlan_macip_lens = skb_transport_offset(skb) +
 586                           sizeof(struct fc_frame_header);
 587         vlan_macip_lens |= (skb_transport_offset(skb) - 4)
 588                            << IXGBE_ADVTXD_MACLEN_SHIFT;
 589         vlan_macip_lens |= first->tx_flags & IXGBE_TX_FLAGS_VLAN_MASK;
 590
 591         /* write context desc */
 592         ixgbe_tx_ctxtdesc(tx_ring, vlan_macip_lens, fcoe_sof_eof,
 593                           type_tucmd, mss_l4len_idx);
 594
 595         return 0;
 596 }
 597
 598 static void ixgbe_fcoe_dma_pool_free(struct ixgbe_fcoe *fcoe, unsigned int cpu)
 599 {
 600         struct ixgbe_fcoe_ddp_pool *ddp_pool;
 601
 602         ddp_pool = per_cpu_ptr(fcoe->ddp_pool, cpu);
 603         dma_pool_destroy(ddp_pool->pool);
 604         ddp_pool->pool = NULL;
 605 }
 606
 607 static int ixgbe_fcoe_dma_pool_alloc(struct ixgbe_fcoe *fcoe,
 608                                      struct device *dev,
 609                                      unsigned int cpu)
 610 {
 611         struct ixgbe_fcoe_ddp_pool *ddp_pool;
 612         struct dma_pool *pool;
 613         char pool_name[32];
 614
 615         snprintf(pool_name, 32, "ixgbe_fcoe_ddp_%u", cpu);
 616
 617         pool = dma_pool_create(pool_name, dev, IXGBE_FCPTR_MAX,
 618                                IXGBE_FCPTR_ALIGN, PAGE_SIZE);
 619         if (!pool)
 620                 return -ENOMEM;
 621
 622         ddp_pool = per_cpu_ptr(fcoe->ddp_pool, cpu);
 623         ddp_pool->pool = pool;
 624         ddp_pool->noddp = 0;
 625         ddp_pool->noddp_ext_buff = 0;
 626
 627         return 0;
 628 }
 629
 630 /**
 631  * ixgbe_configure_fcoe - configures registers for fcoe at start
 632  * @adapter: ptr to ixgbe adapter
 633  *
 634  * This sets up FCoE related registers
 635  *
 636  * Returns : none
 637  */
 638 void ixgbe_configure_fcoe(struct ixgbe_adapter *adapter)
 639 {
 640         struct ixgbe_ring_feature *fcoe = &adapter->ring_feature[RING_F_FCOE];
 641         struct ixgbe_hw *hw = &adapter->hw;
 642         int i, fcoe_q, fcoe_i, fcoe_q_h = 0;
 643         int fcreta_size;
 644         u32 etqf;
 645
 646         /* Minimal functionality for FCoE requires at least CRC offloads */
 647         if (!(adapter->netdev->features & NETIF_F_FCOE_CRC))
 648                 return;
 649
 650         /* Enable L2 EtherType filter for FCoE, needed for FCoE CRC and DDP */
 651         etqf = ETH_P_FCOE | IXGBE_ETQF_FCOE | IXGBE_ETQF_FILTER_EN;
 652         if (adapter->flags & IXGBE_FLAG_SRIOV_ENABLED) {
 653                 etqf |= IXGBE_ETQF_POOL_ENABLE;
 654                 etqf |= VMDQ_P(0) << IXGBE_ETQF_POOL_SHIFT;
 655         }
 656         IXGBE_WRITE_REG(hw, IXGBE_ETQF(IXGBE_ETQF_FILTER_FCOE), etqf);
 657         IXGBE_WRITE_REG(hw, IXGBE_ETQS(IXGBE_ETQF_FILTER_FCOE), 0);
 658
 659         /* leave registers un-configured if FCoE is disabled */
 660         if (!(adapter->flags & IXGBE_FLAG_FCOE_ENABLED))
 661                 return;
 662
 663         /* Use one or more Rx queues for FCoE by redirection table */
 664         fcreta_size = IXGBE_FCRETA_SIZE;
 665         if (adapter->hw.mac.type == ixgbe_mac_X550)
 666                 fcreta_size = IXGBE_FCRETA_SIZE_X550;
 667
 668         for (i = 0; i < fcreta_size; i++) {
 669                 if (adapter->hw.mac.type == ixgbe_mac_X550) {
 670                         int fcoe_i_h = fcoe->offset + ((i + fcreta_size) %
 671                                                         fcoe->indices);
 672                         fcoe_q_h = adapter->rx_ring[fcoe_i_h]->reg_idx;
 673                         fcoe_q_h = (fcoe_q_h << IXGBE_FCRETA_ENTRY_HIGH_SHIFT) &
 674                                    IXGBE_FCRETA_ENTRY_HIGH_MASK;
 675                 }
 676
 677                 fcoe_i = fcoe->offset + (i % fcoe->indices);
 678                 fcoe_i &= IXGBE_FCRETA_ENTRY_MASK;
 679                 fcoe_q = adapter->rx_ring[fcoe_i]->reg_idx;
 680                 fcoe_q |= fcoe_q_h;
 681                 IXGBE_WRITE_REG(hw, IXGBE_FCRETA(i), fcoe_q);
 682         }
 683         IXGBE_WRITE_REG(hw, IXGBE_FCRECTL, IXGBE_FCRECTL_ENA);
 684
 685         /* Enable L2 EtherType filter for FIP */
 686         etqf = ETH_P_FIP | IXGBE_ETQF_FILTER_EN;
 687         if (adapter->flags & IXGBE_FLAG_SRIOV_ENABLED) {
 688                 etqf |= IXGBE_ETQF_POOL_ENABLE;
 689                 etqf |= VMDQ_P(0) << IXGBE_ETQF_POOL_SHIFT;
 690         }
 691         IXGBE_WRITE_REG(hw, IXGBE_ETQF(IXGBE_ETQF_FILTER_FIP), etqf);
 692
 693         /* Send FIP frames to the first FCoE queue */
 694         fcoe_q = adapter->rx_ring[fcoe->offset]->reg_idx;
 695         IXGBE_WRITE_REG(hw, IXGBE_ETQS(IXGBE_ETQF_FILTER_FIP),
 696                         IXGBE_ETQS_QUEUE_EN |
 697                         (fcoe_q << IXGBE_ETQS_RX_QUEUE_SHIFT));
 698
 699         /* Configure FCoE Rx control */
 700         IXGBE_WRITE_REG(hw, IXGBE_FCRXCTRL,
 701                         IXGBE_FCRXCTRL_FCCRCBO |
 702                         (FC_FCOE_VER << IXGBE_FCRXCTRL_FCOEVER_SHIFT));
 703 }
 704
 705 /**
 706  * ixgbe_free_fcoe_ddp_resources - release all fcoe ddp context resources
 707  * @adapter : ixgbe adapter
 708  *
 709  * Cleans up outstanding ddp context resources
 710  *
 711  * Returns : none
 712  */
 713 void ixgbe_free_fcoe_ddp_resources(struct ixgbe_adapter *adapter)
 714 {
 715         struct ixgbe_fcoe *fcoe = &adapter->fcoe;
 716         int cpu, i, ddp_max;
 717
 718         /* do nothing if no DDP pools were allocated */
 719         if (!fcoe->ddp_pool)
 720                 return;
 721
 722         ddp_max = IXGBE_FCOE_DDP_MAX;
 723         /* X550 has different DDP Max limit */
 724         if (adapter->hw.mac.type == ixgbe_mac_X550)
 725                 ddp_max = IXGBE_FCOE_DDP_MAX_X550;
 726
 727         for (i = 0; i < ddp_max; i++)
 728                 ixgbe_fcoe_ddp_put(adapter->netdev, i);
 729
 730         for_each_possible_cpu(cpu)
 731                 ixgbe_fcoe_dma_pool_free(fcoe, cpu);
 732
 733         dma_unmap_single(&adapter->pdev->dev,
 734                          fcoe->extra_ddp_buffer_dma,
 735                          IXGBE_FCBUFF_MIN,
 736                          DMA_FROM_DEVICE);
 737         kfree(fcoe->extra_ddp_buffer);
 738
 739         fcoe->extra_ddp_buffer = NULL;
 740         fcoe->extra_ddp_buffer_dma = 0;
 741 }
 742
 743 /**
 744  * ixgbe_setup_fcoe_ddp_resources - setup all fcoe ddp context resources
 745  * @adapter: ixgbe adapter
 746  *
 747  * Sets up ddp context resouces
 748  *
 749  * Returns : 0 indicates success or -EINVAL on failure
 750  */
 751 int ixgbe_setup_fcoe_ddp_resources(struct ixgbe_adapter *adapter)
 752 {
 753         struct ixgbe_fcoe *fcoe = &adapter->fcoe;
 754         struct device *dev = &adapter->pdev->dev;
 755         void *buffer;
 756         dma_addr_t dma;
 757         unsigned int cpu;
 758
 759         /* do nothing if no DDP pools were allocated */
 760         if (!fcoe->ddp_pool)
 761                 return 0;
 762
 763         /* Extra buffer to be shared by all DDPs for HW work around */
 764         buffer = kmalloc(IXGBE_FCBUFF_MIN, GFP_KERNEL);
 765         if (!buffer)
 766                 return -ENOMEM;
 767
 768         dma = dma_map_single(dev, buffer, IXGBE_FCBUFF_MIN, DMA_FROM_DEVICE);
 769         if (dma_mapping_error(dev, dma)) {
 770                 e_err(drv, "failed to map extra DDP buffer\n");
 771                 kfree(buffer);
 772                 return -ENOMEM;
 773         }
 774
 775         fcoe->extra_ddp_buffer = buffer;
 776         fcoe->extra_ddp_buffer_dma = dma;
 777
 778         /* allocate pci pool for each cpu */
 779         for_each_possible_cpu(cpu) {
 780                 int err = ixgbe_fcoe_dma_pool_alloc(fcoe, dev, cpu);
 781                 if (!err)
 782                         continue;
 783
 784                 e_err(drv, "failed to alloc DDP pool on cpu:%d\n", cpu);
 785                 ixgbe_free_fcoe_ddp_resources(adapter);
 786                 return -ENOMEM;
 787         }
 788
 789         return 0;
 790 }
 791
 792 static int ixgbe_fcoe_ddp_enable(struct ixgbe_adapter *adapter)
 793 {
 794         struct ixgbe_fcoe *fcoe = &adapter->fcoe;
 795
 796         if (!(adapter->flags & IXGBE_FLAG_FCOE_CAPABLE))
 797                 return -EINVAL;
 798
 799         fcoe->ddp_pool = alloc_percpu(struct ixgbe_fcoe_ddp_pool);
 800
 801         if (!fcoe->ddp_pool) {
 802                 e_err(drv, "failed to allocate percpu DDP resources\n");
 803                 return -ENOMEM;
 804         }
 805
 806         adapter->netdev->fcoe_ddp_xid = IXGBE_FCOE_DDP_MAX - 1;
 807         /* X550 has different DDP Max limit */
 808         if (adapter->hw.mac.type == ixgbe_mac_X550)
 809                 adapter->netdev->fcoe_ddp_xid = IXGBE_FCOE_DDP_MAX_X550 - 1;
 810
 811         return 0;
 812 }
 813
 814 static void ixgbe_fcoe_ddp_disable(struct ixgbe_adapter *adapter)
 815 {
 816         struct ixgbe_fcoe *fcoe = &adapter->fcoe;
 817
 818         adapter->netdev->fcoe_ddp_xid = 0;
 819
 820         if (!fcoe->ddp_pool)
 821                 return;
 822
 823         free_percpu(fcoe->ddp_pool);
 824         fcoe->ddp_pool = NULL;
 825 }
 826
 827 /**
 828  * ixgbe_fcoe_enable - turn on FCoE offload feature
 829  * @netdev: the corresponding netdev
 830  *
 831  * Turns on FCoE offload feature in 82599.
 832  *
 833  * Returns : 0 indicates success or -EINVAL on failure
 834  */
 835 int ixgbe_fcoe_enable(struct net_device *netdev)
 836 {
 837         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 838         struct ixgbe_fcoe *fcoe = &adapter->fcoe;
 839
 840         atomic_inc(&fcoe->refcnt);
 841
 842         if (!(adapter->flags & IXGBE_FLAG_FCOE_CAPABLE))
 843                 return -EINVAL;
 844
 845         if (adapter->flags & IXGBE_FLAG_FCOE_ENABLED)
 846                 return -EINVAL;
 847
 848         e_info(drv, "Enabling FCoE offload features.\n");
 849
 850         if (adapter->flags & IXGBE_FLAG_SRIOV_ENABLED)
 851                 e_warn(probe, "Enabling FCoE on PF will disable legacy VFs\n");
 852
 853         if (netif_running(netdev))
 854                 netdev->netdev_ops->ndo_stop(netdev);
 855
 856         /* Allocate per CPU memory to track DDP pools */
 857         ixgbe_fcoe_ddp_enable(adapter);
 858
 859         /* enable FCoE and notify stack */
 860         adapter->flags |= IXGBE_FLAG_FCOE_ENABLED;
 861         netdev->features |= NETIF_F_FCOE_MTU;
 862         netdev_features_change(netdev);
 863
 864         /* release existing queues and reallocate them */
 865         ixgbe_clear_interrupt_scheme(adapter);
 866         ixgbe_init_interrupt_scheme(adapter);
 867
 868         if (netif_running(netdev))
 869                 netdev->netdev_ops->ndo_open(netdev);
 870
 871         return 0;
 872 }
 873
 874 /**
 875  * ixgbe_fcoe_disable - turn off FCoE offload feature
 876  * @netdev: the corresponding netdev
 877  *
 878  * Turns off FCoE offload feature in 82599.
 879  *
 880  * Returns : 0 indicates success or -EINVAL on failure
 881  */
 882 int ixgbe_fcoe_disable(struct net_device *netdev)
 883 {
 884         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 885
 886         if (!atomic_dec_and_test(&adapter->fcoe.refcnt))
 887                 return -EINVAL;
 888
 889         if (!(adapter->flags & IXGBE_FLAG_FCOE_ENABLED))
 890                 return -EINVAL;
 891
 892         e_info(drv, "Disabling FCoE offload features.\n");
 893         if (netif_running(netdev))
 894                 netdev->netdev_ops->ndo_stop(netdev);
 895
 896         /* Free per CPU memory to track DDP pools */
 897         ixgbe_fcoe_ddp_disable(adapter);
 898
 899         /* disable FCoE and notify stack */
 900         adapter->flags &= ~IXGBE_FLAG_FCOE_ENABLED;
 901         netdev->features &= ~NETIF_F_FCOE_MTU;
 902
 903         netdev_features_change(netdev);
 904
 905         /* release existing queues and reallocate them */
 906         ixgbe_clear_interrupt_scheme(adapter);
 907         ixgbe_init_interrupt_scheme(adapter);
 908
 909         if (netif_running(netdev))
 910                 netdev->netdev_ops->ndo_open(netdev);
 911
 912         return 0;
 913 }
 914
 915 /**
 916  * ixgbe_fcoe_get_wwn - get world wide name for the node or the port
 917  * @netdev : ixgbe adapter
 918  * @wwn : the world wide name
 919  * @type: the type of world wide name
 920  *
 921  * Returns the node or port world wide name if both the prefix and the san
 922  * mac address are valid, then the wwn is formed based on the NAA-2 for
 923  * IEEE Extended name identifier (ref. to T10 FC-LS Spec., Sec. 15.3).
 924  *
 925  * Returns : 0 on success
 926  */
 927 int ixgbe_fcoe_get_wwn(struct net_device *netdev, u64 *wwn, int type)
 928 {
 929         u16 prefix = 0xffff;
 930         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 931         struct ixgbe_mac_info *mac = &adapter->hw.mac;
 932
 933         switch (type) {
 934         case NETDEV_FCOE_WWNN:
 935                 prefix = mac->wwnn_prefix;
 936                 break;
 937         case NETDEV_FCOE_WWPN:
 938                 prefix = mac->wwpn_prefix;
 939                 break;
 940         default:
 941                 break;
 942         }
 943
 944         if ((prefix != 0xffff) &&
 945             is_valid_ether_addr(mac->san_addr)) {
 946                 *wwn = ((u64) prefix << 48) |
 947                        ((u64) mac->san_addr[0] << 40) |
 948                        ((u64) mac->san_addr[1] << 32) |
 949                        ((u64) mac->san_addr[2] << 24) |
 950                        ((u64) mac->san_addr[3] << 16) |
 951                        ((u64) mac->san_addr[4] << 8)  |
 952                        ((u64) mac->san_addr[5]);
 953                 return 0;
 954         }
 955         return -EINVAL;
 956 }
 957
 958 /**
 959  * ixgbe_fcoe_get_hbainfo - get FCoE HBA information
 960  * @netdev : ixgbe adapter
 961  * @info : HBA information
 962  *
 963  * Returns ixgbe HBA information
 964  *
 965  * Returns : 0 on success
 966  */
 967 int ixgbe_fcoe_get_hbainfo(struct net_device *netdev,
 968                            struct netdev_fcoe_hbainfo *info)
 969 {
 970         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 971         struct ixgbe_hw *hw = &adapter->hw;
 972         u64 dsn;
 973
 974         if (!info)
 975                 return -EINVAL;
 976
 977         /* Don't return information on unsupported devices */
 978         if (!(adapter->flags & IXGBE_FLAG_FCOE_ENABLED))
 979                 return -EINVAL;
 980
 981         /* Manufacturer */
 982         snprintf(info->manufacturer, sizeof(info->manufacturer),
 983                  "Intel Corporation");
 984
 985         /* Serial Number */
 986
 987         /* Get the PCI-e Device Serial Number Capability */
 988         dsn = pci_get_dsn(adapter->pdev);
 989         if (dsn)
 990                 snprintf(info->serial_number, sizeof(info->serial_number),
 991                          "%016llX", dsn);
 992         else
 993                 snprintf(info->serial_number, sizeof(info->serial_number),
 994                          "Unknown");
 995
 996         /* Hardware Version */
 997         snprintf(info->hardware_version,
 998                  sizeof(info->hardware_version),
 999                  "Rev %d", hw->revision_id);
1000         /* Driver Name/Version */
1001         snprintf(info->driver_version,
1002                  sizeof(info->driver_version),
1003                  "%s v%s",
1004                  ixgbe_driver_name,
1005                  UTS_RELEASE);
1006         /* Firmware Version */
1007         strlcpy(info->firmware_version, adapter->eeprom_id,
1008                 sizeof(info->firmware_version));
1009
1010         /* Model */
1011         if (hw->mac.type == ixgbe_mac_82599EB) {
1012                 snprintf(info->model,
1013                          sizeof(info->model),
1014                          "Intel 82599");
1015         } else if (hw->mac.type == ixgbe_mac_X550) {
1016                 snprintf(info->model,
1017                          sizeof(info->model),
1018                          "Intel X550");
1019         } else {
1020                 snprintf(info->model,
1021                          sizeof(info->model),
1022                          "Intel X540");
1023         }
1024
1025         /* Model Description */
1026         snprintf(info->model_description,
1027                  sizeof(info->model_description),
1028                  "%s",
1029                  ixgbe_default_device_descr);
1030
1031         return 0;
1032 }
1033
1034 /**
1035  * ixgbe_fcoe_get_tc - get the current TC that fcoe is mapped to
1036  * @adapter: pointer to the device adapter structure
1037  *
1038  * Return : TC that FCoE is mapped to
1039  */
1040 u8 ixgbe_fcoe_get_tc(struct ixgbe_adapter *adapter)
1041 {
1042 #ifdef CONFIG_IXGBE_DCB
1043         return netdev_get_prio_tc_map(adapter->netdev, adapter->fcoe.up);
1044 #else
1045         return 0;
1046 #endif
1047 }