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