ia64/linux-2.6.18-xen.hg

view drivers/pci/pci-driver.c @ 882:8dec4aa9b8b9

PCI pass through: PCIe IO space multiplexing

This is required for more than 16 HVM domain to boot from
PCIe pass through device.

Linux as dom0 exclusively assigns IO space to downstream PCI bridges
and the assignment unit of PCI bridge IO space is 4K. So the only up
to 16 PCIe device can be accessed via IO space within 64K IO ports.
PCI expansion ROM BIOS often uses IO port access to boot from the
device, so on virtualized environment, it means only up to 16 guest
domain can boot from pass-through device.

This patch allows PCIe IO space sharing of pass-through device.
- reassign IO space of PCIe devices specified by
"guestiomuldev=[<segment>:]<bus>:<dev>[,[<segment:><bus>:dev]][,...]"
to be shared.
This is implemented as Linux PCI quirk fixup.

The sharing unit is PCIe switch. Ie IO space of the end point
devices under the same switch will be shared. If there are more than
one switches, two areas of IO space will be used.

- And the driver which arbitrates the accesses to the multiplexed PCIe
IO space. Later qemu-dm will use this.

Limitation:
IO port of IO shared devices can't be accessed from dom0 Linux device
driver. But this wouldn't be a big issue because PCIe specification
discourages the use of IO space and recommends that IO space should be
used only for bootable device with ROM code. OS device driver should
work without IO space access.

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
author Keir Fraser <keir.fraser@citrix.com>
date Thu May 28 09:57:49 2009 +0100 (2009-05-28)
parents 831230e53067
children
line source
1 /*
2 * drivers/pci/pci-driver.c
3 *
4 */
6 #include <linux/pci.h>
7 #include <linux/module.h>
8 #include <linux/init.h>
9 #include <linux/device.h>
10 #include <linux/mempolicy.h>
11 #include <linux/string.h>
12 #include <linux/slab.h>
13 #include <linux/sched.h>
14 #include "pci.h"
16 /*
17 * Registration of PCI drivers and handling of hot-pluggable devices.
18 */
20 /*
21 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
22 */
24 struct pci_dynid {
25 struct list_head node;
26 struct pci_device_id id;
27 };
29 #ifdef CONFIG_HOTPLUG
31 /**
32 * store_new_id - add a new PCI device ID to this driver and re-probe devices
33 * @driver: target device driver
34 * @buf: buffer for scanning device ID data
35 * @count: input size
36 *
37 * Adds a new dynamic pci device ID to this driver,
38 * and causes the driver to probe for all devices again.
39 */
40 static ssize_t
41 store_new_id(struct device_driver *driver, const char *buf, size_t count)
42 {
43 struct pci_dynid *dynid;
44 struct pci_driver *pdrv = to_pci_driver(driver);
45 __u32 vendor=PCI_ANY_ID, device=PCI_ANY_ID, subvendor=PCI_ANY_ID,
46 subdevice=PCI_ANY_ID, class=0, class_mask=0;
47 unsigned long driver_data=0;
48 int fields=0;
50 fields = sscanf(buf, "%x %x %x %x %x %x %lux",
51 &vendor, &device, &subvendor, &subdevice,
52 &class, &class_mask, &driver_data);
53 if (fields < 0)
54 return -EINVAL;
56 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
57 if (!dynid)
58 return -ENOMEM;
60 INIT_LIST_HEAD(&dynid->node);
61 dynid->id.vendor = vendor;
62 dynid->id.device = device;
63 dynid->id.subvendor = subvendor;
64 dynid->id.subdevice = subdevice;
65 dynid->id.class = class;
66 dynid->id.class_mask = class_mask;
67 dynid->id.driver_data = pdrv->dynids.use_driver_data ?
68 driver_data : 0UL;
70 spin_lock(&pdrv->dynids.lock);
71 list_add_tail(&pdrv->dynids.list, &dynid->node);
72 spin_unlock(&pdrv->dynids.lock);
74 if (get_driver(&pdrv->driver)) {
75 driver_attach(&pdrv->driver);
76 put_driver(&pdrv->driver);
77 }
79 return count;
80 }
81 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
83 static void
84 pci_free_dynids(struct pci_driver *drv)
85 {
86 struct pci_dynid *dynid, *n;
88 spin_lock(&drv->dynids.lock);
89 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
90 list_del(&dynid->node);
91 kfree(dynid);
92 }
93 spin_unlock(&drv->dynids.lock);
94 }
96 static int
97 pci_create_newid_file(struct pci_driver *drv)
98 {
99 int error = 0;
100 if (drv->probe != NULL)
101 error = sysfs_create_file(&drv->driver.kobj,
102 &driver_attr_new_id.attr);
103 return error;
104 }
106 #else /* !CONFIG_HOTPLUG */
107 static inline void pci_free_dynids(struct pci_driver *drv) {}
108 static inline int pci_create_newid_file(struct pci_driver *drv)
109 {
110 return 0;
111 }
112 #endif
114 /**
115 * pci_match_id - See if a pci device matches a given pci_id table
116 * @ids: array of PCI device id structures to search in
117 * @dev: the PCI device structure to match against.
118 *
119 * Used by a driver to check whether a PCI device present in the
120 * system is in its list of supported devices. Returns the matching
121 * pci_device_id structure or %NULL if there is no match.
122 *
123 * Depreciated, don't use this as it will not catch any dynamic ids
124 * that a driver might want to check for.
125 */
126 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
127 struct pci_dev *dev)
128 {
129 if (ids) {
130 while (ids->vendor || ids->subvendor || ids->class_mask) {
131 if (pci_match_one_device(ids, dev))
132 return ids;
133 ids++;
134 }
135 }
136 return NULL;
137 }
139 /**
140 * pci_match_device - Tell if a PCI device structure has a matching
141 * PCI device id structure
142 * @drv: the PCI driver to match against
143 * @dev: the PCI device structure to match against
144 *
145 * Used by a driver to check whether a PCI device present in the
146 * system is in its list of supported devices. Returns the matching
147 * pci_device_id structure or %NULL if there is no match.
148 */
149 const struct pci_device_id *pci_match_device(struct pci_driver *drv,
150 struct pci_dev *dev)
151 {
152 const struct pci_device_id *id;
153 struct pci_dynid *dynid;
155 id = pci_match_id(drv->id_table, dev);
156 if (id)
157 return id;
159 /* static ids didn't match, lets look at the dynamic ones */
160 spin_lock(&drv->dynids.lock);
161 list_for_each_entry(dynid, &drv->dynids.list, node) {
162 if (pci_match_one_device(&dynid->id, dev)) {
163 spin_unlock(&drv->dynids.lock);
164 return &dynid->id;
165 }
166 }
167 spin_unlock(&drv->dynids.lock);
168 return NULL;
169 }
171 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
172 const struct pci_device_id *id)
173 {
174 int error;
175 #ifdef CONFIG_NUMA
176 /* Execute driver initialization on node where the
177 device's bus is attached to. This way the driver likely
178 allocates its local memory on the right node without
179 any need to change it. */
180 struct mempolicy *oldpol;
181 cpumask_t oldmask = current->cpus_allowed;
182 int node = pcibus_to_node(dev->bus);
183 if (node >= 0 && node_online(node))
184 set_cpus_allowed(current, node_to_cpumask(node));
185 /* And set default memory allocation policy */
186 oldpol = current->mempolicy;
187 current->mempolicy = &default_policy;
188 mpol_get(current->mempolicy);
189 #endif
190 error = drv->probe(dev, id);
191 #ifdef CONFIG_NUMA
192 set_cpus_allowed(current, oldmask);
193 mpol_free(current->mempolicy);
194 current->mempolicy = oldpol;
195 #endif
196 return error;
197 }
199 /**
200 * __pci_device_probe()
201 * @drv: driver to call to check if it wants the PCI device
202 * @pci_dev: PCI device being probed
203 *
204 * returns 0 on success, else error.
205 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
206 */
207 static int
208 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
209 {
210 const struct pci_device_id *id;
211 int error = 0;
213 if (!pci_dev->driver && drv->probe) {
214 error = -ENODEV;
216 id = pci_match_device(drv, pci_dev);
217 if (id)
218 error = pci_call_probe(drv, pci_dev, id);
219 if (error >= 0) {
220 pci_dev->driver = drv;
221 error = 0;
222 }
223 }
224 return error;
225 }
227 static int pci_device_probe(struct device * dev)
228 {
229 int error = 0;
230 struct pci_driver *drv;
231 struct pci_dev *pci_dev;
233 drv = to_pci_driver(dev->driver);
234 pci_dev = to_pci_dev(dev);
235 pci_dev_get(pci_dev);
236 error = __pci_device_probe(drv, pci_dev);
237 if (error)
238 pci_dev_put(pci_dev);
240 return error;
241 }
243 static int pci_device_remove(struct device * dev)
244 {
245 struct pci_dev * pci_dev = to_pci_dev(dev);
246 struct pci_driver * drv = pci_dev->driver;
248 if (drv) {
249 if (drv->remove)
250 drv->remove(pci_dev);
251 pci_dev->driver = NULL;
252 }
254 /*
255 * We would love to complain here if pci_dev->is_enabled is set, that
256 * the driver should have called pci_disable_device(), but the
257 * unfortunate fact is there are too many odd BIOS and bridge setups
258 * that don't like drivers doing that all of the time.
259 * Oh well, we can dream of sane hardware when we sleep, no matter how
260 * horrible the crap we have to deal with is when we are awake...
261 */
263 pci_dev_put(pci_dev);
264 return 0;
265 }
267 static int pci_device_suspend(struct device * dev, pm_message_t state)
268 {
269 struct pci_dev * pci_dev = to_pci_dev(dev);
270 struct pci_driver * drv = pci_dev->driver;
271 int i = 0;
273 if (drv && drv->suspend) {
274 i = drv->suspend(pci_dev, state);
275 suspend_report_result(drv->suspend, i);
276 } else {
277 pci_save_state(pci_dev);
278 }
279 return i;
280 }
283 /*
284 * Default resume method for devices that have no driver provided resume,
285 * or not even a driver at all.
286 */
287 static int pci_default_resume(struct pci_dev *pci_dev)
288 {
289 int retval = 0;
291 /* restore the PCI config space */
292 pci_restore_state(pci_dev);
293 /* if the device was enabled before suspend, reenable */
294 if (pci_dev->is_enabled)
295 retval = pci_enable_device(pci_dev);
296 /* if the device was busmaster before the suspend, make it busmaster again */
297 if (pci_dev->is_busmaster)
298 pci_set_master(pci_dev);
300 return retval;
301 }
303 static int pci_device_resume(struct device * dev)
304 {
305 int error;
306 struct pci_dev * pci_dev = to_pci_dev(dev);
307 struct pci_driver * drv = pci_dev->driver;
309 if (drv && drv->resume)
310 error = drv->resume(pci_dev);
311 else
312 error = pci_default_resume(pci_dev);
313 return error;
314 }
316 static void pci_device_shutdown(struct device *dev)
317 {
318 struct pci_dev *pci_dev = to_pci_dev(dev);
319 struct pci_driver *drv = pci_dev->driver;
321 if (drv && drv->shutdown)
322 drv->shutdown(pci_dev);
323 }
325 #define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
326 #define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
328 static ssize_t
329 pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
330 {
331 struct device_driver *driver = kobj_to_pci_driver(kobj);
332 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
333 ssize_t ret;
335 if (!get_driver(driver))
336 return -ENODEV;
338 ret = dattr->show ? dattr->show(driver, buf) : -EIO;
340 put_driver(driver);
341 return ret;
342 }
344 static ssize_t
345 pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
346 const char *buf, size_t count)
347 {
348 struct device_driver *driver = kobj_to_pci_driver(kobj);
349 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
350 ssize_t ret;
352 if (!get_driver(driver))
353 return -ENODEV;
355 ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
357 put_driver(driver);
358 return ret;
359 }
361 static struct sysfs_ops pci_driver_sysfs_ops = {
362 .show = pci_driver_attr_show,
363 .store = pci_driver_attr_store,
364 };
365 static struct kobj_type pci_driver_kobj_type = {
366 .sysfs_ops = &pci_driver_sysfs_ops,
367 };
369 /**
370 * __pci_register_driver - register a new pci driver
371 * @drv: the driver structure to register
372 * @owner: owner module of drv
373 *
374 * Adds the driver structure to the list of registered drivers.
375 * Returns a negative value on error, otherwise 0.
376 * If no error occurred, the driver remains registered even if
377 * no device was claimed during registration.
378 */
379 int __pci_register_driver(struct pci_driver *drv, struct module *owner)
380 {
381 int error;
383 /* initialize common driver fields */
384 drv->driver.name = drv->name;
385 drv->driver.bus = &pci_bus_type;
386 drv->driver.owner = owner;
387 drv->driver.kobj.ktype = &pci_driver_kobj_type;
389 spin_lock_init(&drv->dynids.lock);
390 INIT_LIST_HEAD(&drv->dynids.list);
392 /* register with core */
393 error = driver_register(&drv->driver);
395 if (!error)
396 error = pci_create_newid_file(drv);
398 return error;
399 }
401 /**
402 * pci_unregister_driver - unregister a pci driver
403 * @drv: the driver structure to unregister
404 *
405 * Deletes the driver structure from the list of registered PCI drivers,
406 * gives it a chance to clean up by calling its remove() function for
407 * each device it was responsible for, and marks those devices as
408 * driverless.
409 */
411 void
412 pci_unregister_driver(struct pci_driver *drv)
413 {
414 driver_unregister(&drv->driver);
415 pci_free_dynids(drv);
416 }
418 static struct pci_driver pci_compat_driver = {
419 .name = "compat"
420 };
422 /**
423 * pci_dev_driver - get the pci_driver of a device
424 * @dev: the device to query
425 *
426 * Returns the appropriate pci_driver structure or %NULL if there is no
427 * registered driver for the device.
428 */
429 struct pci_driver *
430 pci_dev_driver(const struct pci_dev *dev)
431 {
432 if (dev->driver)
433 return dev->driver;
434 else {
435 int i;
436 for(i=0; i<=PCI_ROM_RESOURCE; i++)
437 if (dev->resource[i].flags & IORESOURCE_BUSY)
438 return &pci_compat_driver;
439 }
440 return NULL;
441 }
443 /**
444 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
445 * @dev: the PCI device structure to match against
446 * @drv: the device driver to search for matching PCI device id structures
447 *
448 * Used by a driver to check whether a PCI device present in the
449 * system is in its list of supported devices. Returns the matching
450 * pci_device_id structure or %NULL if there is no match.
451 */
452 static int pci_bus_match(struct device *dev, struct device_driver *drv)
453 {
454 struct pci_dev *pci_dev = to_pci_dev(dev);
455 struct pci_driver *pci_drv = to_pci_driver(drv);
456 const struct pci_device_id *found_id;
458 found_id = pci_match_device(pci_drv, pci_dev);
459 if (found_id)
460 return 1;
462 return 0;
463 }
465 /**
466 * pci_dev_get - increments the reference count of the pci device structure
467 * @dev: the device being referenced
468 *
469 * Each live reference to a device should be refcounted.
470 *
471 * Drivers for PCI devices should normally record such references in
472 * their probe() methods, when they bind to a device, and release
473 * them by calling pci_dev_put(), in their disconnect() methods.
474 *
475 * A pointer to the device with the incremented reference counter is returned.
476 */
477 struct pci_dev *pci_dev_get(struct pci_dev *dev)
478 {
479 if (dev)
480 get_device(&dev->dev);
481 return dev;
482 }
484 /**
485 * pci_dev_put - release a use of the pci device structure
486 * @dev: device that's been disconnected
487 *
488 * Must be called when a user of a device is finished with it. When the last
489 * user of the device calls this function, the memory of the device is freed.
490 */
491 void pci_dev_put(struct pci_dev *dev)
492 {
493 if (dev)
494 put_device(&dev->dev);
495 }
497 #ifndef CONFIG_HOTPLUG
498 int pci_uevent(struct device *dev, char **envp, int num_envp,
499 char *buffer, int buffer_size)
500 {
501 return -ENODEV;
502 }
503 #endif
505 struct bus_type pci_bus_type = {
506 .name = "pci",
507 .match = pci_bus_match,
508 .uevent = pci_uevent,
509 .probe = pci_device_probe,
510 .remove = pci_device_remove,
511 .suspend = pci_device_suspend,
512 .shutdown = pci_device_shutdown,
513 .resume = pci_device_resume,
514 .dev_attrs = pci_dev_attrs,
515 };
517 static int __init pci_driver_init(void)
518 {
519 return bus_register(&pci_bus_type);
520 }
522 postcore_initcall(pci_driver_init);
524 EXPORT_SYMBOL(pci_match_id);
525 EXPORT_SYMBOL(pci_match_device);
526 EXPORT_SYMBOL(__pci_register_driver);
527 EXPORT_SYMBOL(pci_unregister_driver);
528 EXPORT_SYMBOL(pci_dev_driver);
529 EXPORT_SYMBOL(pci_bus_type);
530 EXPORT_SYMBOL(pci_dev_get);
531 EXPORT_SYMBOL(pci_dev_put);