[deliverable/linux.git] / drivers / scsi / fcoe / fc_transport_fcoe.c

/*
 * Copyright(c) 2007 - 2008 Intel Corporation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Maintained at www.Open-FCoE.org
 */

#include <linux/pci.h>
#include <scsi/libfcoe.h>
#include <scsi/fc_transport_fcoe.h>

/* internal fcoe transport */
struct fcoe_transport_internal {
	struct fcoe_transport *t;
	struct net_device *netdev;
	struct list_head list;
};

/* fcoe transports list and its lock */
static LIST_HEAD(fcoe_transports);
static DEFINE_MUTEX(fcoe_transports_lock);

/**
 * fcoe_transport_default() - Returns ptr to the default transport fcoe_sw
 */
struct fcoe_transport *fcoe_transport_default(void)
{
	return &fcoe_sw_transport;
}

/**
 * fcoe_transport_to_pcidev() - get the pci dev from a netdev
 * @netdev: the netdev that pci dev will be retrived from
 *
 * Returns: NULL or the corrsponding pci_dev
 */
struct pci_dev *fcoe_transport_pcidev(const struct net_device *netdev)
{
	if (!netdev->dev.parent)
		return NULL;
	return to_pci_dev(netdev->dev.parent);
}

/**
 * fcoe_transport_device_lookup() - Lookup a transport
 * @netdev: the netdev the transport to be attached to
 *
 * This will look for existing offload driver, if not found, it falls back to
 * the default sw hba (fcoe_sw) as its fcoe transport.
 *
 * Returns: 0 for success
 */
static struct fcoe_transport_internal *
fcoe_transport_device_lookup(struct fcoe_transport *t,
			     struct net_device *netdev)
{
	struct fcoe_transport_internal *ti;

	/* assign the transpor to this device */
	mutex_lock(&t->devlock);
	list_for_each_entry(ti, &t->devlist, list) {
		if (ti->netdev == netdev) {
			mutex_unlock(&t->devlock);
			return ti;
		}
	}
	mutex_unlock(&t->devlock);
	return NULL;
}
/**
 * fcoe_transport_device_add() - Assign a transport to a device
 * @netdev: the netdev the transport to be attached to
 *
 * This will look for existing offload driver, if not found, it falls back to
 * the default sw hba (fcoe_sw) as its fcoe transport.
 *
 * Returns: 0 for success
 */
static int fcoe_transport_device_add(struct fcoe_transport *t,
				     struct net_device *netdev)
{
	struct fcoe_transport_internal *ti;

	ti = fcoe_transport_device_lookup(t, netdev);
	if (ti) {
		printk(KERN_DEBUG "fcoe_transport_device_add:"
		       "device %s is already added to transport %s\n",
		       netdev->name, t->name);
		return -EEXIST;
	}
	/* allocate an internal struct to host the netdev and the list */
	ti = kzalloc(sizeof(*ti), GFP_KERNEL);
	if (!ti)
		return -ENOMEM;

	ti->t = t;
	ti->netdev = netdev;
	INIT_LIST_HEAD(&ti->list);
	dev_hold(ti->netdev);

	mutex_lock(&t->devlock);
	list_add(&ti->list, &t->devlist);
	mutex_unlock(&t->devlock);

	printk(KERN_DEBUG "fcoe_transport_device_add:"
		       "device %s added to transport %s\n",
		       netdev->name, t->name);

	return 0;
}

/**
 * fcoe_transport_device_remove() - Remove a device from its transport
 * @netdev: the netdev the transport to be attached to
 *
 * This removes the device from the transport so the given transport will
 * not manage this device any more
 *
 * Returns: 0 for success
 */
static int fcoe_transport_device_remove(struct fcoe_transport *t,
					struct net_device *netdev)
{
	struct fcoe_transport_internal *ti;

