[SCSI] fnic: Add FIP support to the fnic driver (78112e55) · Commits · 戴 / test

drivers/scsi/Kconfig

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -663,7 +663,7 @@ config FCOE
	config FCOE_FNIC		config FCOE_FNIC
	tristate "Cisco FNIC Driver"		tristate "Cisco FNIC Driver"
	depends on PCI && X86		depends on PCI && X86
	select LIBFC		select LIBFCOE
	help		help
	This is support for the Cisco PCI-Express FCoE HBA.		This is support for the Cisco PCI-Express FCoE HBA.

drivers/scsi/fnic/fnic.h

+14 −9

Original line number	Original line	Diff line number	Diff line
	@@ -22,6 +22,7 @@
	#include <linux/netdevice.h>		#include <linux/netdevice.h>
	#include <linux/workqueue.h>		#include <linux/workqueue.h>
	#include <scsi/libfc.h>		#include <scsi/libfc.h>
			#include <scsi/libfcoe.h>
	#include "fnic_io.h"		#include "fnic_io.h"
	#include "fnic_res.h"		#include "fnic_res.h"
	#include "vnic_dev.h"		#include "vnic_dev.h"
	@@ -145,6 +146,7 @@ struct mempool;
	/* Per-instance private data structure */		/* Per-instance private data structure */
	struct fnic {		struct fnic {
	struct fc_lport *lport;		struct fc_lport *lport;
			struct fcoe_ctlr ctlr; /* FIP FCoE controller structure */
	struct vnic_dev_bar bar0;		struct vnic_dev_bar bar0;

	struct msix_entry msix_entry[FNIC_MSIX_INTR_MAX];		struct msix_entry msix_entry[FNIC_MSIX_INTR_MAX];
	@@ -162,23 +164,16 @@ struct fnic {
	unsigned int wq_count;		unsigned int wq_count;
	unsigned int cq_count;		unsigned int cq_count;

	u32 fcoui_mode:1; /* use fcoui address*/
	u32 vlan_hw_insert:1; /* let hw insert the tag */		u32 vlan_hw_insert:1; /* let hw insert the tag */
	u32 in_remove:1; /* fnic device in removal */		u32 in_remove:1; /* fnic device in removal */
	u32 stop_rx_link_events:1; /* stop proc. rx frames, link events */		u32 stop_rx_link_events:1; /* stop proc. rx frames, link events */

	struct completion remove_wait; / device remove thread blocks */		struct completion remove_wait; / device remove thread blocks */

	struct fc_frame *flogi;
	struct fc_frame *flogi_resp;
	u16 flogi_oxid;
	unsigned long s_id;
	enum fnic_state state;		enum fnic_state state;
	spinlock_t fnic_lock;		spinlock_t fnic_lock;

	u16 vlan_id; /* VLAN tag including priority */		u16 vlan_id; /* VLAN tag including priority */
	u8 mac_addr[ETH_ALEN];
	u8 dest_addr[ETH_ALEN];
	u8 data_src_addr[ETH_ALEN];		u8 data_src_addr[ETH_ALEN];
	u64 fcp_input_bytes; /* internal statistic */		u64 fcp_input_bytes; /* internal statistic */
	u64 fcp_output_bytes; /* internal statistic */		u64 fcp_output_bytes; /* internal statistic */
	@@ -205,6 +200,7 @@ struct fnic {
	struct work_struct link_work;		struct work_struct link_work;
	struct work_struct frame_work;		struct work_struct frame_work;
	struct sk_buff_head frame_queue;		struct sk_buff_head frame_queue;
			struct sk_buff_head tx_queue;

	/* copy work queue cache line section */		/* copy work queue cache line section */
	____cacheline_aligned struct vnic_wq_copy wq_copy[FNIC_WQ_COPY_MAX];		____cacheline_aligned struct vnic_wq_copy wq_copy[FNIC_WQ_COPY_MAX];
	@@ -224,6 +220,11 @@ struct fnic {
	____cacheline_aligned struct vnic_intr intr[FNIC_MSIX_INTR_MAX];		____cacheline_aligned struct vnic_intr intr[FNIC_MSIX_INTR_MAX];
	};		};

			static inline struct fnic fnic_from_ctlr(struct fcoe_ctlr fip)
			{
			return container_of(fip, struct fnic, ctlr);
			}

	extern struct workqueue_struct *fnic_event_queue;		extern struct workqueue_struct *fnic_event_queue;
	extern struct device_attribute *fnic_attrs[];		extern struct device_attribute *fnic_attrs[];

	@@ -239,7 +240,11 @@ void fnic_handle_link(struct work_struct *work);
	int fnic_rq_cmpl_handler(struct fnic *fnic, int);		int fnic_rq_cmpl_handler(struct fnic *fnic, int);
	int fnic_alloc_rq_frame(struct vnic_rq *rq);		int fnic_alloc_rq_frame(struct vnic_rq *rq);
	void fnic_free_rq_buf(struct vnic_rq rq, struct vnic_rq_buf buf);		void fnic_free_rq_buf(struct vnic_rq rq, struct vnic_rq_buf buf);
	int fnic_send_frame(struct fnic fnic, struct fc_frame fp);		void fnic_flush_tx(struct fnic *);
			void fnic_eth_send(struct fcoe_ctlr , struct sk_buff skb);
			void fnic_set_port_id(struct fc_lport , u32, struct fc_frame );
			void fnic_update_mac(struct fc_lport , u8 new);
			void fnic_update_mac_locked(struct fnic , u8 new);

	int fnic_queuecommand(struct scsi_cmnd , void (done)(struct scsi_cmnd *));		int fnic_queuecommand(struct scsi_cmnd , void (done)(struct scsi_cmnd *));
	int fnic_abort_cmd(struct scsi_cmnd *);		int fnic_abort_cmd(struct scsi_cmnd *);
	@@ -252,7 +257,7 @@ void fnic_empty_scsi_cleanup(struct fc_lport *);
	void fnic_exch_mgr_reset(struct fc_lport *, u32, u32);		void fnic_exch_mgr_reset(struct fc_lport *, u32, u32);
	int fnic_wq_copy_cmpl_handler(struct fnic *fnic, int);		int fnic_wq_copy_cmpl_handler(struct fnic *fnic, int);
	int fnic_wq_cmpl_handler(struct fnic *fnic, int);		int fnic_wq_cmpl_handler(struct fnic *fnic, int);
	int fnic_flogi_reg_handler(struct fnic *fnic);		int fnic_flogi_reg_handler(struct fnic *fnic, u32);
	void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,		void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
	struct fcpio_host_req *desc);		struct fcpio_host_req *desc);
	int fnic_fw_reset_handler(struct fnic *fnic);		int fnic_fw_reset_handler(struct fnic *fnic);

drivers/scsi/fnic/fnic_fcs.c

+238 −261

Original line number	Original line	Diff line number	Diff line
	@@ -23,6 +23,7 @@
	#include <linux/if_ether.h>		#include <linux/if_ether.h>
	#include <linux/if_vlan.h>		#include <linux/if_vlan.h>
	#include <linux/workqueue.h>		#include <linux/workqueue.h>
			#include <scsi/fc/fc_fip.h>
	#include <scsi/fc/fc_els.h>		#include <scsi/fc/fc_els.h>
	#include <scsi/fc/fc_fcoe.h>		#include <scsi/fc/fc_fcoe.h>
	#include <scsi/fc_frame.h>		#include <scsi/fc_frame.h>
	@@ -34,6 +35,8 @@

	struct workqueue_struct *fnic_event_queue;		struct workqueue_struct *fnic_event_queue;

			static void fnic_set_eth_mode(struct fnic *);

	void fnic_handle_link(struct work_struct *work)		void fnic_handle_link(struct work_struct *work)
	{		{
	struct fnic *fnic = container_of(work, struct fnic, link_work);		struct fnic *fnic = container_of(work, struct fnic, link_work);
	@@ -64,10 +67,10 @@ void fnic_handle_link(struct work_struct *work)
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,		FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
	"link down\n");		"link down\n");
	fc_linkdown(fnic->lport);		fcoe_ctlr_link_down(&fnic->ctlr);
	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,		FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
	"link up\n");		"link up\n");
	fc_linkup(fnic->lport);		fcoe_ctlr_link_up(&fnic->ctlr);
	} else		} else
	/* UP -> UP */		/* UP -> UP */
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
	@@ -76,13 +79,13 @@ void fnic_handle_link(struct work_struct *work)
	/* DOWN -> UP */		/* DOWN -> UP */
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "link up\n");		FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "link up\n");
	fc_linkup(fnic->lport);		fcoe_ctlr_link_up(&fnic->ctlr);
	} else {		} else {
	/* UP -> DOWN */		/* UP -> DOWN */
	fnic->lport->host_stats.link_failure_count++;		fnic->lport->host_stats.link_failure_count++;
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "link down\n");		FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "link down\n");
	fc_linkdown(fnic->lport);		fcoe_ctlr_link_down(&fnic->ctlr);
	}		}

	}		}
	@@ -107,197 +110,179 @@ void fnic_handle_frame(struct work_struct *work)
	return;		return;
	}		}
	fp = (struct fc_frame *)skb;		fp = (struct fc_frame *)skb;
	/* if Flogi resp frame, register the address */
	if (fr_flags(fp)) {		/*
	vnic_dev_add_addr(fnic->vdev,		* If we're in a transitional state, just re-queue and return.
	fnic->data_src_addr);		* The queue will be serviced when we get to a stable state.
	fr_flags(fp) = 0;		*/
			if (fnic->state != FNIC_IN_FC_MODE &&
			fnic->state != FNIC_IN_ETH_MODE) {
			skb_queue_head(&fnic->frame_queue, skb);
			spin_unlock_irqrestore(&fnic->fnic_lock, flags);
			return;
	}		}
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);		spin_unlock_irqrestore(&fnic->fnic_lock, flags);

	fc_exch_recv(lp, fp);		fc_exch_recv(lp, fp);
	}		}

	}

	static inline void fnic_import_rq_fc_frame(struct sk_buff *skb,
	u32 len, u8 sof, u8 eof)
	{
	struct fc_frame fp = (struct fc_frame )skb;

	skb_trim(skb, len);
	fr_eof(fp) = eof;
	fr_sof(fp) = sof;
	}		}

			/**
	static inline int fnic_import_rq_eth_pkt(struct sk_buff *skb, u32 len)		* fnic_import_rq_eth_pkt() - handle received FCoE or FIP frame.
			* @fnic: fnic instance.
			* @skb: Ethernet Frame.
			*/
			static inline int fnic_import_rq_eth_pkt(struct fnic fnic, struct sk_buff skb)
	{		{
	struct fc_frame *fp;		struct fc_frame *fp;
	struct ethhdr *eh;		struct ethhdr *eh;
	struct vlan_ethhdr *vh;
	struct fcoe_hdr *fcoe_hdr;		struct fcoe_hdr *fcoe_hdr;
	struct fcoe_crc_eof *ft;		struct fcoe_crc_eof *ft;
	u32 transport_len = 0;

			/*
			* Undo VLAN encapsulation if present.
			*/
	eh = (struct ethhdr *)skb->data;		eh = (struct ethhdr *)skb->data;
	vh = (struct vlan_ethhdr *)skb->data;		if (eh->h_proto == htons(ETH_P_8021Q)) {
	if (vh->h_vlan_proto == htons(ETH_P_8021Q) &&		memmove((u8 )eh + VLAN_HLEN, eh, ETH_ALEN 2);
	vh->h_vlan_encapsulated_proto == htons(ETH_P_FCOE)) {		eh = (struct ethhdr *)skb_pull(skb, VLAN_HLEN);
	skb_pull(skb, sizeof(struct vlan_ethhdr));		skb_reset_mac_header(skb);
	transport_len += sizeof(struct vlan_ethhdr);		}
	} else if (eh->h_proto == htons(ETH_P_FCOE)) {		if (eh->h_proto == htons(ETH_P_FIP)) {
	transport_len += sizeof(struct ethhdr);		skb_pull(skb, sizeof(*eh));
	skb_pull(skb, sizeof(struct ethhdr));		fcoe_ctlr_recv(&fnic->ctlr, skb);
	} else		return 1; /* let caller know packet was used */
	return -1;		}
			if (eh->h_proto != htons(ETH_P_FCOE))
			goto drop;
			skb_set_network_header(skb, sizeof(*eh));
			skb_pull(skb, sizeof(*eh));

	fcoe_hdr = (struct fcoe_hdr *)skb->data;		fcoe_hdr = (struct fcoe_hdr *)skb->data;
	if (FC_FCOE_DECAPS_VER(fcoe_hdr) != FC_FCOE_VER)		if (FC_FCOE_DECAPS_VER(fcoe_hdr) != FC_FCOE_VER)
	return -1;		goto drop;

	fp = (struct fc_frame *)skb;		fp = (struct fc_frame *)skb;
	fc_frame_init(fp);		fc_frame_init(fp);
	fr_sof(fp) = fcoe_hdr->fcoe_sof;		fr_sof(fp) = fcoe_hdr->fcoe_sof;
	skb_pull(skb, sizeof(struct fcoe_hdr));		skb_pull(skb, sizeof(struct fcoe_hdr));
	transport_len += sizeof(struct fcoe_hdr);		skb_reset_transport_header(skb);

	ft = (struct fcoe_crc_eof *)(skb->data + len -		ft = (struct fcoe_crc_eof )(skb->data + skb->len - sizeof(ft));
	transport_len - sizeof(*ft));
	fr_eof(fp) = ft->fcoe_eof;		fr_eof(fp) = ft->fcoe_eof;
	skb_trim(skb, len - transport_len - sizeof(*ft));		skb_trim(skb, skb->len - sizeof(*ft));
	return 0;		return 0;
			drop:
			dev_kfree_skb_irq(skb);
			return -1;
	}		}

	static inline int fnic_handle_flogi_resp(struct fnic *fnic,		/**
	struct fc_frame *fp)		* fnic_update_mac_locked() - set data MAC address and filters.
			* @fnic: fnic instance.
			* @new: newly-assigned FCoE MAC address.
			*
			* Called with the fnic lock held.
			*/
			void fnic_update_mac_locked(struct fnic fnic, u8 new)
	{		{
	u8 mac[ETH_ALEN] = FC_FCOE_FLOGI_MAC;		u8 *ctl = fnic->ctlr.ctl_src_addr;
	struct ethhdr *eth_hdr;		u8 *data = fnic->data_src_addr;
	struct fc_frame_header *fh;
	int ret = 0;
	unsigned long flags;
	struct fc_frame *old_flogi_resp = NULL;

	fh = (struct fc_frame_header *)fr_hdr(fp);		if (is_zero_ether_addr(new))
			new = ctl;
	spin_lock_irqsave(&fnic->fnic_lock, flags);		if (!compare_ether_addr(data, new))
			return;
	if (fnic->state == FNIC_IN_ETH_MODE) {		FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "update_mac %pM\n", new);
			if (!is_zero_ether_addr(data) && compare_ether_addr(data, ctl))
	/*		vnic_dev_del_addr(fnic->vdev, data);
	* Check if oxid matches on taking the lock. A new Flogi		memcpy(data, new, ETH_ALEN);
	* issued by libFC might have changed the fnic cached oxid		if (compare_ether_addr(new, ctl))
			vnic_dev_add_addr(fnic->vdev, new);
			}

			/**
			* fnic_update_mac() - set data MAC address and filters.
			* @lport: local port.
			* @new: newly-assigned FCoE MAC address.
	*/		*/
	if (fnic->flogi_oxid != ntohs(fh->fh_ox_id)) {		void fnic_update_mac(struct fc_lport lport, u8 new)
	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,		{
	"Flogi response oxid not"		struct fnic *fnic = lport_priv(lport);
	" matching cached oxid, dropping frame"
	"\n");
	ret = -1;
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
	dev_kfree_skb_irq(fp_skb(fp));
	goto handle_flogi_resp_end;
	}

	/* Drop older cached flogi response frame, cache this frame */		spin_lock_irq(&fnic->fnic_lock);
	old_flogi_resp = fnic->flogi_resp;		fnic_update_mac_locked(fnic, new);
	fnic->flogi_resp = fp;		spin_unlock_irq(&fnic->fnic_lock);
	fnic->flogi_oxid = FC_XID_UNKNOWN;		}

	/*		/**
	* this frame is part of flogi get the src mac addr from this		* fnic_set_port_id() - set the port_ID after successful FLOGI.
	* frame if the src mac is fcoui based then we mark the		* @lport: local port.
	* address mode flag to use fcoui base for dst mac addr		* @port_id: assigned FC_ID.
	* otherwise we have to store the fcoe gateway addr		* @fp: received frame containing the FLOGI accept or NULL.
			*
			* This is called from libfc when a new FC_ID has been assigned.
			* This causes us to reset the firmware to FC_MODE and setup the new MAC
			* address and FC_ID.
			*
			* It is also called with FC_ID 0 when we're logged off.
			*
			* If the FC_ID is due to point-to-point, fp may be NULL.
	*/		*/
	eth_hdr = (struct ethhdr *)skb_mac_header(fp_skb(fp));		void fnic_set_port_id(struct fc_lport lport, u32 port_id, struct fc_frame fp)
	memcpy(mac, eth_hdr->h_source, ETH_ALEN);		{
			struct fnic *fnic = lport_priv(lport);
			u8 *mac;
			int ret;

	if (ntoh24(mac) == FC_FCOE_OUI)		FNIC_FCS_DBG(KERN_DEBUG, lport->host, "set port_id %x fp %p\n",
	fnic->fcoui_mode = 1;		port_id, fp);
	else {
	fnic->fcoui_mode = 0;
	memcpy(fnic->dest_addr, mac, ETH_ALEN);
	}

	/*		/*
	* Except for Flogi frame, all outbound frames from us have the		* If we're clearing the FC_ID, change to use the ctl_src_addr.
	* Eth Src address as FC_FCOE_OUI"our_sid". Flogi frame uses		* Set ethernet mode to send FLOGI.
	* the vnic MAC address as the Eth Src address
	*/		*/
	fc_fcoe_set_mac(fnic->data_src_addr, fh->fh_d_id);		if (!port_id) {
			fnic_update_mac(lport, fnic->ctlr.ctl_src_addr);
			fnic_set_eth_mode(fnic);
			return;
			}

	/* We get our s_id from the d_id of the flogi resp frame */		if (fp) {
	fnic->s_id = ntoh24(fh->fh_d_id);		mac = fr_cb(fp)->granted_mac;
			if (is_zero_ether_addr(mac)) {
			/* non-FIP - FLOGI already accepted - ignore return */
			fcoe_ctlr_recv_flogi(&fnic->ctlr, lport, fp);
			}
			fnic_update_mac(lport, mac);
			}

	/* Change state to reflect transition from Eth to FC mode */		/* Change state to reflect transition to FC mode */
			spin_lock_irq(&fnic->fnic_lock);
			if (fnic->state == FNIC_IN_ETH_MODE \|\| fnic->state == FNIC_IN_FC_MODE)
	fnic->state = FNIC_IN_ETH_TRANS_FC_MODE;		fnic->state = FNIC_IN_ETH_TRANS_FC_MODE;
			else {
	} else {
	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,		FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
	"Unexpected fnic state %s while"		"Unexpected fnic state %s while"
	" processing flogi resp\n",		" processing flogi resp\n",
	fnic_state_to_str(fnic->state));		fnic_state_to_str(fnic->state));
	ret = -1;		spin_unlock_irq(&fnic->fnic_lock);
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);		return;
	dev_kfree_skb_irq(fp_skb(fp));
	goto handle_flogi_resp_end;
	}		}
			spin_unlock_irq(&fnic->fnic_lock);
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);

	/* Drop older cached frame */
	if (old_flogi_resp)
	dev_kfree_skb_irq(fp_skb(old_flogi_resp));

	/*		/*
	* send flogi reg request to firmware, this will put the fnic in		* Send FLOGI registration to firmware to set up FC mode.
	* in FC mode		* The new address will be set up when registration completes.
	*/		*/
	ret = fnic_flogi_reg_handler(fnic);		ret = fnic_flogi_reg_handler(fnic, port_id);

	if (ret < 0) {		if (ret < 0) {
	int free_fp = 1;		spin_lock_irq(&fnic->fnic_lock);
	spin_lock_irqsave(&fnic->fnic_lock, flags);
	/*
	* free the frame is some other thread is not
	* pointing to it
	*/
	if (fnic->flogi_resp != fp)
	free_fp = 0;
	else
	fnic->flogi_resp = NULL;

	if (fnic->state == FNIC_IN_ETH_TRANS_FC_MODE)		if (fnic->state == FNIC_IN_ETH_TRANS_FC_MODE)
	fnic->state = FNIC_IN_ETH_MODE;		fnic->state = FNIC_IN_ETH_MODE;
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);		spin_unlock_irq(&fnic->fnic_lock);
	if (free_fp)
	dev_kfree_skb_irq(fp_skb(fp));
	}

	handle_flogi_resp_end:
	return ret;
	}		}

	/* Returns 1 for a response that matches cached flogi oxid */
	static inline int is_matching_flogi_resp_frame(struct fnic *fnic,
	struct fc_frame *fp)
	{
	struct fc_frame_header *fh;
	int ret = 0;
	u32 f_ctl;

	fh = fc_frame_header_get(fp);
	f_ctl = ntoh24(fh->fh_f_ctl);

	if (fnic->flogi_oxid == ntohs(fh->fh_ox_id) &&
	fh->fh_r_ctl == FC_RCTL_ELS_REP &&
	(f_ctl & (FC_FC_EX_CTX \| FC_FC_SEQ_CTX)) == FC_FC_EX_CTX &&
	fh->fh_type == FC_TYPE_ELS)
	ret = 1;

	return ret;
	}		}

	static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc		static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
	@@ -326,6 +311,7 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
	pci_unmap_single(fnic->pdev, buf->dma_addr, buf->len,		pci_unmap_single(fnic->pdev, buf->dma_addr, buf->len,
	PCI_DMA_FROMDEVICE);		PCI_DMA_FROMDEVICE);
	skb = buf->os_buf;		skb = buf->os_buf;
			fp = (struct fc_frame *)skb;
	buf->os_buf = NULL;		buf->os_buf = NULL;

	cq_desc_dec(cq_desc, &type, &color, &q_number, &completed_index);		cq_desc_dec(cq_desc, &type, &color, &q_number, &completed_index);
	@@ -338,6 +324,9 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
	&fcoe_enc_error, &fcs_ok, &vlan_stripped,		&fcoe_enc_error, &fcs_ok, &vlan_stripped,
	&vlan);		&vlan);
	eth_hdrs_stripped = 1;		eth_hdrs_stripped = 1;
			skb_trim(skb, fcp_bytes_written);
			fr_sof(fp) = sof;
			fr_eof(fp) = eof;

	} else if (type == CQ_DESC_TYPE_RQ_ENET) {		} else if (type == CQ_DESC_TYPE_RQ_ENET) {
	cq_enet_rq_desc_dec((struct cq_enet_rq_desc *)cq_desc,		cq_enet_rq_desc_dec((struct cq_enet_rq_desc *)cq_desc,
	@@ -352,6 +341,14 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
	&ipv4_csum_ok, &ipv6, &ipv4,		&ipv4_csum_ok, &ipv6, &ipv4,
	&ipv4_fragment, &fcs_ok);		&ipv4_fragment, &fcs_ok);
	eth_hdrs_stripped = 0;		eth_hdrs_stripped = 0;
			skb_trim(skb, bytes_written);
			if (!fcs_ok) {
			FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
			"fcs error. dropping packet.\n");
			goto drop;
			}
			if (fnic_import_rq_eth_pkt(fnic, skb))
			return;

	} else {		} else {
	/* wrong CQ type*/		/* wrong CQ type*/
	@@ -370,43 +367,11 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
	goto drop;		goto drop;
	}		}

	if (eth_hdrs_stripped)
	fnic_import_rq_fc_frame(skb, fcp_bytes_written, sof, eof);
	else if (fnic_import_rq_eth_pkt(skb, bytes_written))
	goto drop;

	fp = (struct fc_frame *)skb;

	/*
	* If frame is an ELS response that matches the cached FLOGI OX_ID,
	* and is accept, issue flogi_reg_request copy wq request to firmware
	* to register the S_ID and determine whether FC_OUI mode or GW mode.
	*/
	if (is_matching_flogi_resp_frame(fnic, fp)) {
	if (!eth_hdrs_stripped) {
	if (fc_frame_payload_op(fp) == ELS_LS_ACC) {
	fnic_handle_flogi_resp(fnic, fp);
	return;
	}
	/*
	* Recd. Flogi reject. No point registering
	* with fw, but forward to libFC
	*/
	goto forward;
	}
	goto drop;
	}
	if (!eth_hdrs_stripped)
	goto drop;

	forward:
	spin_lock_irqsave(&fnic->fnic_lock, flags);		spin_lock_irqsave(&fnic->fnic_lock, flags);
	if (fnic->stop_rx_link_events) {		if (fnic->stop_rx_link_events) {
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
	goto drop;		goto drop;
	}		}
	/* Use fr_flags to indicate whether succ. flogi resp or not */
	fr_flags(fp) = 0;
	fr_dev(fp) = fnic->lport;		fr_dev(fp) = fnic->lport;
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);		spin_unlock_irqrestore(&fnic->fnic_lock, flags);

	@@ -494,12 +459,49 @@ void fnic_free_rq_buf(struct vnic_rq rq, struct vnic_rq_buf buf)
	buf->os_buf = NULL;		buf->os_buf = NULL;
	}		}

	static inline int is_flogi_frame(struct fc_frame_header *fh)		/**
			* fnic_eth_send() - Send Ethernet frame.
			* @fip: fcoe_ctlr instance.
			* @skb: Ethernet Frame, FIP, without VLAN encapsulation.
			*/
			void fnic_eth_send(struct fcoe_ctlr fip, struct sk_buff skb)
	{		{
	return fh->fh_r_ctl == FC_RCTL_ELS_REQ && (u8 )(fh + 1) == ELS_FLOGI;		struct fnic *fnic = fnic_from_ctlr(fip);
			struct vnic_wq *wq = &fnic->wq[0];
			dma_addr_t pa;
			struct ethhdr *eth_hdr;
			struct vlan_ethhdr *vlan_hdr;
			unsigned long flags;

			if (!fnic->vlan_hw_insert) {
			eth_hdr = (struct ethhdr *)skb_mac_header(skb);
			vlan_hdr = (struct vlan_ethhdr *)skb_push(skb,
			sizeof(vlan_hdr) - sizeof(eth_hdr));
			memcpy(vlan_hdr, eth_hdr, 2 * ETH_ALEN);
			vlan_hdr->h_vlan_proto = htons(ETH_P_8021Q);
			vlan_hdr->h_vlan_encapsulated_proto = eth_hdr->h_proto;
			vlan_hdr->h_vlan_TCI = htons(fnic->vlan_id);
			}

			pa = pci_map_single(fnic->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);

			spin_lock_irqsave(&fnic->wq_lock[0], flags);
			if (!vnic_wq_desc_avail(wq)) {
			pci_unmap_single(fnic->pdev, pa, skb->len, PCI_DMA_TODEVICE);
			spin_unlock_irqrestore(&fnic->wq_lock[0], flags);
			kfree_skb(skb);
			return;
			}

			fnic_queue_wq_eth_desc(wq, skb, pa, skb->len,
			fnic->vlan_hw_insert, fnic->vlan_id, 1);
			spin_unlock_irqrestore(&fnic->wq_lock[0], flags);
	}		}

	int fnic_send_frame(struct fnic fnic, struct fc_frame fp)		/*
			* Send FC frame.
			*/
			static int fnic_send_frame(struct fnic fnic, struct fc_frame fp)
	{		{
	struct vnic_wq *wq = &fnic->wq[0];		struct vnic_wq *wq = &fnic->wq[0];
	struct sk_buff *skb;		struct sk_buff *skb;
	@@ -515,6 +517,10 @@ int fnic_send_frame(struct fnic fnic, struct fc_frame fp)
	fh = fc_frame_header_get(fp);		fh = fc_frame_header_get(fp);
	skb = fp_skb(fp);		skb = fp_skb(fp);

			if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ) &&
			fcoe_ctlr_els_send(&fnic->ctlr, fnic->lport, skb))
			return 0;

	if (!fnic->vlan_hw_insert) {		if (!fnic->vlan_hw_insert) {
	eth_hdr_len = sizeof(vlan_hdr) + sizeof(fcoe_hdr);		eth_hdr_len = sizeof(vlan_hdr) + sizeof(fcoe_hdr);
	vlan_hdr = (struct vlan_ethhdr *)skb_push(skb, eth_hdr_len);		vlan_hdr = (struct vlan_ethhdr *)skb_push(skb, eth_hdr_len);
	@@ -530,16 +536,11 @@ int fnic_send_frame(struct fnic fnic, struct fc_frame fp)
	fcoe_hdr = (struct fcoe_hdr *)(eth_hdr + 1);		fcoe_hdr = (struct fcoe_hdr *)(eth_hdr + 1);
	}		}

	if (is_flogi_frame(fh)) {		if (fnic->ctlr.map_dest)
	fc_fcoe_set_mac(eth_hdr->h_dest, fh->fh_d_id);
	memcpy(eth_hdr->h_source, fnic->mac_addr, ETH_ALEN);
	} else {
	if (fnic->fcoui_mode)
	fc_fcoe_set_mac(eth_hdr->h_dest, fh->fh_d_id);		fc_fcoe_set_mac(eth_hdr->h_dest, fh->fh_d_id);
	else		else
	memcpy(eth_hdr->h_dest, fnic->dest_addr, ETH_ALEN);		memcpy(eth_hdr->h_dest, fnic->ctlr.dest_addr, ETH_ALEN);
	memcpy(eth_hdr->h_source, fnic->data_src_addr, ETH_ALEN);		memcpy(eth_hdr->h_source, fnic->data_src_addr, ETH_ALEN);
	}

	tot_len = skb->len;		tot_len = skb->len;
	BUG_ON(tot_len % 4);		BUG_ON(tot_len % 4);
	@@ -578,109 +579,85 @@ fnic_send_frame_end:
	int fnic_send(struct fc_lport lp, struct fc_frame fp)		int fnic_send(struct fc_lport lp, struct fc_frame fp)
	{		{
	struct fnic *fnic = lport_priv(lp);		struct fnic *fnic = lport_priv(lp);
	struct fc_frame_header *fh;
	int ret = 0;
	enum fnic_state old_state;
	unsigned long flags;		unsigned long flags;
	struct fc_frame *old_flogi = NULL;
	struct fc_frame *old_flogi_resp = NULL;

	if (fnic->in_remove) {		if (fnic->in_remove) {
	dev_kfree_skb(fp_skb(fp));		dev_kfree_skb(fp_skb(fp));
	ret = -1;		return -1;
	goto fnic_send_end;
	}		}

	fh = fc_frame_header_get(fp);		/*
	/* if not an Flogi frame, send it out, this is the common case */		* Queue frame if in a transitional state.
	if (!is_flogi_frame(fh))		* This occurs while registering the Port_ID / MAC address after FLOGI.
			*/
			spin_lock_irqsave(&fnic->fnic_lock, flags);
			if (fnic->state != FNIC_IN_FC_MODE && fnic->state != FNIC_IN_ETH_MODE) {
			skb_queue_tail(&fnic->tx_queue, fp_skb(fp));
			spin_unlock_irqrestore(&fnic->fnic_lock, flags);
			return 0;
			}
			spin_unlock_irqrestore(&fnic->fnic_lock, flags);

	return fnic_send_frame(fnic, fp);		return fnic_send_frame(fnic, fp);
			}

	/* Flogi frame, now enter the state machine */		/**
			* fnic_flush_tx() - send queued frames.
			* @fnic: fnic device
			*
			* Send frames that were waiting to go out in FC or Ethernet mode.
			* Whenever changing modes we purge queued frames, so these frames should
			* be queued for the stable mode that we're in, either FC or Ethernet.
			*
			* Called without fnic_lock held.
			*/
			void fnic_flush_tx(struct fnic *fnic)
			{
			struct sk_buff *skb;
			struct fc_frame *fp;

	spin_lock_irqsave(&fnic->fnic_lock, flags);		while ((skb = skb_dequeue(&fnic->frame_queue))) {
	again:		fp = (struct fc_frame *)skb;
	/* Get any old cached frames, free them after dropping lock */		fnic_send_frame(fnic, fp);
	old_flogi = fnic->flogi;		}
	fnic->flogi = NULL;		}
	old_flogi_resp = fnic->flogi_resp;
	fnic->flogi_resp = NULL;

	fnic->flogi_oxid = FC_XID_UNKNOWN;		/**
			* fnic_set_eth_mode() - put fnic into ethernet mode.
			* @fnic: fnic device
			*
			* Called without fnic lock held.
			*/
			static void fnic_set_eth_mode(struct fnic *fnic)
			{
			unsigned long flags;
			enum fnic_state old_state;
			int ret;

			spin_lock_irqsave(&fnic->fnic_lock, flags);
			again:
	old_state = fnic->state;		old_state = fnic->state;
	switch (old_state) {		switch (old_state) {
	case FNIC_IN_FC_MODE:		case FNIC_IN_FC_MODE:
	case FNIC_IN_ETH_TRANS_FC_MODE:		case FNIC_IN_ETH_TRANS_FC_MODE:
	default:		default:
	fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;		fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;
	vnic_dev_del_addr(fnic->vdev, fnic->data_src_addr);
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);		spin_unlock_irqrestore(&fnic->fnic_lock, flags);

	if (old_flogi) {
	dev_kfree_skb(fp_skb(old_flogi));
	old_flogi = NULL;
	}
	if (old_flogi_resp) {
	dev_kfree_skb(fp_skb(old_flogi_resp));
	old_flogi_resp = NULL;
	}

	ret = fnic_fw_reset_handler(fnic);		ret = fnic_fw_reset_handler(fnic);

	spin_lock_irqsave(&fnic->fnic_lock, flags);		spin_lock_irqsave(&fnic->fnic_lock, flags);
	if (fnic->state != FNIC_IN_FC_TRANS_ETH_MODE)		if (fnic->state != FNIC_IN_FC_TRANS_ETH_MODE)
	goto again;		goto again;
	if (ret) {		if (ret)
	fnic->state = old_state;		fnic->state = old_state;
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
	dev_kfree_skb(fp_skb(fp));
	goto fnic_send_end;
	}
	old_flogi = fnic->flogi;
	fnic->flogi = fp;
	fnic->flogi_oxid = ntohs(fh->fh_ox_id);
	old_flogi_resp = fnic->flogi_resp;
	fnic->flogi_resp = NULL;
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
	break;		break;

	case FNIC_IN_FC_TRANS_ETH_MODE:		case FNIC_IN_FC_TRANS_ETH_MODE:
	/*
	* A reset is pending with the firmware. Store the flogi
	* and its oxid. The transition out of this state happens
	* only when Firmware completes the reset, either with
	* success or failed. If success, transition to
	* FNIC_IN_ETH_MODE, if fail, then transition to
	* FNIC_IN_FC_MODE
	*/
	fnic->flogi = fp;
	fnic->flogi_oxid = ntohs(fh->fh_ox_id);
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
	break;

	case FNIC_IN_ETH_MODE:		case FNIC_IN_ETH_MODE:
	/*
	* The fw/hw is already in eth mode. Store the oxid,
	* and send the flogi frame out. The transition out of this
	* state happens only we receive flogi response from the
	* network, and the oxid matches the cached oxid when the
	* flogi frame was sent out. If they match, then we issue
	* a flogi_reg request and transition to state
	* FNIC_IN_ETH_TRANS_FC_MODE
	*/
	fnic->flogi_oxid = ntohs(fh->fh_ox_id);
	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
	ret = fnic_send_frame(fnic, fp);
	break;		break;
	}		}
			spin_unlock_irqrestore(&fnic->fnic_lock, flags);
	fnic_send_end:
	if (old_flogi)
	dev_kfree_skb(fp_skb(old_flogi));
	if (old_flogi_resp)
	dev_kfree_skb(fp_skb(old_flogi_resp));
	return ret;
	}		}

	static void fnic_wq_complete_frame_send(struct vnic_wq *wq,		static void fnic_wq_complete_frame_send(struct vnic_wq *wq,

drivers/scsi/fnic/fnic_main.c

+42 −29

File changed.

Preview size limit exceeded, changes collapsed.

drivers/scsi/fnic/fnic_res.c

+2 −3

Original line number	Original line	Diff line number	Diff line
	@@ -144,10 +144,9 @@ int fnic_get_vnic_config(struct fnic *fnic)
	c->intr_timer_type = c->intr_timer_type;		c->intr_timer_type = c->intr_timer_type;

	shost_printk(KERN_INFO, fnic->lport->host,		shost_printk(KERN_INFO, fnic->lport->host,
	"vNIC MAC addr %02x:%02x:%02x:%02x:%02x:%02x "		"vNIC MAC addr %pM "
	"wq/wq_copy/rq %d/%d/%d\n",		"wq/wq_copy/rq %d/%d/%d\n",
	fnic->mac_addr[0], fnic->mac_addr[1], fnic->mac_addr[2],		fnic->ctlr.ctl_src_addr,
	fnic->mac_addr[3], fnic->mac_addr[4], fnic->mac_addr[5],
	c->wq_enet_desc_count, c->wq_copy_desc_count,		c->wq_enet_desc_count, c->wq_copy_desc_count,
	c->rq_desc_count);		c->rq_desc_count);
	shost_printk(KERN_INFO, fnic->lport->host,		shost_printk(KERN_INFO, fnic->lport->host,

Admin message