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_ATOMIC, &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_ATOMIC);
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 	int i, pos;
972 	u8 buf[8];
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 	pos = pci_find_ext_capability(adapter->pdev, PCI_EXT_CAP_ID_DSN);
989 	if (pos) {
990 		pos += 4;
991 		for (i = 0; i < 8; i++)
992 			pci_read_config_byte(adapter->pdev, pos + i, &buf[i]);
993 
994 		snprintf(info->serial_number, sizeof(info->serial_number),
995 			 "%02X%02X%02X%02X%02X%02X%02X%02X",
996 			 buf[7], buf[6], buf[5], buf[4],
997 			 buf[3], buf[2], buf[1], buf[0]);
998 	} else
999 		snprintf(info->serial_number, sizeof(info->serial_number),
1000 			 "Unknown");
1001 
1002 	/* Hardware Version */
1003 	snprintf(info->hardware_version,
1004 		 sizeof(info->hardware_version),
1005 		 "Rev %d", hw->revision_id);
1006 	/* Driver Name/Version */
1007 	snprintf(info->driver_version,
1008 		 sizeof(info->driver_version),
1009 		 "%s v%s",
1010 		 ixgbe_driver_name,
1011 		 ixgbe_driver_version);
1012 	/* Firmware Version */
1013 	strlcpy(info->firmware_version, adapter->eeprom_id,
1014 		sizeof(info->firmware_version));
1015 
1016 	/* Model */
1017 	if (hw->mac.type == ixgbe_mac_82599EB) {
1018 		snprintf(info->model,
1019 			 sizeof(info->model),
1020 			 "Intel 82599");
1021 	} else if (hw->mac.type == ixgbe_mac_X550) {
1022 		snprintf(info->model,
1023 			 sizeof(info->model),
1024 			 "Intel X550");
1025 	} else {
1026 		snprintf(info->model,
1027 			 sizeof(info->model),
1028 			 "Intel X540");
1029 	}
1030 
1031 	/* Model Description */
1032 	snprintf(info->model_description,
1033 		 sizeof(info->model_description),
1034 		 "%s",
1035 		 ixgbe_default_device_descr);
1036 
1037 	return 0;
1038 }
1039 
1040 /**
1041  * ixgbe_fcoe_get_tc - get the current TC that fcoe is mapped to
1042  * @adapter: pointer to the device adapter structure
1043  *
1044  * Return : TC that FCoE is mapped to
1045  */
1046 u8 ixgbe_fcoe_get_tc(struct ixgbe_adapter *adapter)
1047 {
1048 #ifdef CONFIG_IXGBE_DCB
1049 	return netdev_get_prio_tc_map(adapter->netdev, adapter->fcoe.up);
1050 #else
1051 	return 0;
1052 #endif
1053 }
1054