1 /*******************************************************************************
3 * Intel Ethernet Controller XL710 Family Linux Driver
4 * Copyright(c) 2013 - 2014 Intel Corporation.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License along
16 * with this program. If not, see <http://www.gnu.org/licenses/>.
18 * The full GNU General Public License is included in this distribution in
19 * the file called "COPYING".
21 * Contact Information:
22 * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
23 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
25 ******************************************************************************/
28 #include <linux/if_ether.h>
29 #include <scsi/scsi_cmnd.h>
30 #include <scsi/scsi_device.h>
31 #include <scsi/fc/fc_fs.h>
32 #include <scsi/fc/fc_fip.h>
33 #include <scsi/fc/fc_fcoe.h>
34 #include <scsi/libfc.h>
35 #include <scsi/libfcoe.h>
36 #include <uapi/linux/dcbnl.h>
39 #include "i40e_fcoe.h"
42 * i40e_rx_is_fcoe - returns true if the rx packet type is FCoE
43 * @ptype: the packet type field from rx descriptor write-back
45 static inline bool i40e_rx_is_fcoe(u16 ptype
)
47 return (ptype
>= I40E_RX_PTYPE_L2_FCOE_PAY3
) &&
48 (ptype
<= I40E_RX_PTYPE_L2_FCOE_VFT_FCOTHER
);
52 * i40e_fcoe_sof_is_class2 - returns true if this is a FC Class 2 SOF
53 * @sof: the FCoE start of frame delimiter
55 static inline bool i40e_fcoe_sof_is_class2(u8 sof
)
57 return (sof
== FC_SOF_I2
) || (sof
== FC_SOF_N2
);
61 * i40e_fcoe_sof_is_class3 - returns true if this is a FC Class 3 SOF
62 * @sof: the FCoE start of frame delimiter
64 static inline bool i40e_fcoe_sof_is_class3(u8 sof
)
66 return (sof
== FC_SOF_I3
) || (sof
== FC_SOF_N3
);
70 * i40e_fcoe_sof_is_supported - returns true if the FC SOF is supported by HW
71 * @sof: the input SOF value from the frame
73 static inline bool i40e_fcoe_sof_is_supported(u8 sof
)
75 return i40e_fcoe_sof_is_class2(sof
) ||
76 i40e_fcoe_sof_is_class3(sof
);
80 * i40e_fcoe_fc_sof - pull the SOF from FCoE header in the frame
81 * @skb: the frame whose EOF is to be pulled from
83 static inline int i40e_fcoe_fc_sof(struct sk_buff
*skb
, u8
*sof
)
85 *sof
= ((struct fcoe_hdr
*)skb_network_header(skb
))->fcoe_sof
;
87 if (!i40e_fcoe_sof_is_supported(*sof
))
93 * i40e_fcoe_eof_is_supported - returns true if the EOF is supported by HW
94 * @eof: the input EOF value from the frame
96 static inline bool i40e_fcoe_eof_is_supported(u8 eof
)
98 return (eof
== FC_EOF_N
) || (eof
== FC_EOF_T
) ||
99 (eof
== FC_EOF_NI
) || (eof
== FC_EOF_A
);
103 * i40e_fcoe_fc_eof - pull EOF from FCoE trailer in the frame
104 * @skb: the frame whose EOF is to be pulled from
106 static inline int i40e_fcoe_fc_eof(struct sk_buff
*skb
, u8
*eof
)
108 /* the first byte of the last dword is EOF */
109 skb_copy_bits(skb
, skb
->len
- 4, eof
, 1);
111 if (!i40e_fcoe_eof_is_supported(*eof
))
117 * i40e_fcoe_ctxt_eof - convert input FC EOF for descriptor programming
118 * @eof: the input eof value from the frame
120 * The FC EOF is converted to the value understood by HW for descriptor
121 * programming. Never call this w/o calling i40e_fcoe_eof_is_supported()
124 static inline u32
i40e_fcoe_ctxt_eof(u8 eof
)
128 return I40E_TX_DESC_CMD_L4T_EOFT_EOF_N
;
130 return I40E_TX_DESC_CMD_L4T_EOFT_EOF_T
;
132 return I40E_TX_DESC_CMD_L4T_EOFT_EOF_NI
;
134 return I40E_TX_DESC_CMD_L4T_EOFT_EOF_A
;
136 /* FIXME: still returns 0 */
137 pr_err("Unrecognized EOF %x\n", eof
);
143 * i40e_fcoe_xid_is_valid - returns true if the exchange id is valid
144 * @xid: the exchange id
146 static inline bool i40e_fcoe_xid_is_valid(u16 xid
)
148 return (xid
!= FC_XID_UNKNOWN
) && (xid
< I40E_FCOE_DDP_MAX
);
152 * i40e_fcoe_ddp_unmap - unmap the mapped sglist associated
154 * @ddp: sw DDP context
156 * Unmap the scatter-gather list associated with the given SW DDP context
158 * Returns: data length already ddp-ed in bytes
161 static inline void i40e_fcoe_ddp_unmap(struct i40e_pf
*pf
,
162 struct i40e_fcoe_ddp
*ddp
)
164 if (test_and_set_bit(__I40E_FCOE_DDP_UNMAPPED
, &ddp
->flags
))
168 dma_unmap_sg(&pf
->pdev
->dev
, ddp
->sgl
, ddp
->sgc
,
175 dma_pool_free(ddp
->pool
, ddp
->udl
, ddp
->udp
);
181 * i40e_fcoe_ddp_clear - clear the given SW DDP context
182 * @ddp - SW DDP context
184 static inline void i40e_fcoe_ddp_clear(struct i40e_fcoe_ddp
*ddp
)
186 memset(ddp
, 0, sizeof(struct i40e_fcoe_ddp
));
187 ddp
->xid
= FC_XID_UNKNOWN
;
188 ddp
->flags
= __I40E_FCOE_DDP_NONE
;
192 * i40e_fcoe_progid_is_fcoe - check if the prog_id is for FCoE
193 * @id: the prog id for the programming status Rx descriptor write-back
195 static inline bool i40e_fcoe_progid_is_fcoe(u8 id
)
197 return (id
== I40E_RX_PROG_STATUS_DESC_FCOE_CTXT_PROG_STATUS
) ||
198 (id
== I40E_RX_PROG_STATUS_DESC_FCOE_CTXT_INVL_STATUS
);
202 * i40e_fcoe_fc_get_xid - get xid from the frame header
203 * @fh: the fc frame header
205 * In case the incoming frame's exchange is originated from
206 * the initiator, then received frame's exchange id is ANDed
207 * with fc_cpu_mask bits to get the same cpu on which exchange
208 * was originated, otherwise just use the current cpu.
210 * Returns ox_id if exchange originator, rx_id if responder
212 static inline u16
i40e_fcoe_fc_get_xid(struct fc_frame_header
*fh
)
214 u32 f_ctl
= ntoh24(fh
->fh_f_ctl
);
216 return (f_ctl
& FC_FC_EX_CTX
) ?
217 be16_to_cpu(fh
->fh_ox_id
) :
218 be16_to_cpu(fh
->fh_rx_id
);
222 * i40e_fcoe_fc_frame_header - get fc frame header from skb
225 * This checks if there is a VLAN header and returns the data
226 * pointer to the start of the fc_frame_header.
228 * Returns pointer to the fc_frame_header
230 static inline struct fc_frame_header
*i40e_fcoe_fc_frame_header(
233 void *fh
= skb
->data
+ sizeof(struct fcoe_hdr
);
235 if (eth_hdr(skb
)->h_proto
== htons(ETH_P_8021Q
))
236 fh
+= sizeof(struct vlan_hdr
);
238 return (struct fc_frame_header
*)fh
;
242 * i40e_fcoe_ddp_put - release the DDP context for a given exchange id
243 * @netdev: the corresponding net_device
244 * @xid: the exchange id that corresponding DDP context will be released
246 * This is the implementation of net_device_ops.ndo_fcoe_ddp_done
247 * and it is expected to be called by ULD, i.e., FCP layer of libfc
248 * to release the corresponding ddp context when the I/O is done.
250 * Returns : data length already ddp-ed in bytes
252 static int i40e_fcoe_ddp_put(struct net_device
*netdev
, u16 xid
)
254 struct i40e_netdev_priv
*np
= netdev_priv(netdev
);
255 struct i40e_pf
*pf
= np
->vsi
->back
;
256 struct i40e_fcoe
*fcoe
= &pf
->fcoe
;
258 struct i40e_fcoe_ddp
*ddp
= &fcoe
->ddp
[xid
];
263 if (test_bit(__I40E_FCOE_DDP_DONE
, &ddp
->flags
))
265 i40e_fcoe_ddp_unmap(pf
, ddp
);
271 * i40e_fcoe_sw_init - sets up the HW for FCoE
274 * Returns 0 if FCoE is supported otherwise the error code
276 int i40e_init_pf_fcoe(struct i40e_pf
*pf
)
278 struct i40e_hw
*hw
= &pf
->hw
;
281 pf
->flags
&= ~I40E_FLAG_FCOE_ENABLED
;
282 pf
->num_fcoe_qps
= 0;
283 pf
->fcoe_hmc_cntx_num
= 0;
284 pf
->fcoe_hmc_filt_num
= 0;
286 if (!pf
->hw
.func_caps
.fcoe
) {
287 dev_info(&pf
->pdev
->dev
, "FCoE capability is disabled\n");
291 if (!pf
->hw
.func_caps
.dcb
) {
292 dev_warn(&pf
->pdev
->dev
,
293 "Hardware is not DCB capable not enabling FCoE.\n");
297 /* enable FCoE hash filter */
298 val
= rd32(hw
, I40E_PFQF_HENA(1));
299 val
|= 1 << (I40E_FILTER_PCTYPE_FCOE_OX
- 32);
300 val
|= 1 << (I40E_FILTER_PCTYPE_FCOE_RX
- 32);
301 val
&= I40E_PFQF_HENA_PTYPE_ENA_MASK
;
302 wr32(hw
, I40E_PFQF_HENA(1), val
);
305 pf
->flags
|= I40E_FLAG_FCOE_ENABLED
;
306 pf
->num_fcoe_qps
= I40E_DEFAULT_FCOE
;
308 /* Reserve 4K DDP contexts and 20K filter size for FCoE */
309 pf
->fcoe_hmc_cntx_num
= (1 << I40E_DMA_CNTX_SIZE_4K
) *
310 I40E_DMA_CNTX_BASE_SIZE
;
311 pf
->fcoe_hmc_filt_num
= pf
->fcoe_hmc_cntx_num
+
312 (1 << I40E_HASH_FILTER_SIZE_16K
) *
313 I40E_HASH_FILTER_BASE_SIZE
;
315 /* FCoE object: max 16K filter buckets and 4K DMA contexts */
316 pf
->filter_settings
.fcoe_filt_num
= I40E_HASH_FILTER_SIZE_16K
;
317 pf
->filter_settings
.fcoe_cntx_num
= I40E_DMA_CNTX_SIZE_4K
;
319 /* Setup max frame with FCoE_MTU plus L2 overheads */
320 val
= rd32(hw
, I40E_GLFCOE_RCTL
);
321 val
&= ~I40E_GLFCOE_RCTL_MAX_SIZE_MASK
;
322 val
|= ((FCOE_MTU
+ ETH_HLEN
+ VLAN_HLEN
+ ETH_FCS_LEN
)
323 << I40E_GLFCOE_RCTL_MAX_SIZE_SHIFT
);
324 wr32(hw
, I40E_GLFCOE_RCTL
, val
);
326 dev_info(&pf
->pdev
->dev
, "FCoE is supported.\n");
331 * i40e_get_fcoe_tc_map - Return TC map for FCoE APP
335 u8
i40e_get_fcoe_tc_map(struct i40e_pf
*pf
)
337 struct i40e_dcb_app_priority_table app
;
338 struct i40e_hw
*hw
= &pf
->hw
;
341 /* Get the FCoE APP TLV */
342 struct i40e_dcbx_config
*dcbcfg
= &hw
->local_dcbx_config
;
344 for (i
= 0; i
< dcbcfg
->numapps
; i
++) {
345 app
= dcbcfg
->app
[i
];
346 if (app
.selector
== IEEE_8021QAZ_APP_SEL_ETHERTYPE
&&
347 app
.protocolid
== ETH_P_FCOE
) {
348 tc
= dcbcfg
->etscfg
.prioritytable
[app
.priority
];
349 enabled_tc
|= (1 << tc
);
354 /* TC0 if there is no TC defined for FCoE APP TLV */
355 enabled_tc
= enabled_tc
? enabled_tc
: 0x1;
361 * i40e_fcoe_vsi_init - prepares the VSI context for creating a FCoE VSI
362 * @vsi: pointer to the associated VSI struct
363 * @ctxt: pointer to the associated VSI context to be passed to HW
365 * Returns 0 on success or < 0 on error
367 int i40e_fcoe_vsi_init(struct i40e_vsi
*vsi
, struct i40e_vsi_context
*ctxt
)
369 struct i40e_aqc_vsi_properties_data
*info
= &ctxt
->info
;
370 struct i40e_pf
*pf
= vsi
->back
;
371 struct i40e_hw
*hw
= &pf
->hw
;
374 if (!(pf
->flags
& I40E_FLAG_FCOE_ENABLED
)) {
375 dev_err(&pf
->pdev
->dev
,
376 "FCoE is not enabled for this device\n");
380 /* initialize the hardware for FCoE */
381 ctxt
->pf_num
= hw
->pf_id
;
383 ctxt
->uplink_seid
= vsi
->uplink_seid
;
384 ctxt
->connection_type
= 0x1;
385 ctxt
->flags
= I40E_AQ_VSI_TYPE_PF
;
387 /* FCoE VSI would need the following sections */
388 info
->valid_sections
|= cpu_to_le16(I40E_AQ_VSI_PROP_SWITCH_VALID
|
389 I40E_AQ_VSI_PROP_QUEUE_OPT_VALID
);
391 /* FCoE VSI does not need these sections */
392 info
->valid_sections
&= cpu_to_le16(~(I40E_AQ_VSI_PROP_SECURITY_VALID
|
393 I40E_AQ_VSI_PROP_VLAN_VALID
|
394 I40E_AQ_VSI_PROP_CAS_PV_VALID
|
395 I40E_AQ_VSI_PROP_INGRESS_UP_VALID
|
396 I40E_AQ_VSI_PROP_EGRESS_UP_VALID
));
398 info
->switch_id
= cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB
);
399 enabled_tc
= i40e_get_fcoe_tc_map(pf
);
400 i40e_vsi_setup_queue_map(vsi
, ctxt
, enabled_tc
, true);
402 /* set up queue option section: only enable FCoE */
403 info
->queueing_opt_flags
= I40E_AQ_VSI_QUE_OPT_FCOE_ENA
;
409 * i40e_fcoe_enable - this is the implementation of ndo_fcoe_enable,
410 * indicating the upper FCoE protocol stack is ready to use FCoE
413 * @netdev: pointer to the netdev that FCoE is created on
415 * Returns 0 on success
420 int i40e_fcoe_enable(struct net_device
*netdev
)
422 struct i40e_netdev_priv
*np
= netdev_priv(netdev
);
423 struct i40e_vsi
*vsi
= np
->vsi
;
424 struct i40e_pf
*pf
= vsi
->back
;
425 struct i40e_fcoe
*fcoe
= &pf
->fcoe
;
427 if (!(pf
->flags
& I40E_FLAG_FCOE_ENABLED
)) {
428 netdev_err(netdev
, "HW does not support FCoE.\n");
432 if (vsi
->type
!= I40E_VSI_FCOE
) {
433 netdev_err(netdev
, "interface does not support FCoE.\n");
437 atomic_inc(&fcoe
->refcnt
);
443 * i40e_fcoe_disable- disables FCoE for upper FCoE protocol stack.
444 * @dev: pointer to the netdev that FCoE is created on
446 * Returns 0 on success
449 int i40e_fcoe_disable(struct net_device
*netdev
)
451 struct i40e_netdev_priv
*np
= netdev_priv(netdev
);
452 struct i40e_vsi
*vsi
= np
->vsi
;
453 struct i40e_pf
*pf
= vsi
->back
;
454 struct i40e_fcoe
*fcoe
= &pf
->fcoe
;
456 if (!(pf
->flags
& I40E_FLAG_FCOE_ENABLED
)) {
457 netdev_err(netdev
, "device does not support FCoE\n");
460 if (vsi
->type
!= I40E_VSI_FCOE
)
463 if (!atomic_dec_and_test(&fcoe
->refcnt
))
466 netdev_info(netdev
, "FCoE disabled\n");
472 * i40e_fcoe_dma_pool_free - free the per cpu pool for FCoE DDP
473 * @fcoe: the FCoE sw object
474 * @dev: the device that the pool is associated with
475 * @cpu: the cpu for this pool
478 static void i40e_fcoe_dma_pool_free(struct i40e_fcoe
*fcoe
,
482 struct i40e_fcoe_ddp_pool
*ddp_pool
;
484 ddp_pool
= per_cpu_ptr(fcoe
->ddp_pool
, cpu
);
485 if (!ddp_pool
->pool
) {
486 dev_warn(dev
, "DDP pool already freed for cpu %d\n", cpu
);
489 dma_pool_destroy(ddp_pool
->pool
);
490 ddp_pool
->pool
= NULL
;
494 * i40e_fcoe_dma_pool_create - per cpu pool for FCoE DDP
495 * @fcoe: the FCoE sw object
496 * @dev: the device that the pool is associated with
497 * @cpu: the cpu for this pool
499 * Returns 0 on successful or non zero on failure
502 static int i40e_fcoe_dma_pool_create(struct i40e_fcoe
*fcoe
,
506 struct i40e_fcoe_ddp_pool
*ddp_pool
;
507 struct dma_pool
*pool
;
510 ddp_pool
= per_cpu_ptr(fcoe
->ddp_pool
, cpu
);
511 if (ddp_pool
&& ddp_pool
->pool
) {
512 dev_warn(dev
, "DDP pool already allocated for cpu %d\n", cpu
);
515 snprintf(pool_name
, sizeof(pool_name
), "i40e_fcoe_ddp_%d", cpu
);
516 pool
= dma_pool_create(pool_name
, dev
, I40E_FCOE_DDP_PTR_MAX
,
517 I40E_FCOE_DDP_PTR_ALIGN
, PAGE_SIZE
);
519 dev_err(dev
, "dma_pool_create %s failed\n", pool_name
);
522 ddp_pool
->pool
= pool
;
527 * i40e_fcoe_free_ddp_resources - release FCoE DDP resources
528 * @vsi: the vsi FCoE is associated with
531 void i40e_fcoe_free_ddp_resources(struct i40e_vsi
*vsi
)
533 struct i40e_pf
*pf
= vsi
->back
;
534 struct i40e_fcoe
*fcoe
= &pf
->fcoe
;
537 /* do nothing if not FCoE VSI */
538 if (vsi
->type
!= I40E_VSI_FCOE
)
541 /* do nothing if no DDP pools were allocated */
545 for (i
= 0; i
< I40E_FCOE_DDP_MAX
; i
++)
546 i40e_fcoe_ddp_put(vsi
->netdev
, i
);
548 for_each_possible_cpu(cpu
)
549 i40e_fcoe_dma_pool_free(fcoe
, &pf
->pdev
->dev
, cpu
);
551 free_percpu(fcoe
->ddp_pool
);
552 fcoe
->ddp_pool
= NULL
;
554 netdev_info(vsi
->netdev
, "VSI %d,%d FCoE DDP resources released\n",
559 * i40e_fcoe_setup_ddp_resources - allocate per cpu DDP resources
560 * @vsi: the VSI FCoE is associated with
562 * Returns 0 on successful or non zero on failure
565 int i40e_fcoe_setup_ddp_resources(struct i40e_vsi
*vsi
)
567 struct i40e_pf
*pf
= vsi
->back
;
568 struct device
*dev
= &pf
->pdev
->dev
;
569 struct i40e_fcoe
*fcoe
= &pf
->fcoe
;
573 if (vsi
->type
!= I40E_VSI_FCOE
)
576 /* do nothing if no DDP pools were allocated */
580 /* allocate per CPU memory to track DDP pools */
581 fcoe
->ddp_pool
= alloc_percpu(struct i40e_fcoe_ddp_pool
);
582 if (!fcoe
->ddp_pool
) {
583 dev_err(&pf
->pdev
->dev
, "failed to allocate percpu DDP\n");
587 /* allocate pci pool for each cpu */
588 for_each_possible_cpu(cpu
) {
589 if (!i40e_fcoe_dma_pool_create(fcoe
, dev
, cpu
))
592 dev_err(dev
, "failed to alloc DDP pool on cpu:%d\n", cpu
);
593 i40e_fcoe_free_ddp_resources(vsi
);
597 /* initialize the sw context */
598 for (i
= 0; i
< I40E_FCOE_DDP_MAX
; i
++)
599 i40e_fcoe_ddp_clear(&fcoe
->ddp
[i
]);
601 netdev_info(vsi
->netdev
, "VSI %d,%d FCoE DDP resources allocated\n",
608 * i40e_fcoe_handle_status - check the Programming Status for FCoE
609 * @rx_ring: the Rx ring for this descriptor
610 * @rx_desc: the Rx descriptor for Programming Status, not a packet descriptor.
612 * Check if this is the Rx Programming Status descriptor write-back for FCoE.
613 * This is used to verify if the context/filter programming or invalidation
614 * requested by SW to the HW is successful or not and take actions accordingly.
616 void i40e_fcoe_handle_status(struct i40e_ring
*rx_ring
,
617 union i40e_rx_desc
*rx_desc
, u8 prog_id
)
619 struct i40e_pf
*pf
= rx_ring
->vsi
->back
;
620 struct i40e_fcoe
*fcoe
= &pf
->fcoe
;
621 struct i40e_fcoe_ddp
*ddp
;
626 /* we only care for FCoE here */
627 if (!i40e_fcoe_progid_is_fcoe(prog_id
))
630 xid
= le32_to_cpu(rx_desc
->wb
.qword0
.hi_dword
.fcoe_param
) &
631 (I40E_FCOE_DDP_MAX
- 1);
633 if (!i40e_fcoe_xid_is_valid(xid
))
636 ddp
= &fcoe
->ddp
[xid
];
637 WARN_ON(xid
!= ddp
->xid
);
639 qw
= le64_to_cpu(rx_desc
->wb
.qword1
.status_error_len
);
640 error
= (qw
& I40E_RX_PROG_STATUS_DESC_QW1_ERROR_MASK
) >>
641 I40E_RX_PROG_STATUS_DESC_QW1_ERROR_SHIFT
;
643 /* DDP context programming status: failure or success */
644 if (prog_id
== I40E_RX_PROG_STATUS_DESC_FCOE_CTXT_PROG_STATUS
) {
645 if (I40E_RX_PROG_FCOE_ERROR_TBL_FULL(error
)) {
646 dev_err(&pf
->pdev
->dev
, "xid %x ddp->xid %x TABLE FULL\n",
648 ddp
->prerr
|= I40E_RX_PROG_FCOE_ERROR_TBL_FULL_BIT
;
650 if (I40E_RX_PROG_FCOE_ERROR_CONFLICT(error
)) {
651 dev_err(&pf
->pdev
->dev
, "xid %x ddp->xid %x CONFLICT\n",
653 ddp
->prerr
|= I40E_RX_PROG_FCOE_ERROR_CONFLICT_BIT
;
657 /* DDP context invalidation status: failure or success */
658 if (prog_id
== I40E_RX_PROG_STATUS_DESC_FCOE_CTXT_INVL_STATUS
) {
659 if (I40E_RX_PROG_FCOE_ERROR_INVLFAIL(error
)) {
660 dev_err(&pf
->pdev
->dev
, "xid %x ddp->xid %x INVALIDATION FAILURE\n",
662 ddp
->prerr
|= I40E_RX_PROG_FCOE_ERROR_INVLFAIL_BIT
;
664 /* clear the flag so we can retry invalidation */
665 clear_bit(__I40E_FCOE_DDP_ABORTED
, &ddp
->flags
);
669 i40e_fcoe_ddp_unmap(pf
, ddp
);
670 i40e_fcoe_ddp_clear(ddp
);
674 * i40e_fcoe_handle_offload - check ddp status and mark it done
675 * @adapter: i40e adapter
676 * @rx_desc: advanced rx descriptor
677 * @skb: the skb holding the received data
679 * This checks ddp status.
681 * Returns : < 0 indicates an error or not a FCOE ddp, 0 indicates
682 * not passing the skb to ULD, > 0 indicates is the length of data
686 int i40e_fcoe_handle_offload(struct i40e_ring
*rx_ring
,
687 union i40e_rx_desc
*rx_desc
,
690 struct i40e_pf
*pf
= rx_ring
->vsi
->back
;
691 struct i40e_fcoe
*fcoe
= &pf
->fcoe
;
692 struct fc_frame_header
*fh
= NULL
;
693 struct i40e_fcoe_ddp
*ddp
= NULL
;
701 /* check this rxd is for programming status */
702 qw
= le64_to_cpu(rx_desc
->wb
.qword1
.status_error_len
);
703 /* packet descriptor, check packet type */
704 ptype
= (qw
& I40E_RXD_QW1_PTYPE_MASK
) >> I40E_RXD_QW1_PTYPE_SHIFT
;
705 if (!i40e_rx_is_fcoe(ptype
))
708 error
= (qw
& I40E_RXD_QW1_ERROR_MASK
) >> I40E_RXD_QW1_ERROR_SHIFT
;
709 fcerr
= (error
>> I40E_RX_DESC_ERROR_L3L4E_SHIFT
) &
710 I40E_RX_DESC_FCOE_ERROR_MASK
;
712 /* check stateless offload error */
713 if (unlikely(fcerr
== I40E_RX_DESC_ERROR_L3L4E_PROT
)) {
714 dev_err(&pf
->pdev
->dev
, "Protocol Error\n");
715 skb
->ip_summed
= CHECKSUM_NONE
;
717 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
720 /* check hw status on ddp */
721 status
= (qw
& I40E_RXD_QW1_STATUS_MASK
) >> I40E_RXD_QW1_STATUS_SHIFT
;
722 fltstat
= (status
>> I40E_RX_DESC_STATUS_FLTSTAT_SHIFT
) &
723 I40E_RX_DESC_FLTSTAT_FCMASK
;
725 /* now we are ready to check DDP */
726 fh
= i40e_fcoe_fc_frame_header(skb
);
727 xid
= i40e_fcoe_fc_get_xid(fh
);
728 if (!i40e_fcoe_xid_is_valid(xid
))
731 /* non DDP normal receive, return to the protocol stack */
732 if (fltstat
== I40E_RX_DESC_FLTSTAT_NOMTCH
)
735 /* do we have a sw ddp context setup ? */
736 ddp
= &fcoe
->ddp
[xid
];
740 /* fetch xid from hw rxd wb, which should match up the sw ctxt */
741 xid
= le16_to_cpu(rx_desc
->wb
.qword0
.lo_dword
.mirr_fcoe
.fcoe_ctx_id
);
742 if (ddp
->xid
!= xid
) {
743 dev_err(&pf
->pdev
->dev
, "xid 0x%x does not match ctx_xid 0x%x\n",
748 /* the same exchange has already errored out */
750 dev_err(&pf
->pdev
->dev
, "xid 0x%x fcerr 0x%x reported fcer 0x%x\n",
751 xid
, ddp
->fcerr
, fcerr
);
755 /* fcoe param is valid by now with correct DDPed length */
756 ddp
->len
= le32_to_cpu(rx_desc
->wb
.qword0
.hi_dword
.fcoe_param
);
758 /* header posting only, useful only for target mode and debugging */
759 if (fltstat
== I40E_RX_DESC_FLTSTAT_DDP
) {
760 /* For target mode, we get header of the last packet but it
761 * does not have the FCoE trailer field, i.e., CRC and EOF
762 * Ordered Set since they are offloaded by the HW, so fill
763 * it up correspondingly to allow the packet to pass through
764 * to the upper protocol stack.
766 u32 f_ctl
= ntoh24(fh
->fh_f_ctl
);
768 if ((f_ctl
& FC_FC_END_SEQ
) &&
769 (fh
->fh_r_ctl
== FC_RCTL_DD_SOL_DATA
)) {
770 struct fcoe_crc_eof
*crc
= NULL
;
772 crc
= (struct fcoe_crc_eof
*)skb_put(skb
, sizeof(*crc
));
773 crc
->fcoe_eof
= FC_EOF_T
;
775 /* otherwise, drop the header only frame */
782 /* either we got RSP or we have an error, unmap DMA in both cases */
783 i40e_fcoe_ddp_unmap(pf
, ddp
);
784 if (ddp
->len
&& !ddp
->fcerr
) {
788 i40e_fcoe_ddp_clear(ddp
);
790 pkts
= DIV_ROUND_UP(rc
, 2048);
791 rx_ring
->stats
.bytes
+= rc
;
792 rx_ring
->stats
.packets
+= pkts
;
793 rx_ring
->q_vector
->rx
.total_bytes
+= rc
;
794 rx_ring
->q_vector
->rx
.total_packets
+= pkts
;
795 set_bit(__I40E_FCOE_DDP_DONE
, &ddp
->flags
);
803 * i40e_fcoe_ddp_setup - called to set up ddp context
804 * @netdev: the corresponding net_device
805 * @xid: the exchange id requesting ddp
806 * @sgl: the scatter-gather list for this request
807 * @sgc: the number of scatter-gather items
808 * @target_mode: indicates this is a DDP request for target
810 * Returns : 1 for success and 0 for no DDP on this I/O
812 static int i40e_fcoe_ddp_setup(struct net_device
*netdev
, u16 xid
,
813 struct scatterlist
*sgl
, unsigned int sgc
,
816 static const unsigned int bufflen
= I40E_FCOE_DDP_BUF_MIN
;
817 struct i40e_netdev_priv
*np
= netdev_priv(netdev
);
818 struct i40e_fcoe_ddp_pool
*ddp_pool
;
819 struct i40e_pf
*pf
= np
->vsi
->back
;
820 struct i40e_fcoe
*fcoe
= &pf
->fcoe
;
821 unsigned int i
, j
, dmacount
;
822 struct i40e_fcoe_ddp
*ddp
;
823 unsigned int firstoff
= 0;
824 unsigned int thisoff
= 0;
825 unsigned int thislen
= 0;
826 struct scatterlist
*sg
;
830 if (xid
>= I40E_FCOE_DDP_MAX
) {
831 dev_warn(&pf
->pdev
->dev
, "xid=0x%x out-of-range\n", xid
);
835 /* no DDP if we are already down or resetting */
836 if (test_bit(__I40E_DOWN
, &pf
->state
) ||
837 test_bit(__I40E_NEEDS_RESTART
, &pf
->state
)) {
838 dev_info(&pf
->pdev
->dev
, "xid=0x%x device in reset/down\n",
843 ddp
= &fcoe
->ddp
[xid
];
845 dev_info(&pf
->pdev
->dev
, "xid 0x%x w/ non-null sgl=%p nents=%d\n",
846 xid
, ddp
->sgl
, ddp
->sgc
);
849 i40e_fcoe_ddp_clear(ddp
);
851 if (!fcoe
->ddp_pool
) {
852 dev_info(&pf
->pdev
->dev
, "No DDP pool, xid 0x%x\n", xid
);
856 ddp_pool
= per_cpu_ptr(fcoe
->ddp_pool
, get_cpu());
857 if (!ddp_pool
->pool
) {
858 dev_info(&pf
->pdev
->dev
, "No percpu ddp pool, xid 0x%x\n", xid
);
862 /* setup dma from scsi command sgl */
863 dmacount
= dma_map_sg(&pf
->pdev
->dev
, sgl
, sgc
, DMA_FROM_DEVICE
);
865 dev_info(&pf
->pdev
->dev
, "dma_map_sg for sgl %p, sgc %d failed\n",
867 goto out_noddp_unmap
;
870 /* alloc the udl from our ddp pool */
871 ddp
->udl
= dma_pool_alloc(ddp_pool
->pool
, GFP_ATOMIC
, &ddp
->udp
);
873 dev_info(&pf
->pdev
->dev
,
874 "Failed allocated ddp context, xid 0x%x\n", xid
);
875 goto out_noddp_unmap
;
880 for_each_sg(sgl
, sg
, dmacount
, i
) {
881 addr
= sg_dma_address(sg
);
882 len
= sg_dma_len(sg
);
885 /* max number of buffers allowed in one DDP context */
886 if (j
>= I40E_FCOE_DDP_BUFFCNT_MAX
) {
887 dev_info(&pf
->pdev
->dev
,
888 "xid=%x:%d,%d,%d:addr=%llx not enough descriptors\n",
889 xid
, i
, j
, dmacount
, (u64
)addr
);
893 /* get the offset of length of current buffer */
894 thisoff
= addr
& ((dma_addr_t
)bufflen
- 1);
895 thislen
= min_t(unsigned int, (bufflen
- thisoff
), len
);
896 /* all but the 1st buffer (j == 0)
897 * must be aligned on bufflen
899 if ((j
!= 0) && (thisoff
))
902 /* all but the last buffer
903 * ((i == (dmacount - 1)) && (thislen == len))
904 * must end at bufflen
906 if (((i
!= (dmacount
- 1)) || (thislen
!= len
)) &&
907 ((thislen
+ thisoff
) != bufflen
))
910 ddp
->udl
[j
] = (u64
)(addr
- thisoff
);
911 /* only the first buffer may have none-zero offset */
919 /* only the last buffer may have non-full bufflen */
920 ddp
->lastsize
= thisoff
+ thislen
;
921 ddp
->firstoff
= firstoff
;
923 ddp
->pool
= ddp_pool
->pool
;
928 set_bit(__I40E_FCOE_DDP_TARGET
, &ddp
->flags
);
929 set_bit(__I40E_FCOE_DDP_INITALIZED
, &ddp
->flags
);
932 return 1; /* Success */
935 dma_pool_free(ddp
->pool
, ddp
->udl
, ddp
->udp
);
936 i40e_fcoe_ddp_clear(ddp
);
939 dma_unmap_sg(&pf
->pdev
->dev
, sgl
, sgc
, DMA_FROM_DEVICE
);
946 * i40e_fcoe_ddp_get - called to set up ddp context in initiator mode
947 * @netdev: the corresponding net_device
948 * @xid: the exchange id requesting ddp
949 * @sgl: the scatter-gather list for this request
950 * @sgc: the number of scatter-gather items
952 * This is the implementation of net_device_ops.ndo_fcoe_ddp_setup
953 * and is expected to be called from ULD, e.g., FCP layer of libfc
954 * to set up ddp for the corresponding xid of the given sglist for
955 * the corresponding I/O.
957 * Returns : 1 for success and 0 for no ddp
959 static int i40e_fcoe_ddp_get(struct net_device
*netdev
, u16 xid
,
960 struct scatterlist
*sgl
, unsigned int sgc
)
962 return i40e_fcoe_ddp_setup(netdev
, xid
, sgl
, sgc
, 0);
966 * i40e_fcoe_ddp_target - called to set up ddp context in target mode
967 * @netdev: the corresponding net_device
968 * @xid: the exchange id requesting ddp
969 * @sgl: the scatter-gather list for this request
970 * @sgc: the number of scatter-gather items
972 * This is the implementation of net_device_ops.ndo_fcoe_ddp_target
973 * and is expected to be called from ULD, e.g., FCP layer of libfc
974 * to set up ddp for the corresponding xid of the given sglist for
975 * the corresponding I/O. The DDP in target mode is a write I/O request
976 * from the initiator.
978 * Returns : 1 for success and 0 for no ddp
980 static int i40e_fcoe_ddp_target(struct net_device
*netdev
, u16 xid
,
981 struct scatterlist
*sgl
, unsigned int sgc
)
983 return i40e_fcoe_ddp_setup(netdev
, xid
, sgl
, sgc
, 1);
987 * i40e_fcoe_program_ddp - programs the HW DDP related descriptors
988 * @tx_ring: transmit ring for this packet
989 * @skb: the packet to be sent out
990 * @sof: the SOF to indicate class of service
992 * Determine if it is READ/WRITE command, and finds out if there is
993 * a matching SW DDP context for this command. DDP is applicable
994 * only in case of READ if initiator or WRITE in case of
995 * responder (via checking XFER_RDY).
997 * Note: caller checks sof and ddp sw context
1002 static void i40e_fcoe_program_ddp(struct i40e_ring
*tx_ring
,
1003 struct sk_buff
*skb
,
1004 struct i40e_fcoe_ddp
*ddp
, u8 sof
)
1006 struct i40e_fcoe_filter_context_desc
*filter_desc
= NULL
;
1007 struct i40e_fcoe_queue_context_desc
*queue_desc
= NULL
;
1008 struct i40e_fcoe_ddp_context_desc
*ddp_desc
= NULL
;
1009 struct i40e_pf
*pf
= tx_ring
->vsi
->back
;
1010 u16 i
= tx_ring
->next_to_use
;
1011 struct fc_frame_header
*fh
;
1012 u64 flags_rsvd_lanq
= 0;
1015 /* check if abort is still pending */
1016 if (test_bit(__I40E_FCOE_DDP_ABORTED
, &ddp
->flags
)) {
1017 dev_warn(&pf
->pdev
->dev
,
1018 "DDP abort is still pending xid:%hx and ddp->flags:%lx:\n",
1019 ddp
->xid
, ddp
->flags
);
1023 /* set the flag to indicate this is programmed */
1024 if (test_and_set_bit(__I40E_FCOE_DDP_PROGRAMMED
, &ddp
->flags
)) {
1025 dev_warn(&pf
->pdev
->dev
,
1026 "DDP is already programmed for xid:%hx and ddp->flags:%lx:\n",
1027 ddp
->xid
, ddp
->flags
);
1031 /* Prepare the DDP context descriptor */
1032 ddp_desc
= I40E_DDP_CONTEXT_DESC(tx_ring
, i
);
1034 if (i
== tx_ring
->count
)
1037 ddp_desc
->type_cmd_foff_lsize
=
1038 cpu_to_le64(I40E_TX_DESC_DTYPE_DDP_CTX
|
1039 ((u64
)I40E_FCOE_DDP_CTX_DESC_BSIZE_4K
<<
1040 I40E_FCOE_DDP_CTX_QW1_CMD_SHIFT
) |
1041 ((u64
)ddp
->firstoff
<<
1042 I40E_FCOE_DDP_CTX_QW1_FOFF_SHIFT
) |
1043 ((u64
)ddp
->lastsize
<<
1044 I40E_FCOE_DDP_CTX_QW1_LSIZE_SHIFT
));
1045 ddp_desc
->rsvd
= cpu_to_le64(0);
1047 /* target mode needs last packet in the sequence */
1048 target_mode
= test_bit(__I40E_FCOE_DDP_TARGET
, &ddp
->flags
);
1050 ddp_desc
->type_cmd_foff_lsize
|=
1051 cpu_to_le64(I40E_FCOE_DDP_CTX_DESC_LASTSEQH
);
1053 /* Prepare queue_context descriptor */
1054 queue_desc
= I40E_QUEUE_CONTEXT_DESC(tx_ring
, i
++);
1055 if (i
== tx_ring
->count
)
1057 queue_desc
->dmaindx_fbase
= cpu_to_le64(ddp
->xid
| ((u64
)ddp
->udp
));
1058 queue_desc
->flen_tph
= cpu_to_le64(ddp
->list_len
|
1059 ((u64
)(I40E_FCOE_QUEUE_CTX_DESC_TPHRDESC
|
1060 I40E_FCOE_QUEUE_CTX_DESC_TPHDATA
) <<
1061 I40E_FCOE_QUEUE_CTX_QW1_TPH_SHIFT
));
1063 /* Prepare filter_context_desc */
1064 filter_desc
= I40E_FILTER_CONTEXT_DESC(tx_ring
, i
);
1066 if (i
== tx_ring
->count
)
1069 fh
= (struct fc_frame_header
*)skb_transport_header(skb
);
1070 filter_desc
->param
= cpu_to_le32(ntohl(fh
->fh_parm_offset
));
1071 filter_desc
->seqn
= cpu_to_le16(ntohs(fh
->fh_seq_cnt
));
1072 filter_desc
->rsvd_dmaindx
= cpu_to_le16(ddp
->xid
<<
1073 I40E_FCOE_FILTER_CTX_QW0_DMAINDX_SHIFT
);
1075 flags_rsvd_lanq
= I40E_FCOE_FILTER_CTX_DESC_CTYP_DDP
;
1076 flags_rsvd_lanq
|= (u64
)(target_mode
?
1077 I40E_FCOE_FILTER_CTX_DESC_ENODE_RSP
:
1078 I40E_FCOE_FILTER_CTX_DESC_ENODE_INIT
);
1080 flags_rsvd_lanq
|= (u64
)((sof
== FC_SOF_I2
|| sof
== FC_SOF_N2
) ?
1081 I40E_FCOE_FILTER_CTX_DESC_FC_CLASS2
:
1082 I40E_FCOE_FILTER_CTX_DESC_FC_CLASS3
);
1084 flags_rsvd_lanq
|= ((u64
)skb
->queue_mapping
<<
1085 I40E_FCOE_FILTER_CTX_QW1_LANQINDX_SHIFT
);
1086 filter_desc
->flags_rsvd_lanq
= cpu_to_le64(flags_rsvd_lanq
);
1088 /* By this time, all offload related descriptors has been programmed */
1089 tx_ring
->next_to_use
= i
;
1093 * i40e_fcoe_invalidate_ddp - invalidates DDP in case of abort
1094 * @tx_ring: transmit ring for this packet
1095 * @skb: the packet associated w/ this DDP invalidation, i.e., ABTS
1096 * @ddp: the SW DDP context for this DDP
1098 * Programs the Tx context descriptor to do DDP invalidation.
1100 static void i40e_fcoe_invalidate_ddp(struct i40e_ring
*tx_ring
,
1101 struct sk_buff
*skb
,
1102 struct i40e_fcoe_ddp
*ddp
)
1104 struct i40e_tx_context_desc
*context_desc
;
1107 if (test_and_set_bit(__I40E_FCOE_DDP_ABORTED
, &ddp
->flags
))
1110 i
= tx_ring
->next_to_use
;
1111 context_desc
= I40E_TX_CTXTDESC(tx_ring
, i
);
1113 if (i
== tx_ring
->count
)
1116 context_desc
->tunneling_params
= cpu_to_le32(0);
1117 context_desc
->l2tag2
= cpu_to_le16(0);
1118 context_desc
->rsvd
= cpu_to_le16(0);
1119 context_desc
->type_cmd_tso_mss
= cpu_to_le64(
1120 I40E_TX_DESC_DTYPE_FCOE_CTX
|
1121 (I40E_FCOE_TX_CTX_DESC_OPCODE_DDP_CTX_INVL
<<
1122 I40E_TXD_CTX_QW1_CMD_SHIFT
) |
1123 (I40E_FCOE_TX_CTX_DESC_OPCODE_SINGLE_SEND
<<
1124 I40E_TXD_CTX_QW1_CMD_SHIFT
));
1125 tx_ring
->next_to_use
= i
;
1129 * i40e_fcoe_handle_ddp - check we should setup or invalidate DDP
1130 * @tx_ring: transmit ring for this packet
1131 * @skb: the packet to be sent out
1132 * @sof: the SOF to indicate class of service
1134 * Determine if it is ABTS/READ/XFER_RDY, and finds out if there is
1135 * a matching SW DDP context for this command. DDP is applicable
1136 * only in case of READ if initiator or WRITE in case of
1137 * responder (via checking XFER_RDY). In case this is an ABTS, send
1138 * just invalidate the context.
1140 static void i40e_fcoe_handle_ddp(struct i40e_ring
*tx_ring
,
1141 struct sk_buff
*skb
, u8 sof
)
1143 struct i40e_pf
*pf
= tx_ring
->vsi
->back
;
1144 struct i40e_fcoe
*fcoe
= &pf
->fcoe
;
1145 struct fc_frame_header
*fh
;
1146 struct i40e_fcoe_ddp
*ddp
;
1151 fh
= (struct fc_frame_header
*)skb_transport_header(skb
);
1152 f_ctl
= ntoh24(fh
->fh_f_ctl
);
1153 r_ctl
= fh
->fh_r_ctl
;
1156 if ((r_ctl
== FC_RCTL_DD_DATA_DESC
) && (f_ctl
& FC_FC_EX_CTX
)) {
1157 /* exchange responder? if so, XFER_RDY for write */
1158 xid
= ntohs(fh
->fh_rx_id
);
1159 if (i40e_fcoe_xid_is_valid(xid
)) {
1160 ddp
= &fcoe
->ddp
[xid
];
1161 if ((ddp
->xid
== xid
) &&
1162 (test_bit(__I40E_FCOE_DDP_TARGET
, &ddp
->flags
)))
1163 i40e_fcoe_program_ddp(tx_ring
, skb
, ddp
, sof
);
1165 } else if (r_ctl
== FC_RCTL_DD_UNSOL_CMD
) {
1166 /* exchange originator, check READ cmd */
1167 xid
= ntohs(fh
->fh_ox_id
);
1168 if (i40e_fcoe_xid_is_valid(xid
)) {
1169 ddp
= &fcoe
->ddp
[xid
];
1170 if ((ddp
->xid
== xid
) &&
1171 (!test_bit(__I40E_FCOE_DDP_TARGET
, &ddp
->flags
)))
1172 i40e_fcoe_program_ddp(tx_ring
, skb
, ddp
, sof
);
1174 } else if (r_ctl
== FC_RCTL_BA_ABTS
) {
1175 /* exchange originator, check ABTS */
1176 xid
= ntohs(fh
->fh_ox_id
);
1177 if (i40e_fcoe_xid_is_valid(xid
)) {
1178 ddp
= &fcoe
->ddp
[xid
];
1179 if ((ddp
->xid
== xid
) &&
1180 (!test_bit(__I40E_FCOE_DDP_TARGET
, &ddp
->flags
)))
1181 i40e_fcoe_invalidate_ddp(tx_ring
, skb
, ddp
);
1187 * i40e_fcoe_tso - set up FCoE TSO
1188 * @tx_ring: ring to send buffer on
1190 * @tx_flags: collected send information
1191 * @hdr_len: the tso header length
1192 * @sof: the SOF to indicate class of service
1194 * Note must already have sof checked to be either class 2 or class 3 before
1195 * calling this function.
1197 * Returns 1 to indicate sequence segmentation offload is properly setup
1198 * or returns 0 to indicate no tso is needed, otherwise returns error
1199 * code to drop the frame.
1201 static int i40e_fcoe_tso(struct i40e_ring
*tx_ring
,
1202 struct sk_buff
*skb
,
1203 u32 tx_flags
, u8
*hdr_len
, u8 sof
)
1205 struct i40e_tx_context_desc
*context_desc
;
1206 u32 cd_type
, cd_cmd
, cd_tso_len
, cd_mss
;
1207 struct fc_frame_header
*fh
;
1208 u64 cd_type_cmd_tso_mss
;
1210 /* must match gso type as FCoE */
1211 if (!skb_is_gso(skb
))
1214 /* is it the expected gso type for FCoE ?*/
1215 if (skb_shinfo(skb
)->gso_type
!= SKB_GSO_FCOE
) {
1216 netdev_err(skb
->dev
,
1217 "wrong gso type %d:expecting SKB_GSO_FCOE\n",
1218 skb_shinfo(skb
)->gso_type
);
1222 /* header and trailer are inserted by hw */
1223 *hdr_len
= skb_transport_offset(skb
) + sizeof(struct fc_frame_header
) +
1224 sizeof(struct fcoe_crc_eof
);
1226 /* check sof to decide a class 2 or 3 TSO */
1227 if (likely(i40e_fcoe_sof_is_class3(sof
)))
1228 cd_cmd
= I40E_FCOE_TX_CTX_DESC_OPCODE_TSO_FC_CLASS3
;
1230 cd_cmd
= I40E_FCOE_TX_CTX_DESC_OPCODE_TSO_FC_CLASS2
;
1232 /* param field valid? */
1233 fh
= (struct fc_frame_header
*)skb_transport_header(skb
);
1234 if (fh
->fh_f_ctl
[2] & FC_FC_REL_OFF
)
1235 cd_cmd
|= I40E_FCOE_TX_CTX_DESC_RELOFF
;
1237 /* fill the field values */
1238 cd_type
= I40E_TX_DESC_DTYPE_FCOE_CTX
;
1239 cd_tso_len
= skb
->len
- *hdr_len
;
1240 cd_mss
= skb_shinfo(skb
)->gso_size
;
1241 cd_type_cmd_tso_mss
=
1242 ((u64
)cd_type
<< I40E_TXD_CTX_QW1_DTYPE_SHIFT
) |
1243 ((u64
)cd_cmd
<< I40E_TXD_CTX_QW1_CMD_SHIFT
) |
1244 ((u64
)cd_tso_len
<< I40E_TXD_CTX_QW1_TSO_LEN_SHIFT
) |
1245 ((u64
)cd_mss
<< I40E_TXD_CTX_QW1_MSS_SHIFT
);
1247 /* grab the next descriptor */
1248 context_desc
= I40E_TX_CTXTDESC(tx_ring
, tx_ring
->next_to_use
);
1249 tx_ring
->next_to_use
++;
1250 if (tx_ring
->next_to_use
== tx_ring
->count
)
1251 tx_ring
->next_to_use
= 0;
1253 context_desc
->tunneling_params
= 0;
1254 context_desc
->l2tag2
= cpu_to_le16((tx_flags
& I40E_TX_FLAGS_VLAN_MASK
)
1255 >> I40E_TX_FLAGS_VLAN_SHIFT
);
1256 context_desc
->type_cmd_tso_mss
= cpu_to_le64(cd_type_cmd_tso_mss
);
1262 * i40e_fcoe_tx_map - build the tx descriptor
1263 * @tx_ring: ring to send buffer on
1265 * @first: first buffer info buffer to use
1266 * @tx_flags: collected send information
1267 * @hdr_len: ptr to the size of the packet header
1268 * @eof: the frame eof value
1270 * Note, for FCoE, sof and eof are already checked
1272 static void i40e_fcoe_tx_map(struct i40e_ring
*tx_ring
,
1273 struct sk_buff
*skb
,
1274 struct i40e_tx_buffer
*first
,
1275 u32 tx_flags
, u8 hdr_len
, u8 eof
)
1282 td_cmd
= I40E_TX_DESC_CMD_ICRC
;
1285 maclen
= skb_network_offset(skb
);
1286 if (tx_flags
& I40E_TX_FLAGS_SW_VLAN
)
1287 maclen
+= sizeof(struct vlan_hdr
);
1289 if (skb
->protocol
== htons(ETH_P_FCOE
)) {
1290 /* for FCoE, maclen should exclude ether type */
1292 /* setup type as FCoE and EOF insertion */
1293 td_cmd
|= (I40E_TX_DESC_CMD_FCOET
| i40e_fcoe_ctxt_eof(eof
));
1294 /* setup FCoELEN and FCLEN */
1295 td_offset
|= ((((sizeof(struct fcoe_hdr
) + 2) >> 2) <<
1296 I40E_TX_DESC_LENGTH_IPLEN_SHIFT
) |
1297 ((sizeof(struct fc_frame_header
) >> 2) <<
1298 I40E_TX_DESC_LENGTH_L4_FC_LEN_SHIFT
));
1299 /* trim to exclude trailer */
1300 pskb_trim(skb
, skb
->len
- sizeof(struct fcoe_crc_eof
));
1303 /* MACLEN is ether header length in words not bytes */
1304 td_offset
|= (maclen
>> 1) << I40E_TX_DESC_LENGTH_MACLEN_SHIFT
;
1306 return i40e_tx_map(tx_ring
, skb
, first
, tx_flags
, hdr_len
,
1311 * i40e_fcoe_set_skb_header - adjust skb header point for FIP/FCoE/FC
1312 * @skb: the skb to be adjusted
1314 * Returns true if this skb is a FCoE/FIP or VLAN carried FCoE/FIP and then
1315 * adjusts the skb header pointers correspondingly. Otherwise, returns false.
1317 static inline int i40e_fcoe_set_skb_header(struct sk_buff
*skb
)
1319 __be16 protocol
= skb
->protocol
;
1321 skb_reset_mac_header(skb
);
1322 skb
->mac_len
= sizeof(struct ethhdr
);
1323 if (protocol
== htons(ETH_P_8021Q
)) {
1324 struct vlan_ethhdr
*veth
= (struct vlan_ethhdr
*)eth_hdr(skb
);
1326 protocol
= veth
->h_vlan_encapsulated_proto
;
1327 skb
->mac_len
+= sizeof(struct vlan_hdr
);
1330 /* FCoE or FIP only */
1331 if ((protocol
!= htons(ETH_P_FIP
)) &&
1332 (protocol
!= htons(ETH_P_FCOE
)))
1335 /* set header to L2 of FCoE/FIP */
1336 skb_set_network_header(skb
, skb
->mac_len
);
1337 if (protocol
== htons(ETH_P_FIP
))
1340 /* set header to L3 of FC */
1341 skb_set_transport_header(skb
, skb
->mac_len
+ sizeof(struct fcoe_hdr
));
1346 * i40e_fcoe_xmit_frame - transmit buffer
1348 * @netdev: the fcoe netdev
1350 * Returns 0 if sent, else an error code
1352 static netdev_tx_t
i40e_fcoe_xmit_frame(struct sk_buff
*skb
,
1353 struct net_device
*netdev
)
1355 struct i40e_netdev_priv
*np
= netdev_priv(skb
->dev
);
1356 struct i40e_vsi
*vsi
= np
->vsi
;
1357 struct i40e_ring
*tx_ring
= vsi
->tx_rings
[skb
->queue_mapping
];
1358 struct i40e_tx_buffer
*first
;
1365 if (i40e_fcoe_set_skb_header(skb
))
1368 if (!i40e_xmit_descriptor_count(skb
, tx_ring
))
1369 return NETDEV_TX_BUSY
;
1371 /* prepare the xmit flags */
1372 if (i40e_tx_prepare_vlan_flags(skb
, tx_ring
, &tx_flags
))
1375 /* record the location of the first descriptor for this packet */
1376 first
= &tx_ring
->tx_bi
[tx_ring
->next_to_use
];
1378 /* FIP is a regular L2 traffic w/o offload */
1379 if (skb
->protocol
== htons(ETH_P_FIP
))
1382 /* check sof and eof, only supports FC Class 2 or 3 */
1383 if (i40e_fcoe_fc_sof(skb
, &sof
) || i40e_fcoe_fc_eof(skb
, &eof
)) {
1384 netdev_err(netdev
, "SOF/EOF error:%02x - %02x\n", sof
, eof
);
1388 /* always do FCCRC for FCoE */
1389 tx_flags
|= I40E_TX_FLAGS_FCCRC
;
1391 /* check we should do sequence offload */
1392 fso
= i40e_fcoe_tso(tx_ring
, skb
, tx_flags
, &hdr_len
, sof
);
1396 tx_flags
|= I40E_TX_FLAGS_FSO
;
1398 i40e_fcoe_handle_ddp(tx_ring
, skb
, sof
);
1401 /* send out the packet */
1402 i40e_fcoe_tx_map(tx_ring
, skb
, first
, tx_flags
, hdr_len
, eof
);
1404 i40e_maybe_stop_tx(tx_ring
, DESC_NEEDED
);
1405 return NETDEV_TX_OK
;
1408 dev_kfree_skb_any(skb
);
1409 return NETDEV_TX_OK
;
1413 * i40e_fcoe_change_mtu - NDO callback to change the Maximum Transfer Unit
1414 * @netdev: network interface device structure
1415 * @new_mtu: new value for maximum frame size
1417 * Returns error as operation not permitted
1420 static int i40e_fcoe_change_mtu(struct net_device
*netdev
, int new_mtu
)
1422 netdev_warn(netdev
, "MTU change is not supported on FCoE interfaces\n");
1427 * i40e_fcoe_set_features - set the netdev feature flags
1428 * @netdev: ptr to the netdev being adjusted
1429 * @features: the feature set that the stack is suggesting
1432 static int i40e_fcoe_set_features(struct net_device
*netdev
,
1433 netdev_features_t features
)
1435 struct i40e_netdev_priv
*np
= netdev_priv(netdev
);
1436 struct i40e_vsi
*vsi
= np
->vsi
;
1438 if (features
& NETIF_F_HW_VLAN_CTAG_RX
)
1439 i40e_vlan_stripping_enable(vsi
);
1441 i40e_vlan_stripping_disable(vsi
);
1447 static const struct net_device_ops i40e_fcoe_netdev_ops
= {
1448 .ndo_open
= i40e_open
,
1449 .ndo_stop
= i40e_close
,
1450 .ndo_get_stats64
= i40e_get_netdev_stats_struct
,
1451 .ndo_set_rx_mode
= i40e_set_rx_mode
,
1452 .ndo_validate_addr
= eth_validate_addr
,
1453 .ndo_set_mac_address
= i40e_set_mac
,
1454 .ndo_change_mtu
= i40e_fcoe_change_mtu
,
1455 .ndo_do_ioctl
= i40e_ioctl
,
1456 .ndo_tx_timeout
= i40e_tx_timeout
,
1457 .ndo_vlan_rx_add_vid
= i40e_vlan_rx_add_vid
,
1458 .ndo_vlan_rx_kill_vid
= i40e_vlan_rx_kill_vid
,
1459 .ndo_setup_tc
= i40e_setup_tc
,
1461 #ifdef CONFIG_NET_POLL_CONTROLLER
1462 .ndo_poll_controller
= i40e_netpoll
,
1464 .ndo_start_xmit
= i40e_fcoe_xmit_frame
,
1465 .ndo_fcoe_enable
= i40e_fcoe_enable
,
1466 .ndo_fcoe_disable
= i40e_fcoe_disable
,
1467 .ndo_fcoe_ddp_setup
= i40e_fcoe_ddp_get
,
1468 .ndo_fcoe_ddp_done
= i40e_fcoe_ddp_put
,
1469 .ndo_fcoe_ddp_target
= i40e_fcoe_ddp_target
,
1470 .ndo_set_features
= i40e_fcoe_set_features
,
1474 * i40e_fcoe_config_netdev - prepares the VSI context for creating a FCoE VSI
1475 * @vsi: pointer to the associated VSI struct
1476 * @ctxt: pointer to the associated VSI context to be passed to HW
1478 * Returns 0 on success or < 0 on error
1480 void i40e_fcoe_config_netdev(struct net_device
*netdev
, struct i40e_vsi
*vsi
)
1482 struct i40e_hw
*hw
= &vsi
->back
->hw
;
1483 struct i40e_pf
*pf
= vsi
->back
;
1485 if (vsi
->type
!= I40E_VSI_FCOE
)
1488 netdev
->features
= (NETIF_F_HW_VLAN_CTAG_TX
|
1489 NETIF_F_HW_VLAN_CTAG_RX
|
1490 NETIF_F_HW_VLAN_CTAG_FILTER
);
1492 netdev
->vlan_features
= netdev
->features
;
1493 netdev
->vlan_features
&= ~(NETIF_F_HW_VLAN_CTAG_TX
|
1494 NETIF_F_HW_VLAN_CTAG_RX
|
1495 NETIF_F_HW_VLAN_CTAG_FILTER
);
1496 netdev
->fcoe_ddp_xid
= I40E_FCOE_DDP_MAX
- 1;
1497 netdev
->features
|= NETIF_F_ALL_FCOE
;
1498 netdev
->vlan_features
|= NETIF_F_ALL_FCOE
;
1499 netdev
->hw_features
|= netdev
->features
;
1500 netdev
->priv_flags
|= IFF_UNICAST_FLT
;
1501 netdev
->priv_flags
|= IFF_SUPP_NOFCS
;
1503 strlcpy(netdev
->name
, "fcoe%d", IFNAMSIZ
-1);
1504 netdev
->mtu
= FCOE_MTU
;
1505 SET_NETDEV_DEV(netdev
, &pf
->pdev
->dev
);
1506 /* set different dev_port value 1 for FCoE netdev than the default
1507 * zero dev_port value for PF netdev, this helps biosdevname user
1508 * tool to differentiate them correctly while both attached to the
1509 * same PCI function.
1511 netdev
->dev_port
= 1;
1512 i40e_add_filter(vsi
, hw
->mac
.san_addr
, 0, false, false);
1513 i40e_add_filter(vsi
, (u8
[6]) FC_FCOE_FLOGI_MAC
, 0, false, false);
1514 i40e_add_filter(vsi
, FIP_ALL_FCOE_MACS
, 0, false, false);
1515 i40e_add_filter(vsi
, FIP_ALL_ENODE_MACS
, 0, false, false);
1518 ether_addr_copy(netdev
->dev_addr
, hw
->mac
.san_addr
);
1519 ether_addr_copy(netdev
->perm_addr
, hw
->mac
.san_addr
);
1520 /* fcoe netdev ops */
1521 netdev
->netdev_ops
= &i40e_fcoe_netdev_ops
;
1525 * i40e_fcoe_vsi_setup - allocate and set up FCoE VSI
1526 * @pf: the pf that VSI is associated with
1529 void i40e_fcoe_vsi_setup(struct i40e_pf
*pf
)
1531 struct i40e_vsi
*vsi
;
1535 if (!(pf
->flags
& I40E_FLAG_FCOE_ENABLED
))
1538 BUG_ON(!pf
->vsi
[pf
->lan_vsi
]);
1540 for (i
= 0; i
< pf
->num_alloc_vsi
; i
++) {
1542 if (vsi
&& vsi
->type
== I40E_VSI_FCOE
) {
1543 dev_warn(&pf
->pdev
->dev
,
1544 "FCoE VSI already created\n");
1549 seid
= pf
->vsi
[pf
->lan_vsi
]->seid
;
1550 vsi
= i40e_vsi_setup(pf
, I40E_VSI_FCOE
, seid
, 0);
1552 dev_dbg(&pf
->pdev
->dev
,
1553 "Successfully created FCoE VSI seid %d id %d uplink_seid %d pf seid %d\n",
1554 vsi
->seid
, vsi
->id
, vsi
->uplink_seid
, seid
);
1556 dev_info(&pf
->pdev
->dev
, "Failed to create FCoE VSI\n");