[SCSI] bnx2fc: Allocate fcoe_ctlr with bnx2fc_interface, not as a member (fd8f8902) · Commits · 戴 / test

drivers/scsi/bnx2fc/bnx2fc.h

+5 −2

Original line number	Original line	Diff line number	Diff line
	@@ -228,13 +228,16 @@ struct bnx2fc_interface {
	struct packet_type fip_packet_type;		struct packet_type fip_packet_type;
	struct workqueue_struct *timer_work_queue;		struct workqueue_struct *timer_work_queue;
	struct kref kref;		struct kref kref;
	struct fcoe_ctlr ctlr;
	u8 vlan_enabled;		u8 vlan_enabled;
	int vlan_id;		int vlan_id;
	bool enabled;		bool enabled;
	};		};

	#define bnx2fc_from_ctlr(fip) container_of(fip, struct bnx2fc_interface, ctlr)		#define bnx2fc_from_ctlr(x) \
			((struct bnx2fc_interface *)((x) + 1))

			#define bnx2fc_to_ctlr(x) \
			((struct fcoe_ctlr )(((struct fcoe_ctlr )(x)) - 1))

	struct bnx2fc_lport {		struct bnx2fc_lport {
	struct list_head list;		struct list_head list;

drivers/scsi/bnx2fc/bnx2fc_els.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -900,7 +900,7 @@ struct fc_seq bnx2fc_elsct_send(struct fc_lport lport, u32 did,
	{		{
	struct fcoe_port *port = lport_priv(lport);		struct fcoe_port *port = lport_priv(lport);
	struct bnx2fc_interface *interface = port->priv;		struct bnx2fc_interface *interface = port->priv;
	struct fcoe_ctlr *fip = &interface->ctlr;		struct fcoe_ctlr *fip = bnx2fc_to_ctlr(interface);
	struct fc_frame_header *fh = fc_frame_header_get(fp);		struct fc_frame_header *fh = fc_frame_header_get(fp);

	switch (op) {		switch (op) {

drivers/scsi/bnx2fc/bnx2fc_fcoe.c

+74 −42

Original line number	Original line	Diff line number	Diff line
	@@ -244,6 +244,7 @@ static int bnx2fc_xmit(struct fc_lport lport, struct fc_frame fp)
	struct sk_buff *skb;		struct sk_buff *skb;
	struct fc_frame_header *fh;		struct fc_frame_header *fh;
	struct bnx2fc_interface *interface;		struct bnx2fc_interface *interface;
			struct fcoe_ctlr *ctlr;
	struct bnx2fc_hba *hba;		struct bnx2fc_hba *hba;
	struct fcoe_port *port;		struct fcoe_port *port;
	struct fcoe_hdr *hp;		struct fcoe_hdr *hp;
	@@ -256,6 +257,7 @@ static int bnx2fc_xmit(struct fc_lport lport, struct fc_frame fp)

	port = (struct fcoe_port *)lport_priv(lport);		port = (struct fcoe_port *)lport_priv(lport);
	interface = port->priv;		interface = port->priv;
			ctlr = bnx2fc_to_ctlr(interface);
	hba = interface->hba;		hba = interface->hba;

	fh = fc_frame_header_get(fp);		fh = fc_frame_header_get(fp);
	@@ -268,12 +270,12 @@ static int bnx2fc_xmit(struct fc_lport lport, struct fc_frame fp)
	}		}

	if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ)) {		if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ)) {
	if (!interface->ctlr.sel_fcf) {		if (!ctlr->sel_fcf) {
	BNX2FC_HBA_DBG(lport, "FCF not selected yet!\n");		BNX2FC_HBA_DBG(lport, "FCF not selected yet!\n");
	kfree_skb(skb);		kfree_skb(skb);
	return -EINVAL;		return -EINVAL;
	}		}
	if (fcoe_ctlr_els_send(&interface->ctlr, lport, skb))		if (fcoe_ctlr_els_send(ctlr, lport, skb))
	return 0;		return 0;
	}		}

	@@ -346,14 +348,14 @@ static int bnx2fc_xmit(struct fc_lport lport, struct fc_frame fp)
	/* fill up mac and fcoe headers */		/* fill up mac and fcoe headers */
	eh = eth_hdr(skb);		eh = eth_hdr(skb);
	eh->h_proto = htons(ETH_P_FCOE);		eh->h_proto = htons(ETH_P_FCOE);
	if (interface->ctlr.map_dest)		if (ctlr->map_dest)
	fc_fcoe_set_mac(eh->h_dest, fh->fh_d_id);		fc_fcoe_set_mac(eh->h_dest, fh->fh_d_id);
	else		else
	/* insert GW address */		/* insert GW address */
	memcpy(eh->h_dest, interface->ctlr.dest_addr, ETH_ALEN);		memcpy(eh->h_dest, ctlr->dest_addr, ETH_ALEN);

	if (unlikely(interface->ctlr.flogi_oxid != FC_XID_UNKNOWN))		if (unlikely(ctlr->flogi_oxid != FC_XID_UNKNOWN))
	memcpy(eh->h_source, interface->ctlr.ctl_src_addr, ETH_ALEN);		memcpy(eh->h_source, ctlr->ctl_src_addr, ETH_ALEN);
	else		else
	memcpy(eh->h_source, port->data_src_addr, ETH_ALEN);		memcpy(eh->h_source, port->data_src_addr, ETH_ALEN);

	@@ -403,6 +405,7 @@ static int bnx2fc_rcv(struct sk_buff skb, struct net_device dev,
	{		{
	struct fc_lport *lport;		struct fc_lport *lport;
	struct bnx2fc_interface *interface;		struct bnx2fc_interface *interface;
			struct fcoe_ctlr *ctlr;
	struct fc_frame_header *fh;		struct fc_frame_header *fh;
	struct fcoe_rcv_info *fr;		struct fcoe_rcv_info *fr;
	struct fcoe_percpu_s *bg;		struct fcoe_percpu_s *bg;
	@@ -410,7 +413,8 @@ static int bnx2fc_rcv(struct sk_buff skb, struct net_device dev,

	interface = container_of(ptype, struct bnx2fc_interface,		interface = container_of(ptype, struct bnx2fc_interface,
	fcoe_packet_type);		fcoe_packet_type);
	lport = interface->ctlr.lp;		ctlr = bnx2fc_to_ctlr(interface);
			lport = ctlr->lp;

	if (unlikely(lport == NULL)) {		if (unlikely(lport == NULL)) {
	printk(KERN_ERR PFX "bnx2fc_rcv: lport is NULL\n");		printk(KERN_ERR PFX "bnx2fc_rcv: lport is NULL\n");
	@@ -758,11 +762,13 @@ static int bnx2fc_net_config(struct fc_lport lport, struct net_device netdev)
	{		{
	struct bnx2fc_hba *hba;		struct bnx2fc_hba *hba;
	struct bnx2fc_interface *interface;		struct bnx2fc_interface *interface;
			struct fcoe_ctlr *ctlr;
	struct fcoe_port *port;		struct fcoe_port *port;
	u64 wwnn, wwpn;		u64 wwnn, wwpn;

	port = lport_priv(lport);		port = lport_priv(lport);
	interface = port->priv;		interface = port->priv;
			ctlr = bnx2fc_to_ctlr(interface);
	hba = interface->hba;		hba = interface->hba;

	/* require support for get_pauseparam ethtool op. */		/* require support for get_pauseparam ethtool op. */
	@@ -781,13 +787,13 @@ static int bnx2fc_net_config(struct fc_lport lport, struct net_device netdev)

	if (!lport->vport) {		if (!lport->vport) {
	if (fcoe_get_wwn(netdev, &wwnn, NETDEV_FCOE_WWNN))		if (fcoe_get_wwn(netdev, &wwnn, NETDEV_FCOE_WWNN))
	wwnn = fcoe_wwn_from_mac(interface->ctlr.ctl_src_addr,		wwnn = fcoe_wwn_from_mac(ctlr->ctl_src_addr,
	1, 0);		1, 0);
	BNX2FC_HBA_DBG(lport, "WWNN = 0x%llx\n", wwnn);		BNX2FC_HBA_DBG(lport, "WWNN = 0x%llx\n", wwnn);
	fc_set_wwnn(lport, wwnn);		fc_set_wwnn(lport, wwnn);

	if (fcoe_get_wwn(netdev, &wwpn, NETDEV_FCOE_WWPN))		if (fcoe_get_wwn(netdev, &wwpn, NETDEV_FCOE_WWPN))
	wwpn = fcoe_wwn_from_mac(interface->ctlr.ctl_src_addr,		wwpn = fcoe_wwn_from_mac(ctlr->ctl_src_addr,
	2, 0);		2, 0);

	BNX2FC_HBA_DBG(lport, "WWPN = 0x%llx\n", wwpn);		BNX2FC_HBA_DBG(lport, "WWPN = 0x%llx\n", wwpn);
	@@ -824,6 +830,7 @@ static void bnx2fc_indicate_netevent(void *context, unsigned long event,
	struct fc_lport *lport;		struct fc_lport *lport;
	struct fc_lport *vport;		struct fc_lport *vport;
	struct bnx2fc_interface interface, tmp;		struct bnx2fc_interface interface, tmp;
			struct fcoe_ctlr *ctlr;
	int wait_for_upload = 0;		int wait_for_upload = 0;
	u32 link_possible = 1;		u32 link_possible = 1;

	@@ -874,7 +881,8 @@ static void bnx2fc_indicate_netevent(void *context, unsigned long event,
	if (interface->hba != hba)		if (interface->hba != hba)
	continue;		continue;

	lport = interface->ctlr.lp;		ctlr = bnx2fc_to_ctlr(interface);
			lport = ctlr->lp;
	BNX2FC_HBA_DBG(lport, "netevent handler - event=%s %ld\n",		BNX2FC_HBA_DBG(lport, "netevent handler - event=%s %ld\n",
	interface->netdev->name, event);		interface->netdev->name, event);

	@@ -889,8 +897,8 @@ static void bnx2fc_indicate_netevent(void *context, unsigned long event,
	* on a stale vlan		* on a stale vlan
	*/		*/
	if (interface->enabled)		if (interface->enabled)
	fcoe_ctlr_link_up(&interface->ctlr);		fcoe_ctlr_link_up(ctlr);
	} else if (fcoe_ctlr_link_down(&interface->ctlr)) {		} else if (fcoe_ctlr_link_down(ctlr)) {
	mutex_lock(&lport->lp_mutex);		mutex_lock(&lport->lp_mutex);
	list_for_each_entry(vport, &lport->vports, list)		list_for_each_entry(vport, &lport->vports, list)
	fc_host_port_type(vport->host) =		fc_host_port_type(vport->host) =
	@@ -995,9 +1003,11 @@ static int bnx2fc_fip_recv(struct sk_buff skb, struct net_device dev,
	struct net_device *orig_dev)		struct net_device *orig_dev)
	{		{
	struct bnx2fc_interface *interface;		struct bnx2fc_interface *interface;
			struct fcoe_ctlr *ctlr;
	interface = container_of(ptype, struct bnx2fc_interface,		interface = container_of(ptype, struct bnx2fc_interface,
	fip_packet_type);		fip_packet_type);
	fcoe_ctlr_recv(&interface->ctlr, skb);		ctlr = bnx2fc_to_ctlr(interface);
			fcoe_ctlr_recv(ctlr, skb);
	return 0;		return 0;
	}		}

	@@ -1155,6 +1165,7 @@ static int bnx2fc_interface_setup(struct bnx2fc_interface *interface)
	{		{
	struct net_device *netdev = interface->netdev;		struct net_device *netdev = interface->netdev;
	struct net_device *physdev = interface->hba->phys_dev;		struct net_device *physdev = interface->hba->phys_dev;
			struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
	struct netdev_hw_addr *ha;		struct netdev_hw_addr *ha;
	int sel_san_mac = 0;		int sel_san_mac = 0;

	@@ -1169,7 +1180,7 @@ static int bnx2fc_interface_setup(struct bnx2fc_interface *interface)

	if ((ha->type == NETDEV_HW_ADDR_T_SAN) &&		if ((ha->type == NETDEV_HW_ADDR_T_SAN) &&
	(is_valid_ether_addr(ha->addr))) {		(is_valid_ether_addr(ha->addr))) {
	memcpy(interface->ctlr.ctl_src_addr, ha->addr,		memcpy(ctlr->ctl_src_addr, ha->addr,
	ETH_ALEN);		ETH_ALEN);
	sel_san_mac = 1;		sel_san_mac = 1;
	BNX2FC_MISC_DBG("Found SAN MAC\n");		BNX2FC_MISC_DBG("Found SAN MAC\n");
	@@ -1225,18 +1236,20 @@ static void bnx2fc_release_transport(void)
	static void bnx2fc_interface_release(struct kref *kref)		static void bnx2fc_interface_release(struct kref *kref)
	{		{
	struct bnx2fc_interface *interface;		struct bnx2fc_interface *interface;
			struct fcoe_ctlr *ctlr;
	struct net_device *netdev;		struct net_device *netdev;

	interface = container_of(kref, struct bnx2fc_interface, kref);		interface = container_of(kref, struct bnx2fc_interface, kref);
	BNX2FC_MISC_DBG("Interface is being released\n");		BNX2FC_MISC_DBG("Interface is being released\n");

			ctlr = bnx2fc_to_ctlr(interface);
	netdev = interface->netdev;		netdev = interface->netdev;

	/* tear-down FIP controller */		/* tear-down FIP controller */
	if (test_and_clear_bit(BNX2FC_CTLR_INIT_DONE, &interface->if_flags))		if (test_and_clear_bit(BNX2FC_CTLR_INIT_DONE, &interface->if_flags))
	fcoe_ctlr_destroy(&interface->ctlr);		fcoe_ctlr_destroy(ctlr);

	kfree(interface);		kfree(ctlr);

	dev_put(netdev);		dev_put(netdev);
	module_put(THIS_MODULE);		module_put(THIS_MODULE);
	@@ -1330,32 +1343,36 @@ struct bnx2fc_interface bnx2fc_interface_create(struct bnx2fc_hba hba,
	enum fip_state fip_mode)		enum fip_state fip_mode)
	{		{
	struct bnx2fc_interface *interface;		struct bnx2fc_interface *interface;
			struct fcoe_ctlr *ctlr;
			int size;
	int rc = 0;		int rc = 0;

	interface = kzalloc(sizeof(*interface), GFP_KERNEL);		size = (sizeof(*interface) + sizeof(struct fcoe_ctlr));
	if (!interface) {		ctlr = kzalloc(size, GFP_KERNEL);
			if (!ctlr) {
	printk(KERN_ERR PFX "Unable to allocate interface structure\n");		printk(KERN_ERR PFX "Unable to allocate interface structure\n");
	return NULL;		return NULL;
	}		}
			interface = fcoe_ctlr_priv(ctlr);
	dev_hold(netdev);		dev_hold(netdev);
	kref_init(&interface->kref);		kref_init(&interface->kref);
	interface->hba = hba;		interface->hba = hba;
	interface->netdev = netdev;		interface->netdev = netdev;

	/* Initialize FIP */		/* Initialize FIP */
	fcoe_ctlr_init(&interface->ctlr, fip_mode);		fcoe_ctlr_init(ctlr, fip_mode);
	interface->ctlr.send = bnx2fc_fip_send;		ctlr->send = bnx2fc_fip_send;
	interface->ctlr.update_mac = bnx2fc_update_src_mac;		ctlr->update_mac = bnx2fc_update_src_mac;
	interface->ctlr.get_src_addr = bnx2fc_get_src_mac;		ctlr->get_src_addr = bnx2fc_get_src_mac;
	set_bit(BNX2FC_CTLR_INIT_DONE, &interface->if_flags);		set_bit(BNX2FC_CTLR_INIT_DONE, &interface->if_flags);

	rc = bnx2fc_interface_setup(interface);		rc = bnx2fc_interface_setup(interface);
	if (!rc)		if (!rc)
	return interface;		return interface;

	fcoe_ctlr_destroy(&interface->ctlr);		fcoe_ctlr_destroy(ctlr);
	dev_put(netdev);		dev_put(netdev);
	kfree(interface);		kfree(ctlr);
	return NULL;		return NULL;
	}		}

	@@ -1373,6 +1390,7 @@ struct bnx2fc_interface bnx2fc_interface_create(struct bnx2fc_hba hba,
	static struct fc_lport bnx2fc_if_create(struct bnx2fc_interface interface,		static struct fc_lport bnx2fc_if_create(struct bnx2fc_interface interface,
	struct device *parent, int npiv)		struct device *parent, int npiv)
	{		{
			struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
	struct fc_lport lport, n_port;		struct fc_lport lport, n_port;
	struct fcoe_port *port;		struct fcoe_port *port;
	struct Scsi_Host *shost;		struct Scsi_Host *shost;
	@@ -1383,7 +1401,7 @@ static struct fc_lport bnx2fc_if_create(struct bnx2fc_interface interface,

	blport = kzalloc(sizeof(struct bnx2fc_lport), GFP_KERNEL);		blport = kzalloc(sizeof(struct bnx2fc_lport), GFP_KERNEL);
	if (!blport) {		if (!blport) {
	BNX2FC_HBA_DBG(interface->ctlr.lp, "Unable to alloc blport\n");		BNX2FC_HBA_DBG(ctlr->lp, "Unable to alloc blport\n");
	return NULL;		return NULL;
	}		}

	@@ -1479,7 +1497,8 @@ static void bnx2fc_net_cleanup(struct bnx2fc_interface *interface)

	static void bnx2fc_interface_cleanup(struct bnx2fc_interface *interface)		static void bnx2fc_interface_cleanup(struct bnx2fc_interface *interface)
	{		{
	struct fc_lport *lport = interface->ctlr.lp;		struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
			struct fc_lport *lport = ctlr->lp;
	struct fcoe_port *port = lport_priv(lport);		struct fcoe_port *port = lport_priv(lport);
	struct bnx2fc_hba *hba = interface->hba;		struct bnx2fc_hba *hba = interface->hba;

	@@ -1519,7 +1538,8 @@ static void bnx2fc_if_destroy(struct fc_lport *lport)

	static void __bnx2fc_destroy(struct bnx2fc_interface *interface)		static void __bnx2fc_destroy(struct bnx2fc_interface *interface)
	{		{
	struct fc_lport *lport = interface->ctlr.lp;		struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
			struct fc_lport *lport = ctlr->lp;
	struct fcoe_port *port = lport_priv(lport);		struct fcoe_port *port = lport_priv(lport);

	bnx2fc_interface_cleanup(interface);		bnx2fc_interface_cleanup(interface);
	@@ -1543,13 +1563,15 @@ static int bnx2fc_destroy(struct net_device *netdev)
	{		{
	struct bnx2fc_interface *interface = NULL;		struct bnx2fc_interface *interface = NULL;
	struct workqueue_struct *timer_work_queue;		struct workqueue_struct *timer_work_queue;
			struct fcoe_ctlr *ctlr;
	int rc = 0;		int rc = 0;

	rtnl_lock();		rtnl_lock();
	mutex_lock(&bnx2fc_dev_lock);		mutex_lock(&bnx2fc_dev_lock);

	interface = bnx2fc_interface_lookup(netdev);		interface = bnx2fc_interface_lookup(netdev);
	if (!interface \|\| !interface->ctlr.lp) {		ctlr = bnx2fc_to_ctlr(interface);
			if (!interface \|\| !ctlr->lp) {
	rc = -ENODEV;		rc = -ENODEV;
	printk(KERN_ERR PFX "bnx2fc_destroy: interface or lport not found\n");		printk(KERN_ERR PFX "bnx2fc_destroy: interface or lport not found\n");
	goto netdev_err;		goto netdev_err;
	@@ -1646,6 +1668,7 @@ static void bnx2fc_ulp_start(void *handle)
	{		{
	struct bnx2fc_hba *hba = handle;		struct bnx2fc_hba *hba = handle;
	struct bnx2fc_interface *interface;		struct bnx2fc_interface *interface;
			struct fcoe_ctlr *ctlr;
	struct fc_lport *lport;		struct fc_lport *lport;

	mutex_lock(&bnx2fc_dev_lock);		mutex_lock(&bnx2fc_dev_lock);
	@@ -1657,7 +1680,8 @@ static void bnx2fc_ulp_start(void *handle)

	list_for_each_entry(interface, &if_list, list) {		list_for_each_entry(interface, &if_list, list) {
	if (interface->hba == hba) {		if (interface->hba == hba) {
	lport = interface->ctlr.lp;		ctlr = bnx2fc_to_ctlr(interface);
			lport = ctlr->lp;
	/* Kick off Fabric discovery*/		/* Kick off Fabric discovery*/
	printk(KERN_ERR PFX "ulp_init: start discovery\n");		printk(KERN_ERR PFX "ulp_init: start discovery\n");
	lport->tt.frame_send = bnx2fc_xmit;		lport->tt.frame_send = bnx2fc_xmit;
	@@ -1677,13 +1701,14 @@ static void bnx2fc_port_shutdown(struct fc_lport *lport)

	static void bnx2fc_stop(struct bnx2fc_interface *interface)		static void bnx2fc_stop(struct bnx2fc_interface *interface)
	{		{
			struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
	struct fc_lport *lport;		struct fc_lport *lport;
	struct fc_lport *vport;		struct fc_lport *vport;

	if (!test_bit(BNX2FC_FLAG_FW_INIT_DONE, &interface->hba->flags))		if (!test_bit(BNX2FC_FLAG_FW_INIT_DONE, &interface->hba->flags))
	return;		return;

	lport = interface->ctlr.lp;		lport = ctlr->lp;
	bnx2fc_port_shutdown(lport);		bnx2fc_port_shutdown(lport);

	mutex_lock(&lport->lp_mutex);		mutex_lock(&lport->lp_mutex);
	@@ -1692,7 +1717,7 @@ static void bnx2fc_stop(struct bnx2fc_interface *interface)
	FC_PORTTYPE_UNKNOWN;		FC_PORTTYPE_UNKNOWN;
	mutex_unlock(&lport->lp_mutex);		mutex_unlock(&lport->lp_mutex);
	fc_host_port_type(lport->host) = FC_PORTTYPE_UNKNOWN;		fc_host_port_type(lport->host) = FC_PORTTYPE_UNKNOWN;
	fcoe_ctlr_link_down(&interface->ctlr);		fcoe_ctlr_link_down(ctlr);
	fcoe_clean_pending_queue(lport);		fcoe_clean_pending_queue(lport);
	}		}

	@@ -1804,6 +1829,7 @@ exit:

	static void bnx2fc_start_disc(struct bnx2fc_interface *interface)		static void bnx2fc_start_disc(struct bnx2fc_interface *interface)
	{		{
			struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
	struct fc_lport *lport;		struct fc_lport *lport;
	int wait_cnt = 0;		int wait_cnt = 0;

	@@ -1814,18 +1840,18 @@ static void bnx2fc_start_disc(struct bnx2fc_interface *interface)
	return;		return;
	}		}

	lport = interface->ctlr.lp;		lport = ctlr->lp;
	BNX2FC_HBA_DBG(lport, "calling fc_fabric_login\n");		BNX2FC_HBA_DBG(lport, "calling fc_fabric_login\n");

	if (!bnx2fc_link_ok(lport) && interface->enabled) {		if (!bnx2fc_link_ok(lport) && interface->enabled) {
	BNX2FC_HBA_DBG(lport, "ctlr_link_up\n");		BNX2FC_HBA_DBG(lport, "ctlr_link_up\n");
	fcoe_ctlr_link_up(&interface->ctlr);		fcoe_ctlr_link_up(ctlr);
	fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT;		fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT;
	set_bit(ADAPTER_STATE_READY, &interface->hba->adapter_state);		set_bit(ADAPTER_STATE_READY, &interface->hba->adapter_state);
	}		}

	/* wait for the FCF to be selected before issuing FLOGI */		/* wait for the FCF to be selected before issuing FLOGI */
	while (!interface->ctlr.sel_fcf) {		while (!ctlr->sel_fcf) {
	msleep(250);		msleep(250);
	/* give up after 3 secs */		/* give up after 3 secs */
	if (++wait_cnt > 12)		if (++wait_cnt > 12)
	@@ -1889,19 +1915,21 @@ static void bnx2fc_ulp_init(struct cnic_dev *dev)
	static int bnx2fc_disable(struct net_device *netdev)		static int bnx2fc_disable(struct net_device *netdev)
	{		{
	struct bnx2fc_interface *interface;		struct bnx2fc_interface *interface;
			struct fcoe_ctlr *ctlr;
	int rc = 0;		int rc = 0;

	rtnl_lock();		rtnl_lock();
	mutex_lock(&bnx2fc_dev_lock);		mutex_lock(&bnx2fc_dev_lock);

	interface = bnx2fc_interface_lookup(netdev);		interface = bnx2fc_interface_lookup(netdev);
	if (!interface \|\| !interface->ctlr.lp) {		ctlr = bnx2fc_to_ctlr(interface);
			if (!interface \|\| !ctlr->lp) {
	rc = -ENODEV;		rc = -ENODEV;
	printk(KERN_ERR PFX "bnx2fc_disable: interface or lport not found\n");		printk(KERN_ERR PFX "bnx2fc_disable: interface or lport not found\n");
	} else {		} else {
	interface->enabled = false;		interface->enabled = false;
	fcoe_ctlr_link_down(&interface->ctlr);		fcoe_ctlr_link_down(ctlr);
	fcoe_clean_pending_queue(interface->ctlr.lp);		fcoe_clean_pending_queue(ctlr->lp);
	}		}

	mutex_unlock(&bnx2fc_dev_lock);		mutex_unlock(&bnx2fc_dev_lock);
	@@ -1913,17 +1941,19 @@ static int bnx2fc_disable(struct net_device *netdev)
	static int bnx2fc_enable(struct net_device *netdev)		static int bnx2fc_enable(struct net_device *netdev)
	{		{
	struct bnx2fc_interface *interface;		struct bnx2fc_interface *interface;
			struct fcoe_ctlr *ctlr;
	int rc = 0;		int rc = 0;

	rtnl_lock();		rtnl_lock();
	mutex_lock(&bnx2fc_dev_lock);		mutex_lock(&bnx2fc_dev_lock);

	interface = bnx2fc_interface_lookup(netdev);		interface = bnx2fc_interface_lookup(netdev);
	if (!interface \|\| !interface->ctlr.lp) {		ctlr = bnx2fc_to_ctlr(interface);
			if (!interface \|\| !ctlr->lp) {
	rc = -ENODEV;		rc = -ENODEV;
	printk(KERN_ERR PFX "bnx2fc_enable: interface or lport not found\n");		printk(KERN_ERR PFX "bnx2fc_enable: interface or lport not found\n");
	} else if (!bnx2fc_link_ok(interface->ctlr.lp)) {		} else if (!bnx2fc_link_ok(ctlr->lp)) {
	fcoe_ctlr_link_up(&interface->ctlr);		fcoe_ctlr_link_up(ctlr);
	interface->enabled = true;		interface->enabled = true;
	}		}

	@@ -1944,6 +1974,7 @@ static int bnx2fc_enable(struct net_device *netdev)
	*/		*/
	static int bnx2fc_create(struct net_device *netdev, enum fip_state fip_mode)		static int bnx2fc_create(struct net_device *netdev, enum fip_state fip_mode)
	{		{
			struct fcoe_ctlr *ctlr;
	struct bnx2fc_interface *interface;		struct bnx2fc_interface *interface;
	struct bnx2fc_hba *hba;		struct bnx2fc_hba *hba;
	struct net_device *phys_dev;		struct net_device *phys_dev;
	@@ -2010,6 +2041,7 @@ static int bnx2fc_create(struct net_device *netdev, enum fip_state fip_mode)
	goto ifput_err;		goto ifput_err;
	}		}

			ctlr = bnx2fc_to_ctlr(interface);
	interface->vlan_id = vlan_id;		interface->vlan_id = vlan_id;
	interface->vlan_enabled = 1;		interface->vlan_enabled = 1;

	@@ -2035,10 +2067,10 @@ static int bnx2fc_create(struct net_device *netdev, enum fip_state fip_mode)
	lport->boot_time = jiffies;		lport->boot_time = jiffies;

	/* Make this master N_port */		/* Make this master N_port */
	interface->ctlr.lp = lport;		ctlr->lp = lport;

	if (!bnx2fc_link_ok(lport)) {		if (!bnx2fc_link_ok(lport)) {
	fcoe_ctlr_link_up(&interface->ctlr);		fcoe_ctlr_link_up(ctlr);
	fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT;		fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT;
	set_bit(ADAPTER_STATE_READY, &interface->hba->adapter_state);		set_bit(ADAPTER_STATE_READY, &interface->hba->adapter_state);
	}		}

drivers/scsi/bnx2fc/bnx2fc_hwi.c

+21 −18

Original line number	Original line	Diff line number	Diff line
	@@ -167,6 +167,7 @@ int bnx2fc_send_session_ofld_req(struct fcoe_port *port,
	{		{
	struct fc_lport *lport = port->lport;		struct fc_lport *lport = port->lport;
	struct bnx2fc_interface *interface = port->priv;		struct bnx2fc_interface *interface = port->priv;
			struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
	struct bnx2fc_hba *hba = interface->hba;		struct bnx2fc_hba *hba = interface->hba;
	struct kwqe *kwqe_arr[4];		struct kwqe *kwqe_arr[4];
	struct fcoe_kwqe_conn_offload1 ofld_req1;		struct fcoe_kwqe_conn_offload1 ofld_req1;
	@@ -314,13 +315,13 @@ int bnx2fc_send_session_ofld_req(struct fcoe_port *port,
	ofld_req4.src_mac_addr_mid[1] = port->data_src_addr[2];		ofld_req4.src_mac_addr_mid[1] = port->data_src_addr[2];
	ofld_req4.src_mac_addr_hi[0] = port->data_src_addr[1];		ofld_req4.src_mac_addr_hi[0] = port->data_src_addr[1];
	ofld_req4.src_mac_addr_hi[1] = port->data_src_addr[0];		ofld_req4.src_mac_addr_hi[1] = port->data_src_addr[0];
	ofld_req4.dst_mac_addr_lo[0] = interface->ctlr.dest_addr[5];		ofld_req4.dst_mac_addr_lo[0] = ctlr->dest_addr[5];
	/* fcf mac */		/* fcf mac */
	ofld_req4.dst_mac_addr_lo[1] = interface->ctlr.dest_addr[4];		ofld_req4.dst_mac_addr_lo[1] = ctlr->dest_addr[4];
	ofld_req4.dst_mac_addr_mid[0] = interface->ctlr.dest_addr[3];		ofld_req4.dst_mac_addr_mid[0] = ctlr->dest_addr[3];
	ofld_req4.dst_mac_addr_mid[1] = interface->ctlr.dest_addr[2];		ofld_req4.dst_mac_addr_mid[1] = ctlr->dest_addr[2];
	ofld_req4.dst_mac_addr_hi[0] = interface->ctlr.dest_addr[1];		ofld_req4.dst_mac_addr_hi[0] = ctlr->dest_addr[1];
	ofld_req4.dst_mac_addr_hi[1] = interface->ctlr.dest_addr[0];		ofld_req4.dst_mac_addr_hi[1] = ctlr->dest_addr[0];

	ofld_req4.lcq_addr_lo = (u32) tgt->lcq_dma;		ofld_req4.lcq_addr_lo = (u32) tgt->lcq_dma;
	ofld_req4.lcq_addr_hi = (u32)((u64) tgt->lcq_dma >> 32);		ofld_req4.lcq_addr_hi = (u32)((u64) tgt->lcq_dma >> 32);
	@@ -351,6 +352,7 @@ static int bnx2fc_send_session_enable_req(struct fcoe_port *port,
	{		{
	struct kwqe *kwqe_arr[2];		struct kwqe *kwqe_arr[2];
	struct bnx2fc_interface *interface = port->priv;		struct bnx2fc_interface *interface = port->priv;
			struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
	struct bnx2fc_hba *hba = interface->hba;		struct bnx2fc_hba *hba = interface->hba;
	struct fcoe_kwqe_conn_enable_disable enbl_req;		struct fcoe_kwqe_conn_enable_disable enbl_req;
	struct fc_lport *lport = port->lport;		struct fc_lport *lport = port->lport;
	@@ -374,12 +376,12 @@ static int bnx2fc_send_session_enable_req(struct fcoe_port *port,
	enbl_req.src_mac_addr_hi[1] = port->data_src_addr[0];		enbl_req.src_mac_addr_hi[1] = port->data_src_addr[0];
	memcpy(tgt->src_addr, port->data_src_addr, ETH_ALEN);		memcpy(tgt->src_addr, port->data_src_addr, ETH_ALEN);

	enbl_req.dst_mac_addr_lo[0] = interface->ctlr.dest_addr[5];		enbl_req.dst_mac_addr_lo[0] = ctlr->dest_addr[5];
	enbl_req.dst_mac_addr_lo[1] = interface->ctlr.dest_addr[4];		enbl_req.dst_mac_addr_lo[1] = ctlr->dest_addr[4];
	enbl_req.dst_mac_addr_mid[0] = interface->ctlr.dest_addr[3];		enbl_req.dst_mac_addr_mid[0] = ctlr->dest_addr[3];
	enbl_req.dst_mac_addr_mid[1] = interface->ctlr.dest_addr[2];		enbl_req.dst_mac_addr_mid[1] = ctlr->dest_addr[2];
	enbl_req.dst_mac_addr_hi[0] = interface->ctlr.dest_addr[1];		enbl_req.dst_mac_addr_hi[0] = ctlr->dest_addr[1];
	enbl_req.dst_mac_addr_hi[1] = interface->ctlr.dest_addr[0];		enbl_req.dst_mac_addr_hi[1] = ctlr->dest_addr[0];

	port_id = fc_host_port_id(lport->host);		port_id = fc_host_port_id(lport->host);
	if (port_id != tgt->sid) {		if (port_id != tgt->sid) {
	@@ -419,6 +421,7 @@ int bnx2fc_send_session_disable_req(struct fcoe_port *port,
	struct bnx2fc_rport *tgt)		struct bnx2fc_rport *tgt)
	{		{
	struct bnx2fc_interface *interface = port->priv;		struct bnx2fc_interface *interface = port->priv;
			struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
	struct bnx2fc_hba *hba = interface->hba;		struct bnx2fc_hba *hba = interface->hba;
	struct fcoe_kwqe_conn_enable_disable disable_req;		struct fcoe_kwqe_conn_enable_disable disable_req;
	struct kwqe *kwqe_arr[2];		struct kwqe *kwqe_arr[2];
	@@ -440,12 +443,12 @@ int bnx2fc_send_session_disable_req(struct fcoe_port *port,
	disable_req.src_mac_addr_hi[0] = tgt->src_addr[1];		disable_req.src_mac_addr_hi[0] = tgt->src_addr[1];
	disable_req.src_mac_addr_hi[1] = tgt->src_addr[0];		disable_req.src_mac_addr_hi[1] = tgt->src_addr[0];

	disable_req.dst_mac_addr_lo[0] = interface->ctlr.dest_addr[5];		disable_req.dst_mac_addr_lo[0] = ctlr->dest_addr[5];
	disable_req.dst_mac_addr_lo[1] = interface->ctlr.dest_addr[4];		disable_req.dst_mac_addr_lo[1] = ctlr->dest_addr[4];
	disable_req.dst_mac_addr_mid[0] = interface->ctlr.dest_addr[3];		disable_req.dst_mac_addr_mid[0] = ctlr->dest_addr[3];
	disable_req.dst_mac_addr_mid[1] = interface->ctlr.dest_addr[2];		disable_req.dst_mac_addr_mid[1] = ctlr->dest_addr[2];
	disable_req.dst_mac_addr_hi[0] = interface->ctlr.dest_addr[1];		disable_req.dst_mac_addr_hi[0] = ctlr->dest_addr[1];
	disable_req.dst_mac_addr_hi[1] = interface->ctlr.dest_addr[0];		disable_req.dst_mac_addr_hi[1] = ctlr->dest_addr[0];

	port_id = tgt->sid;		port_id = tgt->sid;
	disable_req.s_id[0] = (port_id & 0x000000FF);		disable_req.s_id[0] = (port_id & 0x000000FF);

Admin message