[linux.git] / drivers / ide / ide-scan-pci.c

/*
 * support for probing IDE PCI devices in the PCI bus order
 *
 * Copyright (c) 1998-2000  Andre Hedrick <[email protected]>
 * Copyright (c) 1995-1998  Mark Lord
 *
 * May be copied or modified under the terms of the GNU General Public License
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/ide.h>

/*
 *	Module interfaces
 */

static int pre_init = 1;		/* Before first ordered IDE scan */
static LIST_HEAD(ide_pci_drivers);

/*
 *	__ide_pci_register_driver	-	attach IDE driver
 *	@driver: pci driver
 *	@module: owner module of the driver
 *
 *	Registers a driver with the IDE layer. The IDE layer arranges that
 *	boot time setup is done in the expected device order and then
 *	hands the controllers off to the core PCI code to do the rest of
 *	the work.
 *
 *	Returns are the same as for pci_register_driver
 */

int __ide_pci_register_driver(struct pci_driver *driver, struct module *module,
			      const char *mod_name)
{
	if (!pre_init)
		return __pci_register_driver(driver, module, mod_name);
	driver->driver.owner = module;
	list_add_tail(&driver->node, &ide_pci_drivers);
	return 0;
}
EXPORT_SYMBOL_GPL(__ide_pci_register_driver);

/**
 *	ide_scan_pcidev		-	find an IDE driver for a device
 *	@dev: PCI device to check
 *
 *	Look for an IDE driver to handle the device we are considering.
 *	This is only used during boot up to get the ordering correct. After
 *	boot up the pci layer takes over the job.
 */

static int __init ide_scan_pcidev(struct pci_dev *dev)
{
	struct list_head *l;
	struct pci_driver *d;
	int ret;

	list_for_each(l, &ide_pci_drivers) {
		d = list_entry(l, struct pci_driver, node);
		if (d->id_table) {
			const struct pci_device_id *id =
				pci_match_id(d->id_table, dev);

			if (id != NULL) {
				pci_assign_irq(dev);
				ret = d->probe(dev, id);
				if (ret >= 0) {
					dev->driver = d;
					pci_dev_get(dev);
					return 1;
				}
			}
		}
	}
	return 0;
}

/**
 *	ide_scan_pcibus		-	perform the initial IDE driver scan
 *
 *	Perform the initial bus rather than driver ordered scan of the
 *	PCI drivers. After this all IDE pci handling becomes standard
 *	module ordering not traditionally ordered.
 */

static int __init ide_scan_pcibus(void)
{
	struct pci_dev *dev = NULL;
	struct pci_driver *d;
	struct list_head *l, *n;

	pre_init = 0;
	for_each_pci_dev(dev)
		ide_scan_pcidev(dev);

	/*
	 *	Hand the drivers over to the PCI layer now we
	 *	are post init.
	 */

	list_for_each_safe(l, n, &ide_pci_drivers) {
		list_del(l);
		d = list_entry(l, struct pci_driver, node);
		if (__pci_register_driver(d, d->driver.owner,
					  d->driver.mod_name))
			printk(KERN_ERR "%s: failed to register %s driver\n",
					__func__, d->driver.mod_name);
	}

	return 0;
}
device_initcall(ide_scan_pcibus);
Commit	Line	Data
9ac59226 BZ	1	/*
	2	* support for probing IDE PCI devices in the PCI bus order
	3	*
	4	* Copyright (c) 1998-2000 Andre Hedrick <[email protected]>
	5	* Copyright (c) 1995-1998 Mark Lord
	6	*
	7	* May be copied or modified under the terms of the GNU General Public License
	8	*/
	9
ade2daf9 BZ	10	#include <linux/kernel.h>
	11	#include <linux/init.h>
	12	#include <linux/module.h>
	13	#include <linux/ide.h>
	14
9ac59226 BZ	15	/*
	16	* Module interfaces
	17	*/
	18
	19	static int pre_init = 1; /* Before first ordered IDE scan */
	20	static LIST_HEAD(ide_pci_drivers);
	21
	22	/*
	23	* __ide_pci_register_driver - attach IDE driver
	24	* @driver: pci driver
	25	* @module: owner module of the driver
	26	*
	27	* Registers a driver with the IDE layer. The IDE layer arranges that
	28	* boot time setup is done in the expected device order and then
	29	* hands the controllers off to the core PCI code to do the rest of
	30	* the work.
	31	*
	32	* Returns are the same as for pci_register_driver
	33	*/
	34
	35	int __ide_pci_register_driver(struct pci_driver driver, struct module module,
	36	const char *mod_name)
	37	{
	38	if (!pre_init)
	39	return __pci_register_driver(driver, module, mod_name);
	40	driver->driver.owner = module;
	41	list_add_tail(&driver->node, &ide_pci_drivers);
	42	return 0;
	43	}
	44	EXPORT_SYMBOL_GPL(__ide_pci_register_driver);
	45
	46	/**
	47	* ide_scan_pcidev - find an IDE driver for a device
	48	* @dev: PCI device to check
	49	*
	50	* Look for an IDE driver to handle the device we are considering.
	51	* This is only used during boot up to get the ordering correct. After
	52	* boot up the pci layer takes over the job.
	53	*/
	54
	55	static int __init ide_scan_pcidev(struct pci_dev *dev)
	56	{
	57	struct list_head *l;
	58	struct pci_driver *d;
b1f9e5e3	59	int ret;
9ac59226 BZ	60
	61	list_for_each(l, &ide_pci_drivers) {
	62	d = list_entry(l, struct pci_driver, node);
	63	if (d->id_table) {
	64	const struct pci_device_id *id =
	65	pci_match_id(d->id_table, dev);
	66
b1f9e5e3 LP	67	if (id != NULL) {
	68	pci_assign_irq(dev);
	69	ret = d->probe(dev, id);
	70	if (ret >= 0) {
	71	dev->driver = d;
	72	pci_dev_get(dev);
	73	return 1;
	74	}
9ac59226 BZ	75	}
	76	}
	77	}
	78	return 0;
	79	}
	80
	81	/**
	82	* ide_scan_pcibus - perform the initial IDE driver scan
	83	*
	84	* Perform the initial bus rather than driver ordered scan of the
	85	* PCI drivers. After this all IDE pci handling becomes standard
	86	* module ordering not traditionally ordered.
	87	*/
	88
2eae6ebb	89	static int __init ide_scan_pcibus(void)
9ac59226 BZ	90	{
	91	struct pci_dev *dev = NULL;
	92	struct pci_driver *d;
	93	struct list_head l, n;
	94
	95	pre_init = 0;
db210f82	96	for_each_pci_dev(dev)
a594eeb1	97	ide_scan_pcidev(dev);
9ac59226 BZ	98
	99	/*
	100	* Hand the drivers over to the PCI layer now we
	101	* are post init.
	102	*/
	103
	104	list_for_each_safe(l, n, &ide_pci_drivers) {
	105	list_del(l);
	106	d = list_entry(l, struct pci_driver, node);
	107	if (__pci_register_driver(d, d->driver.owner,
	108	d->driver.mod_name))
	109	printk(KERN_ERR "%s: failed to register %s driver\n",
eb63963a	110	__func__, d->driver.mod_name);
9ac59226 BZ	111	}
	112
	113	return 0;
	114	}
e04a2bd6	115	device_initcall(ide_scan_pcibus);