	ti = fcoe_transport_device_lookup(t, netdev);
	if (!ti) {
		printk(KERN_DEBUG "fcoe_transport_device_remove:"
		       "device %s is not managed by transport %s\n",
		       netdev->name, t->name);
		return -ENODEV;
	}
	mutex_lock(&t->devlock);
	list_del(&ti->list);
	mutex_unlock(&t->devlock);
	printk(KERN_DEBUG "fcoe_transport_device_remove:"
	       "device %s removed from transport %s\n",
	       netdev->name, t->name);
	dev_put(ti->netdev);
	kfree(ti);
	return 0;
}

/**
 * fcoe_transport_device_remove_all() - Remove all from transport devlist
 *
 * This removes the device from the transport so the given transport will
 * not manage this device any more
 *
 * Returns: 0 for success
 */
static void fcoe_transport_device_remove_all(struct fcoe_transport *t)
{
	struct fcoe_transport_internal *ti, *tmp;

	mutex_lock(&t->devlock);
	list_for_each_entry_safe(ti, tmp, &t->devlist, list) {
		list_del(&ti->list);
		kfree(ti);
	}
	mutex_unlock(&t->devlock);
}

/**
 * fcoe_transport_match() - Use the bus device match function to match the hw
 * @t: The fcoe transport to check
 * @netdev: The netdev to match against
 *
 * This function is used to check if the given transport wants to manage the
 * input netdev. if the transports implements the match function, it will be
 * called, o.w. we just compare the pci vendor and device id.
 *
 * Returns: true for match up
 */
static bool fcoe_transport_match(struct fcoe_transport *t,
				 struct net_device *netdev)
{
	/* match transport by vendor and device id */
	struct pci_dev *pci;

	pci = fcoe_transport_pcidev(netdev);

	if (pci) {
		printk(KERN_DEBUG "fcoe_transport_match:"
		       "%s:%x:%x -- %s:%x:%x\n",
		       t->name, t->vendor, t->device,
		       netdev->name, pci->vendor, pci->device);

		/* if transport supports match */
		if (t->match)
			return t->match(netdev);

		/* else just compare the vendor and device id: pci only */
		return (t->vendor == pci->vendor) && (t->device == pci->device);
	}
	return false;
}

/**
 * fcoe_transport_lookup() - Check if the transport is already registered
 * @t: the transport to be looked up
 *
 * This compares the parent device (pci) vendor and device id
 *
 * Returns: NULL if not found
 *
 * TODO: return default sw transport if no other transport is found
 */
static struct fcoe_transport *
fcoe_transport_lookup(struct net_device *netdev)
{
	struct fcoe_transport *t;

	mutex_lock(&fcoe_transports_lock);
	list_for_each_entry(t, &fcoe_transports, list) {
		if (fcoe_transport_match(t, netdev)) {
			mutex_unlock(&fcoe_transports_lock);
			return t;
		}
	}
	mutex_unlock(&fcoe_transports_lock);

	printk(KERN_DEBUG "fcoe_transport_lookup:"
	       "use default transport for %s\n", netdev->name);
	return fcoe_transport_default();
}

/**
 * fcoe_transport_register() - Adds a fcoe transport to the fcoe transports list
 * @t: ptr to the fcoe transport to be added
 *
 * Returns: 0 for success
 */
int fcoe_transport_register(struct fcoe_transport *t)
{
	struct fcoe_transport *tt;

	/* TODO - add fcoe_transport specific initialization here */
	mutex_lock(&fcoe_transports_lock);
	list_for_each_entry(tt, &fcoe_transports, list) {
		if (tt == t) {
			mutex_unlock(&fcoe_transports_lock);
			return -EEXIST;
		}
	}
	list_add_tail(&t->list, &fcoe_transports);
	mutex_unlock(&fcoe_transports_lock);

	mutex_init(&t->devlock);
	INIT_LIST_HEAD(&t->devlist);

	printk(KERN_DEBUG "fcoe_transport_register:%s\n", t->name);

	return 0;
}
EXPORT_SYMBOL_GPL(fcoe_transport_register);

