SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/pci/pci-driver.c

   1 /*
   2  * drivers/pci/pci-driver.c
   3  *
   4  * (C) Copyright 2002-2004, 2007 Greg Kroah-Hartman <greg@kroah.com>
   5  * (C) Copyright 2007 Novell Inc.
   6  *
   7  * Released under the GPL v2 only.
   8  *
   9  */
  10
  11 #include <linux/pci.h>
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/device.h>
  15 #include <linux/mempolicy.h>
  16 #include <linux/string.h>
  17 #include <linux/slab.h>
  18 #include <linux/sched.h>
  19 #include <linux/cpu.h>
  20 #include "pci.h"
  21
  22 /*
  23  * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
  24  */
  25
  26 struct pci_dynid {
  27         struct list_head node;
  28         struct pci_device_id id;
  29 };
  30
  31 #ifdef CONFIG_HOTPLUG
  32
  33 /**
  34  * store_new_id - add a new PCI device ID to this driver and re-probe devices
  35  * @driver: target device driver
  36  * @buf: buffer for scanning device ID data
  37  * @count: input size
  38  *
  39  * Adds a new dynamic pci device ID to this driver,
  40  * and causes the driver to probe for all devices again.
  41  */
  42 static ssize_t
  43 store_new_id(struct device_driver *driver, const char *buf, size_t count)
  44 {
  45         struct pci_dynid *dynid;
  46         struct pci_driver *pdrv = to_pci_driver(driver);
  47         const struct pci_device_id *ids = pdrv->id_table;
  48         __u32 vendor, device, subvendor=PCI_ANY_ID,
  49                 subdevice=PCI_ANY_ID, class=0, class_mask=0;
  50         unsigned long driver_data=0;
  51         int fields=0;
  52         int retval=0;
  53
  54         fields = sscanf(buf, "%x %x %x %x %x %x %lx",
  55                         &vendor, &device, &subvendor, &subdevice,
  56                         &class, &class_mask, &driver_data);
  57         if (fields < 2)
  58                 return -EINVAL;
  59
  60         /* Only accept driver_data values that match an existing id_table
  61            entry */
  62         if (ids) {
  63                 retval = -EINVAL;
  64                 while (ids->vendor || ids->subvendor || ids->class_mask) {
  65                         if (driver_data == ids->driver_data) {
  66                                 retval = 0;
  67                                 break;
  68                         }
  69                         ids++;
  70                 }
  71                 if (retval)     /* No match */
  72                         return retval;
  73         }
  74
  75         dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
  76         if (!dynid)
  77                 return -ENOMEM;
  78
  79         dynid->id.vendor = vendor;
  80         dynid->id.device = device;
  81         dynid->id.subvendor = subvendor;
  82         dynid->id.subdevice = subdevice;
  83         dynid->id.class = class;
  84         dynid->id.class_mask = class_mask;
  85         dynid->id.driver_data = driver_data;
  86
  87         spin_lock(&pdrv->dynids.lock);
  88         list_add_tail(&dynid->node, &pdrv->dynids.list);
  89         spin_unlock(&pdrv->dynids.lock);
  90
  91         if (get_driver(&pdrv->driver)) {
  92                 retval = driver_attach(&pdrv->driver);
  93                 put_driver(&pdrv->driver);
  94         }
  95
  96         if (retval)
  97                 return retval;
  98         return count;
  99 }
 100 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
 101
 102 static void
 103 pci_free_dynids(struct pci_driver *drv)
 104 {
 105         struct pci_dynid *dynid, *n;
 106
 107         spin_lock(&drv->dynids.lock);
 108         list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
 109                 list_del(&dynid->node);
 110                 kfree(dynid);
 111         }
 112         spin_unlock(&drv->dynids.lock);
 113 }
 114
 115 static int
 116 pci_create_newid_file(struct pci_driver *drv)
 117 {
 118         int error = 0;
 119         if (drv->probe != NULL)
 120                 error = driver_create_file(&drv->driver, &driver_attr_new_id);
 121         return error;
 122 }
 123
 124 static void pci_remove_newid_file(struct pci_driver *drv)
 125 {
 126         driver_remove_file(&drv->driver, &driver_attr_new_id);
 127 }
 128 #else /* !CONFIG_HOTPLUG */
 129 static inline void pci_free_dynids(struct pci_driver *drv) {}
 130 static inline int pci_create_newid_file(struct pci_driver *drv)
 131 {
 132         return 0;
 133 }
 134 static inline void pci_remove_newid_file(struct pci_driver *drv) {}
 135 #endif
 136
 137 /**
 138  * pci_match_id - See if a pci device matches a given pci_id table
 139  * @ids: array of PCI device id structures to search in
 140  * @dev: the PCI device structure to match against.
 141  *
 142  * Used by a driver to check whether a PCI device present in the
 143  * system is in its list of supported devices.  Returns the matching
 144  * pci_device_id structure or %NULL if there is no match.
 145  *
 146  * Deprecated, don't use this as it will not catch any dynamic ids
 147  * that a driver might want to check for.
 148  */
 149 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
 150                                          struct pci_dev *dev)
 151 {
 152         if (ids) {
 153                 while (ids->vendor || ids->subvendor || ids->class_mask) {
 154                         if (pci_match_one_device(ids, dev))
 155                                 return ids;
 156                         ids++;
 157                 }
 158         }
 159         return NULL;
 160 }
 161
 162 /**
 163  * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
 164  * @drv: the PCI driver to match against
 165  * @dev: the PCI device structure to match against
 166  *
 167  * Used by a driver to check whether a PCI device present in the
 168  * system is in its list of supported devices.  Returns the matching
 169  * pci_device_id structure or %NULL if there is no match.
 170  */
 171 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
 172                                                     struct pci_dev *dev)
 173 {
 174         struct pci_dynid *dynid;
 175
 176         /* Look at the dynamic ids first, before the static ones */
 177         spin_lock(&drv->dynids.lock);
 178         list_for_each_entry(dynid, &drv->dynids.list, node) {
 179                 if (pci_match_one_device(&dynid->id, dev)) {
 180                         spin_unlock(&drv->dynids.lock);
 181                         return &dynid->id;
 182                 }
 183         }
 184         spin_unlock(&drv->dynids.lock);
 185
 186         return pci_match_id(drv->id_table, dev);
 187 }
 188
 189 struct drv_dev_and_id {
 190         struct pci_driver *drv;
 191         struct pci_dev *dev;
 192         const struct pci_device_id *id;
 193 };
 194
 195 static long local_pci_probe(void *_ddi)
 196 {
 197         struct drv_dev_and_id *ddi = _ddi;
 198
 199         return ddi->drv->probe(ddi->dev, ddi->id);
 200 }
 201
 202 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
 203                           const struct pci_device_id *id)
 204 {
 205         int error, node;
 206         struct drv_dev_and_id ddi = { drv, dev, id };
 207
 208         /* Execute driver initialization on node where the device's
 209            bus is attached to.  This way the driver likely allocates
 210            its local memory on the right node without any need to
 211            change it. */
 212         node = dev_to_node(&dev->dev);
 213         if (node >= 0) {
 214                 int cpu;
 215                 node_to_cpumask_ptr(nodecpumask, node);
 216
 217                 get_online_cpus();
 218                 cpu = cpumask_any_and(nodecpumask, cpu_online_mask);
 219                 if (cpu < nr_cpu_ids)
 220                         error = work_on_cpu(cpu, local_pci_probe, &ddi);
 221                 else
 222                         error = local_pci_probe(&ddi);
 223                 put_online_cpus();
 224         } else
 225                 error = local_pci_probe(&ddi);
 226         return error;
 227 }
 228
 229 /**
 230  * __pci_device_probe()
 231  * @drv: driver to call to check if it wants the PCI device
 232  * @pci_dev: PCI device being probed
 233  *
 234  * returns 0 on success, else error.
 235  * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
 236  */
 237 static int
 238 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
 239 {
 240         const struct pci_device_id *id;
 241         int error = 0;
 242
 243         if (!pci_dev->driver && drv->probe) {
 244                 error = -ENODEV;
 245
 246                 id = pci_match_device(drv, pci_dev);
 247                 if (id)
 248                         error = pci_call_probe(drv, pci_dev, id);
 249                 if (error >= 0) {
 250                         pci_dev->driver = drv;
 251                         error = 0;
 252                 }
 253         }
 254         return error;
 255 }
 256
 257 static int pci_device_probe(struct device * dev)
 258 {
 259         int error = 0;
 260         struct pci_driver *drv;
 261         struct pci_dev *pci_dev;
 262
 263         drv = to_pci_driver(dev->driver);
 264         pci_dev = to_pci_dev(dev);
 265         pci_dev_get(pci_dev);
 266         error = __pci_device_probe(drv, pci_dev);
 267         if (error)
 268                 pci_dev_put(pci_dev);
 269
 270         return error;
 271 }
 272
 273 static int pci_device_remove(struct device * dev)
 274 {
 275         struct pci_dev * pci_dev = to_pci_dev(dev);
 276         struct pci_driver * drv = pci_dev->driver;
 277
 278         if (drv) {
 279                 if (drv->remove)
 280                         drv->remove(pci_dev);
 281                 pci_dev->driver = NULL;
 282         }
 283
 284         /*
 285          * If the device is still on, set the power state as "unknown",
 286          * since it might change by the next time we load the driver.
 287          */
 288         if (pci_dev->current_state == PCI_D0)
 289                 pci_dev->current_state = PCI_UNKNOWN;
 290
 291         /*
 292          * We would love to complain here if pci_dev->is_enabled is set, that
 293          * the driver should have called pci_disable_device(), but the
 294          * unfortunate fact is there are too many odd BIOS and bridge setups
 295          * that don't like drivers doing that all of the time.
 296          * Oh well, we can dream of sane hardware when we sleep, no matter how
 297          * horrible the crap we have to deal with is when we are awake...
 298          */
 299
 300         pci_dev_put(pci_dev);
 301         return 0;
 302 }
 303
 304 static void pci_device_shutdown(struct device *dev)
 305 {
 306         struct pci_dev *pci_dev = to_pci_dev(dev);
 307         struct pci_driver *drv = pci_dev->driver;
 308
 309         if (drv && drv->shutdown)
 310                 drv->shutdown(pci_dev);
 311         pci_msi_shutdown(pci_dev);
 312         pci_msix_shutdown(pci_dev);
 313 }
 314
 315 #ifdef CONFIG_PM_SLEEP
 316
 317 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
 318 {
 319         struct pci_driver *drv = pci_dev->driver;
 320
 321         return drv && (drv->suspend || drv->suspend_late || drv->resume
 322                 || drv->resume_early);
 323 }
 324
 325 /*
 326  * Default "suspend" method for devices that have no driver provided suspend,
 327  * or not even a driver at all (first part).
 328  */
 329 static void pci_default_pm_suspend_early(struct pci_dev *pci_dev)
 330 {
 331         /* If device is enabled at this point, disable it */
 332         pci_disable_enabled_device(pci_dev);
 333 }
 334
 335 /*
 336  * Default "suspend" method for devices that have no driver provided suspend,
 337  * or not even a driver at all (second part).
 338  */
 339 static void pci_default_pm_suspend_late(struct pci_dev *pci_dev)
 340 {
 341         pci_save_state(pci_dev);
 342         /*
 343          * mark its power state as "unknown", since we don't know if
 344          * e.g. the BIOS will change its device state when we suspend.
 345          */
 346         if (pci_dev->current_state == PCI_D0)
 347                 pci_dev->current_state = PCI_UNKNOWN;
 348 }
 349
 350 /*
 351  * Default "resume" method for devices that have no driver provided resume,
 352  * or not even a driver at all (first part).
 353  */
 354 static void pci_default_pm_resume_early(struct pci_dev *pci_dev)
 355 {
 356         /* restore the PCI config space */
 357         pci_restore_state(pci_dev);
 358 }
 359
 360 /*
 361  * Default "resume" method for devices that have no driver provided resume,
 362  * or not even a driver at all (second part).
 363  */
 364 static int pci_default_pm_resume_late(struct pci_dev *pci_dev)
 365 {
 366         int retval;
 367
 368         /* if the device was enabled before suspend, reenable */
 369         retval = pci_reenable_device(pci_dev);
 370         /*
 371          * if the device was busmaster before the suspend, make it busmaster
 372          * again
 373          */
 374         if (pci_dev->is_busmaster)
 375                 pci_set_master(pci_dev);
 376
 377         return retval;
 378 }
 379
 380 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
 381 {
 382         struct pci_dev * pci_dev = to_pci_dev(dev);
 383         struct pci_driver * drv = pci_dev->driver;
 384         int i = 0;
 385
 386         if (drv && drv->suspend) {
 387                 i = drv->suspend(pci_dev, state);
 388                 suspend_report_result(drv->suspend, i);
 389         } else {
 390                 /*
 391                  * For compatibility with existing code with legacy PM support
 392                  * don't call pci_default_pm_suspend_early() here.
 393                  */
 394                 pci_default_pm_suspend_late(pci_dev);
 395         }
 396         return i;
 397 }
 398
 399 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
 400 {
 401         struct pci_dev * pci_dev = to_pci_dev(dev);
 402         struct pci_driver * drv = pci_dev->driver;
 403         int i = 0;
 404
 405         if (drv && drv->suspend_late) {
 406                 i = drv->suspend_late(pci_dev, state);
 407                 suspend_report_result(drv->suspend_late, i);
 408         }
 409         return i;
 410 }
 411
 412 static int pci_legacy_resume(struct device *dev)
 413 {
 414         int error;
 415         struct pci_dev * pci_dev = to_pci_dev(dev);
 416         struct pci_driver * drv = pci_dev->driver;
 417
 418         if (drv && drv->resume) {
 419                 error = drv->resume(pci_dev);
 420         } else {
 421                 pci_default_pm_resume_early(pci_dev);
 422                 error = pci_default_pm_resume_late(pci_dev);
 423         }
 424         return error;
 425 }
 426
 427 static int pci_legacy_resume_early(struct device *dev)
 428 {
 429         int error = 0;
 430         struct pci_dev * pci_dev = to_pci_dev(dev);
 431         struct pci_driver * drv = pci_dev->driver;
 432
 433         if (drv && drv->resume_early)
 434                 error = drv->resume_early(pci_dev);
 435         return error;
 436 }
 437
 438 static int pci_pm_prepare(struct device *dev)
 439 {
 440         struct device_driver *drv = dev->driver;
 441         int error = 0;
 442
 443         if (drv && drv->pm && drv->pm->prepare)
 444                 error = drv->pm->prepare(dev);
 445
 446         return error;
 447 }
 448
 449 static void pci_pm_complete(struct device *dev)
 450 {
 451         struct device_driver *drv = dev->driver;
 452
 453         if (drv && drv->pm && drv->pm->complete)
 454                 drv->pm->complete(dev);
 455 }
 456
 457 #ifdef CONFIG_SUSPEND
 458
 459 static int pci_pm_suspend(struct device *dev)
 460 {
 461         struct pci_dev *pci_dev = to_pci_dev(dev);
 462         struct device_driver *drv = dev->driver;
 463         int error = 0;
 464
 465         if (drv && drv->pm) {
 466                 if (drv->pm->suspend) {
 467                         error = drv->pm->suspend(dev);
 468                         suspend_report_result(drv->pm->suspend, error);
 469                 }
 470         } else if (pci_has_legacy_pm_support(pci_dev)) {
 471                 error = pci_legacy_suspend(dev, PMSG_SUSPEND);
 472         } else {
 473                 pci_default_pm_suspend_early(pci_dev);
 474         }
 475
 476         pci_fixup_device(pci_fixup_suspend, pci_dev);
 477
 478         return error;
 479 }
 480
 481 static int pci_pm_suspend_noirq(struct device *dev)
 482 {
 483         struct pci_dev *pci_dev = to_pci_dev(dev);
 484         struct device_driver *drv = dev->driver;
 485         int error = 0;
 486
 487         if (drv && drv->pm) {
 488                 if (drv->pm->suspend_noirq) {
 489                         error = drv->pm->suspend_noirq(dev);
 490                         suspend_report_result(drv->pm->suspend_noirq, error);
 491                 }
 492         } else if (pci_has_legacy_pm_support(pci_dev)) {
 493                 error = pci_legacy_suspend_late(dev, PMSG_SUSPEND);
 494         } else {
 495                 pci_default_pm_suspend_late(pci_dev);
 496         }
 497
 498         return error;
 499 }
 500
 501 static int pci_pm_resume(struct device *dev)
 502 {
 503         struct pci_dev *pci_dev = to_pci_dev(dev);
 504         struct device_driver *drv = dev->driver;
 505         int error = 0;
 506
 507         pci_fixup_device(pci_fixup_resume, pci_dev);
 508
 509         if (drv && drv->pm) {
 510                 if (drv->pm->resume)
 511                         error = drv->pm->resume(dev);
 512         } else if (pci_has_legacy_pm_support(pci_dev)) {
 513                 error = pci_legacy_resume(dev);
 514         } else {
 515                 error = pci_default_pm_resume_late(pci_dev);
 516         }
 517
 518         return error;
 519 }
 520
 521 static int pci_pm_resume_noirq(struct device *dev)
 522 {
 523         struct pci_dev *pci_dev = to_pci_dev(dev);
 524         struct device_driver *drv = dev->driver;
 525         int error = 0;
 526
 527         pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
 528
 529         if (drv && drv->pm) {
 530                 if (drv->pm->resume_noirq)
 531                         error = drv->pm->resume_noirq(dev);
 532         } else if (pci_has_legacy_pm_support(pci_dev)) {
 533                 error = pci_legacy_resume_early(dev);
 534         } else {
 535                 pci_default_pm_resume_early(pci_dev);
 536         }
 537
 538         return error;
 539 }
 540
 541 #else /* !CONFIG_SUSPEND */
 542
 543 #define pci_pm_suspend          NULL
 544 #define pci_pm_suspend_noirq    NULL
 545 #define pci_pm_resume           NULL
 546 #define pci_pm_resume_noirq     NULL
 547
 548 #endif /* !CONFIG_SUSPEND */
 549
 550 #ifdef CONFIG_HIBERNATION
 551
 552 static int pci_pm_freeze(struct device *dev)
 553 {
 554         struct pci_dev *pci_dev = to_pci_dev(dev);
 555         struct device_driver *drv = dev->driver;
 556         int error = 0;
 557
 558         if (drv && drv->pm) {
 559                 if (drv->pm->freeze) {
 560                         error = drv->pm->freeze(dev);
 561                         suspend_report_result(drv->pm->freeze, error);
 562                 }
 563         } else if (pci_has_legacy_pm_support(pci_dev)) {
 564                 error = pci_legacy_suspend(dev, PMSG_FREEZE);
 565                 pci_fixup_device(pci_fixup_suspend, pci_dev);
 566         } else {
 567                 pci_default_pm_suspend_early(pci_dev);
 568         }
 569
 570         return error;
 571 }
 572
 573 static int pci_pm_freeze_noirq(struct device *dev)
 574 {
 575         struct pci_dev *pci_dev = to_pci_dev(dev);
 576         struct device_driver *drv = dev->driver;
 577         int error = 0;
 578
 579         if (drv && drv->pm) {
 580                 if (drv->pm->freeze_noirq) {
 581                         error = drv->pm->freeze_noirq(dev);
 582                         suspend_report_result(drv->pm->freeze_noirq, error);
 583                 }
 584         } else if (pci_has_legacy_pm_support(pci_dev)) {
 585                 error = pci_legacy_suspend_late(dev, PMSG_FREEZE);
 586         } else {
 587                 pci_default_pm_suspend_late(pci_dev);
 588         }
 589
 590         return error;
 591 }
 592
 593 static int pci_pm_thaw(struct device *dev)
 594 {
 595         struct pci_dev *pci_dev = to_pci_dev(dev);
 596         struct device_driver *drv = dev->driver;
 597         int error = 0;
 598
 599         if (drv && drv->pm) {
 600                 if (drv->pm->thaw)
 601                         error =  drv->pm->thaw(dev);
 602         } else if (pci_has_legacy_pm_support(pci_dev)) {
 603                 pci_fixup_device(pci_fixup_resume, pci_dev);
 604                 error = pci_legacy_resume(dev);
 605         } else {
 606                 pci_default_pm_resume_late(pci_dev);
 607         }
 608
 609         return error;
 610 }
 611
 612 static int pci_pm_thaw_noirq(struct device *dev)
 613 {
 614         struct pci_dev *pci_dev = to_pci_dev(dev);
 615         struct device_driver *drv = dev->driver;
 616         int error = 0;
 617
 618         if (drv && drv->pm) {
 619                 if (drv->pm->thaw_noirq)
 620                         error = drv->pm->thaw_noirq(dev);
 621         } else if (pci_has_legacy_pm_support(pci_dev)) {
 622                 pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
 623                 error = pci_legacy_resume_early(dev);
 624         } else {
 625                 pci_default_pm_resume_early(pci_dev);
 626         }
 627
 628         return error;
 629 }
 630
 631 static int pci_pm_poweroff(struct device *dev)
 632 {
 633         struct pci_dev *pci_dev = to_pci_dev(dev);
 634         struct device_driver *drv = dev->driver;
 635         int error = 0;
 636
 637         if (drv && drv->pm) {
 638                 if (drv->pm->poweroff) {
 639                         error = drv->pm->poweroff(dev);
 640                         suspend_report_result(drv->pm->poweroff, error);
 641                 }
 642         } else if (pci_has_legacy_pm_support(pci_dev)) {
 643                 error = pci_legacy_suspend(dev, PMSG_HIBERNATE);
 644         } else {
 645                 pci_default_pm_suspend_early(pci_dev);
 646         }
 647
 648         pci_fixup_device(pci_fixup_suspend, pci_dev);
 649
 650         return error;
 651 }
 652
 653 static int pci_pm_poweroff_noirq(struct device *dev)
 654 {
 655         struct device_driver *drv = dev->driver;
 656         int error = 0;
 657
 658         if (drv && drv->pm) {
 659                 if (drv->pm->poweroff_noirq) {
 660                         error = drv->pm->poweroff_noirq(dev);
 661                         suspend_report_result(drv->pm->poweroff_noirq, error);
 662                 }
 663         } else if (pci_has_legacy_pm_support(to_pci_dev(dev))) {
 664                 error = pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
 665         }
 666
 667         return error;
 668 }
 669
 670 static int pci_pm_restore(struct device *dev)
 671 {
 672         struct pci_dev *pci_dev = to_pci_dev(dev);
 673         struct device_driver *drv = dev->driver;
 674         int error = 0;
 675
 676         pci_fixup_device(pci_fixup_resume, pci_dev);
 677
 678         if (drv && drv->pm) {
 679                 if (drv->pm->restore)
 680                         error = drv->pm->restore(dev);
 681         } else if (pci_has_legacy_pm_support(pci_dev)) {
 682                 error = pci_legacy_resume(dev);
 683         } else {
 684                 error = pci_default_pm_resume_late(pci_dev);
 685         }
 686
 687         return error;
 688 }
 689
 690 static int pci_pm_restore_noirq(struct device *dev)
 691 {
 692         struct pci_dev *pci_dev = to_pci_dev(dev);
 693         struct device_driver *drv = dev->driver;
 694         int error = 0;
 695
 696         pci_fixup_device(pci_fixup_resume_early, pci_dev);
 697
 698         if (drv && drv->pm) {
 699                 if (drv->pm->restore_noirq)
 700                         error = drv->pm->restore_noirq(dev);
 701         } else if (pci_has_legacy_pm_support(pci_dev)) {
 702                 error = pci_legacy_resume_early(dev);
 703         } else {
 704                 pci_default_pm_resume_early(pci_dev);
 705         }
 706
 707         return error;
 708 }
 709
 710 #else /* !CONFIG_HIBERNATION */
 711
 712 #define pci_pm_freeze           NULL
 713 #define pci_pm_freeze_noirq     NULL
 714 #define pci_pm_thaw             NULL
 715 #define pci_pm_thaw_noirq       NULL
 716 #define pci_pm_poweroff         NULL
 717 #define pci_pm_poweroff_noirq   NULL
 718 #define pci_pm_restore          NULL
 719 #define pci_pm_restore_noirq    NULL
 720
 721 #endif /* !CONFIG_HIBERNATION */
 722
 723 struct dev_pm_ops pci_dev_pm_ops = {
 724         .prepare = pci_pm_prepare,
 725         .complete = pci_pm_complete,
 726         .suspend = pci_pm_suspend,
 727         .resume = pci_pm_resume,
 728         .freeze = pci_pm_freeze,
 729         .thaw = pci_pm_thaw,
 730         .poweroff = pci_pm_poweroff,
 731         .restore = pci_pm_restore,
 732         .suspend_noirq = pci_pm_suspend_noirq,
 733         .resume_noirq = pci_pm_resume_noirq,
 734         .freeze_noirq = pci_pm_freeze_noirq,
 735         .thaw_noirq = pci_pm_thaw_noirq,
 736         .poweroff_noirq = pci_pm_poweroff_noirq,
 737         .restore_noirq = pci_pm_restore_noirq,
 738 };
 739
 740 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
 741
 742 #else /* !CONFIG_PM_SLEEP */
 743
 744 #define PCI_PM_OPS_PTR  NULL
 745
 746 #endif /* !CONFIG_PM_SLEEP */
 747
 748 /**
 749  * __pci_register_driver - register a new pci driver
 750  * @drv: the driver structure to register
 751  * @owner: owner module of drv
 752  * @mod_name: module name string
 753  *
 754  * Adds the driver structure to the list of registered drivers.
 755  * Returns a negative value on error, otherwise 0.
 756  * If no error occurred, the driver remains registered even if
 757  * no device was claimed during registration.
 758  */
 759 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
 760                           const char *mod_name)
 761 {
 762         int error;
 763
 764         /* initialize common driver fields */
 765         drv->driver.name = drv->name;
 766         drv->driver.bus = &pci_bus_type;
 767         drv->driver.owner = owner;
 768         drv->driver.mod_name = mod_name;
 769
 770         spin_lock_init(&drv->dynids.lock);
 771         INIT_LIST_HEAD(&drv->dynids.list);
 772
 773         /* register with core */
 774         error = driver_register(&drv->driver);
 775         if (error)
 776                 return error;
 777
 778         error = pci_create_newid_file(drv);
 779         if (error)
 780                 driver_unregister(&drv->driver);
 781
 782         return error;
 783 }
 784
 785 /**
 786  * pci_unregister_driver - unregister a pci driver
 787  * @drv: the driver structure to unregister
 788  *
 789  * Deletes the driver structure from the list of registered PCI drivers,
 790  * gives it a chance to clean up by calling its remove() function for
 791  * each device it was responsible for, and marks those devices as
 792  * driverless.
 793  */
 794
 795 void
 796 pci_unregister_driver(struct pci_driver *drv)
 797 {
 798         pci_remove_newid_file(drv);
 799         driver_unregister(&drv->driver);
 800         pci_free_dynids(drv);
 801 }
 802
 803 static struct pci_driver pci_compat_driver = {
 804         .name = "compat"
 805 };
 806
 807 /**
 808  * pci_dev_driver - get the pci_driver of a device
 809  * @dev: the device to query
 810  *
 811  * Returns the appropriate pci_driver structure or %NULL if there is no
 812  * registered driver for the device.
 813  */
 814 struct pci_driver *
 815 pci_dev_driver(const struct pci_dev *dev)
 816 {
 817         if (dev->driver)
 818                 return dev->driver;
 819         else {
 820                 int i;
 821                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
 822                         if (dev->resource[i].flags & IORESOURCE_BUSY)
 823                                 return &pci_compat_driver;
 824         }
 825         return NULL;
 826 }
 827
 828 /**
 829  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
 830  * @dev: the PCI device structure to match against
 831  * @drv: the device driver to search for matching PCI device id structures
 832  *
 833  * Used by a driver to check whether a PCI device present in the
 834  * system is in its list of supported devices. Returns the matching
 835  * pci_device_id structure or %NULL if there is no match.
 836  */
 837 static int pci_bus_match(struct device *dev, struct device_driver *drv)
 838 {
 839         struct pci_dev *pci_dev = to_pci_dev(dev);
 840         struct pci_driver *pci_drv = to_pci_driver(drv);
 841         const struct pci_device_id *found_id;
 842
 843         found_id = pci_match_device(pci_drv, pci_dev);
 844         if (found_id)
 845                 return 1;
 846
 847         return 0;
 848 }
 849
 850 /**
 851  * pci_dev_get - increments the reference count of the pci device structure
 852  * @dev: the device being referenced
 853  *
 854  * Each live reference to a device should be refcounted.
 855  *
 856  * Drivers for PCI devices should normally record such references in
 857  * their probe() methods, when they bind to a device, and release
 858  * them by calling pci_dev_put(), in their disconnect() methods.
 859  *
 860  * A pointer to the device with the incremented reference counter is returned.
 861  */
 862 struct pci_dev *pci_dev_get(struct pci_dev *dev)
 863 {
 864         if (dev)
 865                 get_device(&dev->dev);
 866         return dev;
 867 }
 868
 869 /**
 870  * pci_dev_put - release a use of the pci device structure
 871  * @dev: device that's been disconnected
 872  *
 873  * Must be called when a user of a device is finished with it.  When the last
 874  * user of the device calls this function, the memory of the device is freed.
 875  */
 876 void pci_dev_put(struct pci_dev *dev)
 877 {
 878         if (dev)
 879                 put_device(&dev->dev);
 880 }
 881
 882 #ifndef CONFIG_HOTPLUG
 883 int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
 884 {
 885         return -ENODEV;
 886 }
 887 #endif
 888
 889 struct bus_type pci_bus_type = {
 890         .name           = "pci",
 891         .match          = pci_bus_match,
 892         .uevent         = pci_uevent,
 893         .probe          = pci_device_probe,
 894         .remove         = pci_device_remove,
 895         .shutdown       = pci_device_shutdown,
 896         .dev_attrs      = pci_dev_attrs,
 897         .pm             = PCI_PM_OPS_PTR,
 898 };
 899
 900 static int __init pci_driver_init(void)
 901 {
 902         return bus_register(&pci_bus_type);
 903 }
 904
 905 postcore_initcall(pci_driver_init);
 906
 907 EXPORT_SYMBOL(pci_match_id);
 908 EXPORT_SYMBOL(__pci_register_driver);
 909 EXPORT_SYMBOL(pci_unregister_driver);
 910 EXPORT_SYMBOL(pci_dev_driver);
 911 EXPORT_SYMBOL(pci_bus_type);
 912 EXPORT_SYMBOL(pci_dev_get);
 913 EXPORT_SYMBOL(pci_dev_put);