Eric Lee / smarc-fsl-linux-kernel

Blame view

drivers/ide/ide-scan-pci.c 2.73 KB
edit raw normal view history
81f7e3824   Eric Lee   Initial Release, ... 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
  /*
   * support for probing IDE PCI devices in the PCI bus order
   *
   * Copyright (c) 1998-2000  Andre Hedrick <andre@linux-ide.org>
   * 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
  ",
  					__func__, d->driver.mod_name);
  	}
  
  	return 0;
  }
  device_initcall(ide_scan_pcibus);