/**
 * fcoe_transport_unregister() - Remove the tranport fro the fcoe transports list
 * @t: ptr to the fcoe transport to be removed
 *
 * Returns: 0 for success
 */
int fcoe_transport_unregister(struct fcoe_transport *t)
{
	struct fcoe_transport *tt, *tmp;

	mutex_lock(&fcoe_transports_lock);
	list_for_each_entry_safe(tt, tmp, &fcoe_transports, list) {
		if (tt == t) {
			list_del(&t->list);
			mutex_unlock(&fcoe_transports_lock);
			fcoe_transport_device_remove_all(t);
			printk(KERN_DEBUG "fcoe_transport_unregister:%s\n",
			       t->name);
			return 0;
		}
	}
	mutex_unlock(&fcoe_transports_lock);
	return -ENODEV;
}
EXPORT_SYMBOL_GPL(fcoe_transport_unregister);

/**
 * fcoe_load_transport_driver() - Load an offload driver by alias name
 * @netdev: the target net device
 *
 * Requests for an offload driver module as the fcoe transport, if fails, it
 * falls back to use the SW HBA (fcoe_sw) as its transport
 *
 * TODO -
 * 	1. supports only PCI device
 * 	2. needs fix for VLAn and bonding
 * 	3. pure hw fcoe hba may not have netdev
 *
 * Returns: 0 for success
 */
int fcoe_load_transport_driver(struct net_device *netdev)
{
	struct pci_dev *pci;
	struct device *dev = netdev->dev.parent;

	if (fcoe_transport_lookup(netdev)) {
		/* load default transport */
		printk(KERN_DEBUG "fcoe: already loaded transport for %s\n",
		       netdev->name);
		return -EEXIST;
	}

	pci = to_pci_dev(dev);
	if (dev->bus != &pci_bus_type) {
		printk(KERN_DEBUG "fcoe: support noly PCI device\n");
		return -ENODEV;
	}
	printk(KERN_DEBUG "fcoe: loading driver fcoe-pci-0x%04x-0x%04x\n",
	       pci->vendor, pci->device);

	return request_module("fcoe-pci-0x%04x-0x%04x",
			      pci->vendor, pci->device);

}
EXPORT_SYMBOL_GPL(fcoe_load_transport_driver);

/**
 * fcoe_transport_attach() - Load transport to fcoe
 * @netdev: the netdev the transport to be attached to
 *
 * This will look for existing offload driver, if not found, it falls back to
 * the default sw hba (fcoe_sw) as its fcoe transport.
 *
 * Returns: 0 for success
 */
int fcoe_transport_attach(struct net_device *netdev)
{
	struct fcoe_transport *t;

	/* find the corresponding transport */
	t = fcoe_transport_lookup(netdev);
	if (!t) {
		printk(KERN_DEBUG "fcoe_transport_attach"
		       ":no transport for %s:use %s\n",
		       netdev->name, t->name);
		return -ENODEV;
	}
	/* add to the transport */
	if (fcoe_transport_device_add(t, netdev)) {
		printk(KERN_DEBUG "fcoe_transport_attach"
		       ":failed to add %s to tramsport %s\n",
		       netdev->name, t->name);
		return -EIO;
	}
	/* transport create function */
	if (t->create)
		t->create(netdev);

	printk(KERN_DEBUG "fcoe_transport_attach:transport %s for %s\n",
	       t->name, netdev->name);
	return 0;
}
EXPORT_SYMBOL_GPL(fcoe_transport_attach);

/**
 * fcoe_transport_release() - Unload transport from fcoe
 * @netdev: the net device on which fcoe is to be released
 *
 * Returns: 0 for success
 */
int fcoe_transport_release(struct net_device *netdev)
{
	struct fcoe_transport *t;

	/* find the corresponding transport */
	t = fcoe_transport_lookup(netdev);
	if (!t) {
		printk(KERN_DEBUG "fcoe_transport_release:"
		       "no transport for %s:use %s\n",
		       netdev->name, t->name);
		return -ENODEV;
	}
	/* remove the device from the transport */
	if (fcoe_transport_device_remove(t, netdev)) {
		printk(KERN_DEBUG "fcoe_transport_release:"
		       "failed to add %s to tramsport %s\n",
		       netdev->name, t->name);
		return -EIO;
	}
	/* transport destroy function */
	if (t->destroy)
		t->destroy(netdev);

	printk(KERN_DEBUG "fcoe_transport_release:"
	       "device %s dettached from transport %s\n",
	       netdev->name, t->name);

	return 0;
}
EXPORT_SYMBOL_GPL(fcoe_transport_release);

/**
 * fcoe_transport_init() - Initializes fcoe transport layer
 *
 * This prepares for the fcoe transport layer
 *
 * Returns: none
 */
int __init fcoe_transport_init(void)
{
	INIT_LIST_HEAD(&fcoe_transports);
	mutex_init(&fcoe_transports_lock);
	return 0;
}

/**
 * fcoe_transport_exit() - Cleans up the fcoe transport layer
 *
 * This cleans up the fcoe transport layer. removing any transport on the list,
 * note that the transport destroy func is not called here.
 *
 * Returns: none
 */
int __exit fcoe_transport_exit(void)
{
	struct fcoe_transport *t, *tmp;

	mutex_lock(&fcoe_transports_lock);
	list_for_each_entry_safe(t, tmp, &fcoe_transports, list) {
		list_del(&t->list);
		mutex_unlock(&fcoe_transports_lock);
		fcoe_transport_device_remove_all(t);
		mutex_lock(&fcoe_transports_lock);
	}
	mutex_unlock(&fcoe_transports_lock);
	return 0;
}
Commit	Line	Data
85b4aa49 RL	1	/*
	2	* Copyright(c) 2007 - 2008 Intel Corporation. All rights reserved.
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms and conditions of the GNU General Public License,
	6	* version 2, as published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope it will be useful, but WITHOUT
	9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	10	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	11	* more details.
	12	*
	13	* You should have received a copy of the GNU General Public License along with
	14	* this program; if not, write to the Free Software Foundation, Inc.,
	15	* 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
	16	*
	17	* Maintained at www.Open-FCoE.org
	18	*/
	19
	20	#include <linux/pci.h>
	21	#include <scsi/libfcoe.h>
	22	#include <scsi/fc_transport_fcoe.h>
	23
	24	/* internal fcoe transport */
	25	struct fcoe_transport_internal {
	26	struct fcoe_transport *t;
	27	struct net_device *netdev;
	28	struct list_head list;
	29	};
	30
	31	/* fcoe transports list and its lock */
	32	static LIST_HEAD(fcoe_transports);
	33	static DEFINE_MUTEX(fcoe_transports_lock);
	34
	35	/**
34f42a07 RL	36	* fcoe_transport_default() - Returns ptr to the default transport fcoe_sw
34f42a07 RL	37	*/
85b4aa49 RL	38	struct fcoe_transport *fcoe_transport_default(void)
	39	{
	40	return &fcoe_sw_transport;
	41	}
	42
	43	/**
34f42a07	44	* fcoe_transport_to_pcidev() - get the pci dev from a netdev
85b4aa49 RL	45	* @netdev: the netdev that pci dev will be retrived from
	46	*
	47	* Returns: NULL or the corrsponding pci_dev
34f42a07	48	*/
85b4aa49 RL	49	struct pci_dev fcoe_transport_pcidev(const struct net_device netdev)
	50	{
	51	if (!netdev->dev.parent)
	52	return NULL;
	53	return to_pci_dev(netdev->dev.parent);
	54	}
	55
	56	/**
34f42a07	57	* fcoe_transport_device_lookup() - Lookup a transport
85b4aa49 RL	58	* @netdev: the netdev the transport to be attached to
	59	*
	60	* This will look for existing offload driver, if not found, it falls back to
	61	* the default sw hba (fcoe_sw) as its fcoe transport.
	62	*
	63	* Returns: 0 for success
34f42a07	64	*/
b2ab99c9 RL	65	static struct fcoe_transport_internal *
	66	fcoe_transport_device_lookup(struct fcoe_transport *t,
	67	struct net_device *netdev)
85b4aa49 RL	68	{
	69	struct fcoe_transport_internal *ti;
	70
	71	/* assign the transpor to this device */
	72	mutex_lock(&t->devlock);
	73	list_for_each_entry(ti, &t->devlist, list) {
	74	if (ti->netdev == netdev) {
	75	mutex_unlock(&t->devlock);
	76	return ti;
	77	}
	78	}
	79	mutex_unlock(&t->devlock);
	80	return NULL;
	81	}
	82	/**
34f42a07	83	* fcoe_transport_device_add() - Assign a transport to a device
85b4aa49 RL	84	* @netdev: the netdev the transport to be attached to
	85	*
	86	* This will look for existing offload driver, if not found, it falls back to
	87	* the default sw hba (fcoe_sw) as its fcoe transport.
	88	*
	89	* Returns: 0 for success
34f42a07	90	*/
85b4aa49 RL	91	static int fcoe_transport_device_add(struct fcoe_transport *t,
	92	struct net_device *netdev)
	93	{
	94	struct fcoe_transport_internal *ti;
	95
	96	ti = fcoe_transport_device_lookup(t, netdev);
	97	if (ti) {
	98	printk(KERN_DEBUG "fcoe_transport_device_add:"
	99	"device %s is already added to transport %s\n",
	100	netdev->name, t->name);
	101	return -EEXIST;
	102	}
	103	/* allocate an internal struct to host the netdev and the list */
	104	ti = kzalloc(sizeof(*ti), GFP_KERNEL);
	105	if (!ti)
	106	return -ENOMEM;
	107
	108	ti->t = t;
	109	ti->netdev = netdev;
	110	INIT_LIST_HEAD(&ti->list);
	111	dev_hold(ti->netdev);
	112
	113	mutex_lock(&t->devlock);
	114	list_add(&ti->list, &t->devlist);
	115	mutex_unlock(&t->devlock);
	116
	117	printk(KERN_DEBUG "fcoe_transport_device_add:"
	118	"device %s added to transport %s\n",
	119	netdev->name, t->name);
	120
	121	return 0;
	122	}
	123
	124	/**
34f42a07	125	* fcoe_transport_device_remove() - Remove a device from its transport
85b4aa49 RL	126	* @netdev: the netdev the transport to be attached to
85b4aa49 RL	127	*
34f42a07	128	* This removes the device from the transport so the given transport will
85b4aa49 RL	129	* not manage this device any more
	130	*
	131	* Returns: 0 for success
34f42a07	132	*/
85b4aa49 RL	133	static int fcoe_transport_device_remove(struct fcoe_transport *t,
	134	struct net_device *netdev)
	135	{
	136	struct fcoe_transport_internal *ti;
	137
	138	ti = fcoe_transport_device_lookup(t, netdev);
	139	if (!ti) {
	140	printk(KERN_DEBUG "fcoe_transport_device_remove:"
	141	"device %s is not managed by transport %s\n",
	142	netdev->name, t->name);
	143	return -ENODEV;
	144	}
	145	mutex_lock(&t->devlock);
	146	list_del(&ti->list);
	147	mutex_unlock(&t->devlock);
	148	printk(KERN_DEBUG "fcoe_transport_device_remove:"
	149	"device %s removed from transport %s\n",
	150	netdev->name, t->name);
	151	dev_put(ti->netdev);
	152	kfree(ti);
	153	return 0;
	154	}
	155
	156	/**
34f42a07	157	* fcoe_transport_device_remove_all() - Remove all from transport devlist
85b4aa49	158	*
34f42a07	159	* This removes the device from the transport so the given transport will
85b4aa49 RL	160	* not manage this device any more
	161	*
	162	* Returns: 0 for success
34f42a07	163	*/
85b4aa49 RL	164	static void fcoe_transport_device_remove_all(struct fcoe_transport *t)
	165	{
	166	struct fcoe_transport_internal ti, tmp;
	167
	168	mutex_lock(&t->devlock);
	169	list_for_each_entry_safe(ti, tmp, &t->devlist, list) {
	170	list_del(&ti->list);
	171	kfree(ti);
	172	}
	173	mutex_unlock(&t->devlock);
	174	}
	175
	176	/**
34f42a07 RL	177	* fcoe_transport_match() - Use the bus device match function to match the hw
	178	* @t: The fcoe transport to check
	179	* @netdev: The netdev to match against
85b4aa49	180	*
34f42a07	181	* This function is used to check if the given transport wants to manage the
85b4aa49 RL	182	* input netdev. if the transports implements the match function, it will be
	183	* called, o.w. we just compare the pci vendor and device id.
	184	*
	185	* Returns: true for match up
34f42a07	186	*/
85b4aa49	187	static bool fcoe_transport_match(struct fcoe_transport *t,
b2ab99c9	188	struct net_device *netdev)
85b4aa49 RL	189	{
	190	/* match transport by vendor and device id */
	191	struct pci_dev *pci;
	192
	193	pci = fcoe_transport_pcidev(netdev);
	194
	195	if (pci) {
	196	printk(KERN_DEBUG "fcoe_transport_match:"
	197	"%s:%x:%x -- %s:%x:%x\n",
	198	t->name, t->vendor, t->device,
	199	netdev->name, pci->vendor, pci->device);
	200
	201	/* if transport supports match */
	202	if (t->match)
	203	return t->match(netdev);
	204
	205	/* else just compare the vendor and device id: pci only */
	206	return (t->vendor == pci->vendor) && (t->device == pci->device);
	207	}
	208	return false;
	209	}
	210
	211	/**
34f42a07	212	* fcoe_transport_lookup() - Check if the transport is already registered
85b4aa49 RL	213	* @t: the transport to be looked up
	214	*
	215	* This compares the parent device (pci) vendor and device id
	216	*
	217	* Returns: NULL if not found
	218	*
34f42a07 RL	219	* TODO: return default sw transport if no other transport is found
34f42a07 RL	220	*/
b2ab99c9 RL	221	static struct fcoe_transport *
b2ab99c9 RL	222	fcoe_transport_lookup(struct net_device *netdev)
85b4aa49 RL	223	{
	224	struct fcoe_transport *t;
	225
	226	mutex_lock(&fcoe_transports_lock);
	227	list_for_each_entry(t, &fcoe_transports, list) {
	228	if (fcoe_transport_match(t, netdev)) {
	229	mutex_unlock(&fcoe_transports_lock);
	230	return t;
	231	}
	232	}
	233	mutex_unlock(&fcoe_transports_lock);
	234
	235	printk(KERN_DEBUG "fcoe_transport_lookup:"
	236	"use default transport for %s\n", netdev->name);
	237	return fcoe_transport_default();
	238	}
	239
	240	/**
34f42a07	241	* fcoe_transport_register() - Adds a fcoe transport to the fcoe transports list
85b4aa49 RL	242	* @t: ptr to the fcoe transport to be added
	243	*
	244	* Returns: 0 for success
34f42a07	245	*/
85b4aa49 RL	246	int fcoe_transport_register(struct fcoe_transport *t)
	247	{
	248	struct fcoe_transport *tt;
	249
	250	/* TODO - add fcoe_transport specific initialization here */
	251	mutex_lock(&fcoe_transports_lock);
	252	list_for_each_entry(tt, &fcoe_transports, list) {
	253	if (tt == t) {
	254	mutex_unlock(&fcoe_transports_lock);
	255	return -EEXIST;
	256	}
	257	}
	258	list_add_tail(&t->list, &fcoe_transports);
	259	mutex_unlock(&fcoe_transports_lock);
	260
	261	mutex_init(&t->devlock);
	262	INIT_LIST_HEAD(&t->devlist);
	263
	264	printk(KERN_DEBUG "fcoe_transport_register:%s\n", t->name);
	265
	266	return 0;
	267	}
	268	EXPORT_SYMBOL_GPL(fcoe_transport_register);
	269
	270	/**
34f42a07	271	* fcoe_transport_unregister() - Remove the tranport fro the fcoe transports list
85b4aa49 RL	272	* @t: ptr to the fcoe transport to be removed
	273	*
	274	* Returns: 0 for success
34f42a07	275	*/
85b4aa49 RL	276	int fcoe_transport_unregister(struct fcoe_transport *t)
	277	{
	278	struct fcoe_transport tt, tmp;
	279
	280	mutex_lock(&fcoe_transports_lock);
	281	list_for_each_entry_safe(tt, tmp, &fcoe_transports, list) {
	282	if (tt == t) {
	283	list_del(&t->list);
	284	mutex_unlock(&fcoe_transports_lock);
	285	fcoe_transport_device_remove_all(t);
	286	printk(KERN_DEBUG "fcoe_transport_unregister:%s\n",
	287	t->name);
	288	return 0;
	289	}
	290	}
	291	mutex_unlock(&fcoe_transports_lock);
	292	return -ENODEV;
	293	}
	294	EXPORT_SYMBOL_GPL(fcoe_transport_unregister);
	295
34f42a07 RL	296	/**
34f42a07 RL	297	* fcoe_load_transport_driver() - Load an offload driver by alias name
85b4aa49 RL	298	* @netdev: the target net device
	299	*
	300	* Requests for an offload driver module as the fcoe transport, if fails, it
	301	* falls back to use the SW HBA (fcoe_sw) as its transport
	302	*
	303	* TODO -
	304	* 1. supports only PCI device
	305	* 2. needs fix for VLAn and bonding
	306	* 3. pure hw fcoe hba may not have netdev
	307	*
	308	* Returns: 0 for success
34f42a07	309	*/
85b4aa49 RL	310	int fcoe_load_transport_driver(struct net_device *netdev)
	311	{
	312	struct pci_dev *pci;
	313	struct device *dev = netdev->dev.parent;
	314
	315	if (fcoe_transport_lookup(netdev)) {
	316	/* load default transport */
	317	printk(KERN_DEBUG "fcoe: already loaded transport for %s\n",
	318	netdev->name);
	319	return -EEXIST;
	320	}
	321
	322	pci = to_pci_dev(dev);
	323	if (dev->bus != &pci_bus_type) {
	324	printk(KERN_DEBUG "fcoe: support noly PCI device\n");
	325	return -ENODEV;
	326	}
	327	printk(KERN_DEBUG "fcoe: loading driver fcoe-pci-0x%04x-0x%04x\n",
	328	pci->vendor, pci->device);
	329
	330	return request_module("fcoe-pci-0x%04x-0x%04x",
	331	pci->vendor, pci->device);
	332
	333	}
	334	EXPORT_SYMBOL_GPL(fcoe_load_transport_driver);
	335
	336	/**
34f42a07	337	* fcoe_transport_attach() - Load transport to fcoe
85b4aa49 RL	338	* @netdev: the netdev the transport to be attached to
	339	*
	340	* This will look for existing offload driver, if not found, it falls back to
	341	* the default sw hba (fcoe_sw) as its fcoe transport.
	342	*
	343	* Returns: 0 for success
34f42a07	344	*/
85b4aa49 RL	345	int fcoe_transport_attach(struct net_device *netdev)
	346	{
	347	struct fcoe_transport *t;
	348
	349	/* find the corresponding transport */
	350	t = fcoe_transport_lookup(netdev);
	351	if (!t) {
	352	printk(KERN_DEBUG "fcoe_transport_attach"
	353	":no transport for %s:use %s\n",
	354	netdev->name, t->name);
	355	return -ENODEV;
	356	}
	357	/* add to the transport */
	358	if (fcoe_transport_device_add(t, netdev)) {
	359	printk(KERN_DEBUG "fcoe_transport_attach"
	360	":failed to add %s to tramsport %s\n",
	361	netdev->name, t->name);
	362	return -EIO;
	363	}
	364	/* transport create function */
	365	if (t->create)
	366	t->create(netdev);
	367
	368	printk(KERN_DEBUG "fcoe_transport_attach:transport %s for %s\n",
	369	t->name, netdev->name);
	370	return 0;
	371	}
	372	EXPORT_SYMBOL_GPL(fcoe_transport_attach);
	373
	374	/**
34f42a07	375	* fcoe_transport_release() - Unload transport from fcoe
85b4aa49 RL	376	* @netdev: the net device on which fcoe is to be released
	377	*
	378	* Returns: 0 for success
34f42a07	379	*/
85b4aa49 RL	380	int fcoe_transport_release(struct net_device *netdev)
	381	{
	382	struct fcoe_transport *t;
	383
	384	/* find the corresponding transport */
	385	t = fcoe_transport_lookup(netdev);
	386	if (!t) {
	387	printk(KERN_DEBUG "fcoe_transport_release:"
	388	"no transport for %s:use %s\n",
	389	netdev->name, t->name);
	390	return -ENODEV;
	391	}
	392	/* remove the device from the transport */
	393	if (fcoe_transport_device_remove(t, netdev)) {
	394	printk(KERN_DEBUG "fcoe_transport_release:"
	395	"failed to add %s to tramsport %s\n",
	396	netdev->name, t->name);
	397	return -EIO;
	398	}
	399	/* transport destroy function */
	400	if (t->destroy)
	401	t->destroy(netdev);
	402
	403	printk(KERN_DEBUG "fcoe_transport_release:"
	404	"device %s dettached from transport %s\n",
	405	netdev->name, t->name);
	406
	407	return 0;
	408	}
	409	EXPORT_SYMBOL_GPL(fcoe_transport_release);
	410
	411	/**
34f42a07	412	* fcoe_transport_init() - Initializes fcoe transport layer
85b4aa49 RL	413	*
	414	* This prepares for the fcoe transport layer
	415	*
	416	* Returns: none
34f42a07	417	*/
85b4aa49 RL	418	int __init fcoe_transport_init(void)
	419	{
	420	INIT_LIST_HEAD(&fcoe_transports);
	421	mutex_init(&fcoe_transports_lock);
	422	return 0;
	423	}
	424
	425	/**
34f42a07 RL	426	* fcoe_transport_exit() - Cleans up the fcoe transport layer
34f42a07 RL	427	*
85b4aa49 RL	428	* This cleans up the fcoe transport layer. removing any transport on the list,
	429	* note that the transport destroy func is not called here.
	430	*
	431	* Returns: none
34f42a07	432	*/
85b4aa49 RL	433	int __exit fcoe_transport_exit(void)
	434	{
	435	struct fcoe_transport t, tmp;
	436
	437	mutex_lock(&fcoe_transports_lock);
	438	list_for_each_entry_safe(t, tmp, &fcoe_transports, list) {
	439	list_del(&t->list);
	440	mutex_unlock(&fcoe_transports_lock);
	441	fcoe_transport_device_remove_all(t);
	442	mutex_lock(&fcoe_transports_lock);
	443	}
	444	mutex_unlock(&fcoe_transports_lock);
	445	return 0;
	446	}