drivers/pci/pci-driver.c

   1 /*
   2  * drivers/pci/pci-driver.c
   3  *
   4  */
   5
   6 #include <linux/pci.h>
   7 #include <linux/module.h>
   8 #include <linux/init.h>
   9 #include <linux/device.h>
  10 #include <linux/pci-dynids.h>
  11 #include "pci.h"
  12
  13 /*
  14  *  Registration of PCI drivers and handling of hot-pluggable devices.
  15  */
  16
  17 /*
  18  * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
  19  */
  20
  21 #ifdef CONFIG_HOTPLUG
  22 /**
  23  * pci_device_probe_dynamic()
  24  *
  25  * Walk the dynamic ID list looking for a match.
  26  * returns 0 and sets pci_dev->driver when drv claims pci_dev, else error.
  27  */
  28 static int
  29 pci_device_probe_dynamic(struct pci_driver *drv, struct pci_dev *pci_dev)
  30 {
  31         int error = -ENODEV;
  32         struct list_head *pos;
  33         struct dynid *dynid;
  34
  35         spin_lock(&drv->dynids.lock);
  36         list_for_each(pos, &drv->dynids.list) {
  37                 dynid = list_entry(pos, struct dynid, node);
  38                 if (pci_match_one_device(&dynid->id, pci_dev)) {
  39                         spin_unlock(&drv->dynids.lock);
  40                         error = drv->probe(pci_dev, &dynid->id);
  41                         if (error >= 0) {
  42                                 pci_dev->driver = drv;
  43                                 return 0;
  44                         }
  45                         return error;
  46                 }
  47         }
  48         spin_unlock(&drv->dynids.lock);
  49         return error;
  50 }
  51
  52 static inline void
  53 dynid_init(struct dynid *dynid)
  54 {
  55         memset(dynid, 0, sizeof(*dynid));
  56         INIT_LIST_HEAD(&dynid->node);
  57 }
  58
  59 /**
  60  * store_new_id
  61  *
  62  * Adds a new dynamic pci device ID to this driver,
  63  * and causes the driver to probe for all devices again.
  64  */
  65 static inline ssize_t
  66 store_new_id(struct device_driver *driver, const char *buf, size_t count)
  67 {
  68         struct dynid *dynid;
  69         struct bus_type * bus;
  70         struct pci_driver *pdrv = to_pci_driver(driver);
  71         __u32 vendor=PCI_ANY_ID, device=PCI_ANY_ID, subvendor=PCI_ANY_ID,
  72                 subdevice=PCI_ANY_ID, class=0, class_mask=0;
  73         unsigned long driver_data=0;
  74         int fields=0;
  75
  76         fields = sscanf(buf, "%x %x %x %x %x %x %lux",
  77                         &vendor, &device, &subvendor, &subdevice,
  78                         &class, &class_mask, &driver_data);
  79         if (fields < 0)
  80                 return -EINVAL;
  81
  82         dynid = kmalloc(sizeof(*dynid), GFP_KERNEL);
  83         if (!dynid)
  84                 return -ENOMEM;
  85         dynid_init(dynid);
  86
  87         dynid->id.vendor = vendor;
  88         dynid->id.device = device;
  89         dynid->id.subvendor = subvendor;
  90         dynid->id.subdevice = subdevice;
  91         dynid->id.class = class;
  92         dynid->id.class_mask = class_mask;
  93         dynid->id.driver_data = pdrv->dynids.use_driver_data ?
  94                 driver_data : 0UL;
  95
  96         spin_lock(&pdrv->dynids.lock);
  97         list_add_tail(&pdrv->dynids.list, &dynid->node);
  98         spin_unlock(&pdrv->dynids.lock);
  99
 100         bus = get_bus(pdrv->driver.bus);
 101         if (bus) {
 102                 if (get_driver(&pdrv->driver)) {
 103                         down_write(&bus->subsys.rwsem);
 104                         driver_attach(&pdrv->driver);
 105                         up_write(&bus->subsys.rwsem);
 106                         put_driver(&pdrv->driver);
 107                 }
 108                 put_bus(bus);
 109         }
 110
 111         return count;
 112 }
 113
 114 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
 115 static inline void
 116 pci_init_dynids(struct pci_dynids *dynids)
 117 {
 118         memset(dynids, 0, sizeof(*dynids));
 119         spin_lock_init(&dynids->lock);
 120         INIT_LIST_HEAD(&dynids->list);
 121 }
 122
 123 static void
 124 pci_free_dynids(struct pci_driver *drv)
 125 {
 126         struct list_head *pos, *n;
 127         struct dynid *dynid;
 128
 129         spin_lock(&drv->dynids.lock);
 130         list_for_each_safe(pos, n, &drv->dynids.list) {
 131                 dynid = list_entry(pos, struct dynid, node);
 132                 list_del(&dynid->node);
 133                 kfree(dynid);
 134         }
 135         spin_unlock(&drv->dynids.lock);
 136 }
 137
 138 static int
 139 pci_create_newid_file(struct pci_driver *drv)
 140 {
 141         int error = 0;
 142         if (drv->probe != NULL)
 143                 error = sysfs_create_file(&drv->driver.kobj,
 144                                           &driver_attr_new_id.attr);
 145         return error;
 146 }
 147
 148 static int
 149 pci_bus_match_dynids(const struct pci_dev *pci_dev, struct pci_driver *pci_drv)
 150 {
 151         struct list_head *pos;
 152         struct dynid *dynid;
 153
 154         spin_lock(&pci_drv->dynids.lock);
 155         list_for_each(pos, &pci_drv->dynids.list) {
 156                 dynid = list_entry(pos, struct dynid, node);
 157                 if (pci_match_one_device(&dynid->id, pci_dev)) {
 158                         spin_unlock(&pci_drv->dynids.lock);
 159                         return 1;
 160                 }
 161         }
 162         spin_unlock(&pci_drv->dynids.lock);
 163         return 0;
 164 }
 165
 166 #else /* !CONFIG_HOTPLUG */
 167 static inline int pci_device_probe_dynamic(struct pci_driver *drv, struct pci_dev *pci_dev)
 168 {
 169         return -ENODEV;
 170 }
 171 static inline void dynid_init(struct dynid *dynid) {}
 172 static inline void pci_init_dynids(struct pci_dynids *dynids) {}
 173 static inline void pci_free_dynids(struct pci_driver *drv) {}
 174 static inline int pci_create_newid_file(struct pci_driver *drv)
 175 {
 176         return 0;
 177 }
 178 static inline int pci_bus_match_dynids(const struct pci_dev *pci_dev, struct pci_driver *pci_drv)
 179 {
 180         return 0;
 181 }
 182 #endif
 183
 184 /**
 185  * pci_match_device - Tell if a PCI device structure has a matching
 186  *                    PCI device id structure
 187  * @ids: array of PCI device id structures to search in
 188  * @dev: the PCI device structure to match against
 189  *
 190  * Used by a driver to check whether a PCI device present in the
 191  * system is in its list of supported devices.Returns the matching
 192  * pci_device_id structure or %NULL if there is no match.
 193  */
 194 const struct pci_device_id *
 195 pci_match_device(const struct pci_device_id *ids, const struct pci_dev *dev)
 196 {
 197         while (ids->vendor || ids->subvendor || ids->class_mask) {
 198                 if (pci_match_one_device(ids, dev))
 199                         return ids;
 200                 ids++;
 201         }
 202         return NULL;
 203 }
 204
 205 /**
 206  * pci_device_probe_static()
 207  *
 208  * returns 0 and sets pci_dev->driver when drv claims pci_dev, else error.
 209  */
 210 static int
 211 pci_device_probe_static(struct pci_driver *drv, struct pci_dev *pci_dev)
 212 {
 213         int error = -ENODEV;
 214         const struct pci_device_id *id;
 215
 216         if (!drv->id_table)
 217                 return error;
 218         id = pci_match_device(drv->id_table, pci_dev);
 219         if (id)
 220                 error = drv->probe(pci_dev, id);
 221         if (error >= 0) {
 222                 pci_dev->driver = drv;
 223                 error = 0;
 224         }
 225         return error;
 226 }
 227
 228 /**
 229  * __pci_device_probe()
 230  *
 231  * returns 0  on success, else error.
 232  * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
 233  */
 234 static int
 235 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
 236 {
 237         int error = 0;
 238
 239         if (!pci_dev->driver && drv->probe) {
 240                 error = pci_device_probe_static(drv, pci_dev);
 241                 if (error == -ENODEV)
 242                         error = pci_device_probe_dynamic(drv, pci_dev);
 243         }
 244         return error;
 245 }
 246
 247 static int pci_device_probe(struct device * dev)
 248 {
 249         int error = 0;
 250         struct pci_driver *drv;
 251         struct pci_dev *pci_dev;
 252
 253         drv = to_pci_driver(dev->driver);
 254         pci_dev = to_pci_dev(dev);
 255         pci_dev_get(pci_dev);
 256         error = __pci_device_probe(drv, pci_dev);
 257         if (error)
 258                 pci_dev_put(pci_dev);
 259
 260         return error;
 261 }
 262
 263 static int pci_device_remove(struct device * dev)
 264 {
 265         struct pci_dev * pci_dev = to_pci_dev(dev);
 266         struct pci_driver * drv = pci_dev->driver;
 267
 268         if (drv) {
 269                 if (drv->remove)
 270                         drv->remove(pci_dev);
 271                 pci_dev->driver = NULL;
 272         }
 273
 274         /*
 275          * We would love to complain here if pci_dev->is_enabled is set, that
 276          * the driver should have called pci_disable_device(), but the
 277          * unfortunate fact is there are too many odd BIOS and bridge setups
 278          * that don't like drivers doing that all of the time.
 279          * Oh well, we can dream of sane hardware when we sleep, no matter how
 280          * horrible the crap we have to deal with is when we are awake...
 281          */
 282
 283         pci_dev_put(pci_dev);
 284         return 0;
 285 }
 286
 287 static int pci_device_suspend(struct device * dev, u32 state)
 288 {
 289         struct pci_dev * pci_dev = to_pci_dev(dev);
 290         struct pci_driver * drv = pci_dev->driver;
 291         u32 dev_state;
 292         int i = 0;
 293
 294         /* Translate PM_SUSPEND_xx states to PCI device states */
 295         static u32 state_conversion[] = {
 296                 [PM_SUSPEND_ON] = 0,
 297                 [PM_SUSPEND_STANDBY] = 1,
 298                 [PM_SUSPEND_MEM] = 3,
 299                 [PM_SUSPEND_DISK] = 3,
 300         };
 301
 302         if (state >= sizeof(state_conversion) / sizeof(state_conversion[1]))
 303                 return -EINVAL;
 304
 305         dev_state = state_conversion[state];
 306         if (drv && drv->suspend)
 307                 i = drv->suspend(pci_dev, dev_state);
 308         else
 309                 pci_save_state(pci_dev);
 310         return i;
 311 }
 312
 313
 314 /*
 315  * Default resume method for devices that have no driver provided resume,
 316  * or not even a driver at all.
 317  */
 318 static void pci_default_resume(struct pci_dev *pci_dev)
 319 {
 320         /* restore the PCI config space */
 321         pci_restore_state(pci_dev);
 322         /* if the device was enabled before suspend, reenable */
 323         if (pci_dev->is_enabled)
 324                 pci_enable_device(pci_dev);
 325         /* if the device was busmaster before the suspend, make it busmaster again */
 326         if (pci_dev->is_busmaster)
 327                 pci_set_master(pci_dev);
 328 }
 329
 330 static int pci_device_resume(struct device * dev)
 331 {
 332         struct pci_dev * pci_dev = to_pci_dev(dev);
 333         struct pci_driver * drv = pci_dev->driver;
 334
 335         if (drv && drv->resume)
 336                 drv->resume(pci_dev);
 337         else
 338                 pci_default_resume(pci_dev);
 339         return 0;
 340 }
 341
 342
 343 #define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
 344 #define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
 345
 346 static ssize_t
 347 pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
 348 {
 349         struct device_driver *driver = kobj_to_pci_driver(kobj);
 350         struct driver_attribute *dattr = attr_to_driver_attribute(attr);
 351         ssize_t ret = 0;
 352
 353         if (get_driver(driver)) {
 354                 if (dattr->show)
 355                         ret = dattr->show(driver, buf);
 356                 put_driver(driver);
 357         }
 358         return ret;
 359 }
 360
 361 static ssize_t
 362 pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
 363                       const char *buf, size_t count)
 364 {
 365         struct device_driver *driver = kobj_to_pci_driver(kobj);
 366         struct driver_attribute *dattr = attr_to_driver_attribute(attr);
 367         ssize_t ret = 0;
 368
 369         if (get_driver(driver)) {
 370                 if (dattr->store)
 371                         ret = dattr->store(driver, buf, count);
 372                 put_driver(driver);
 373         }
 374         return ret;
 375 }
 376
 377 static struct sysfs_ops pci_driver_sysfs_ops = {
 378         .show = pci_driver_attr_show,
 379         .store = pci_driver_attr_store,
 380 };
 381 static struct kobj_type pci_driver_kobj_type = {
 382         .sysfs_ops = &pci_driver_sysfs_ops,
 383 };
 384
 385 static int
 386 pci_populate_driver_dir(struct pci_driver *drv)
 387 {
 388         return pci_create_newid_file(drv);
 389 }
 390
 391 /**
 392  * pci_register_driver - register a new pci driver
 393  * @drv: the driver structure to register
 394  *
 395  * Adds the driver structure to the list of registered drivers.
 396  * Returns a negative value on error, otherwise 0.
 397  * If no error occured, the driver remains registered even if
 398  * no device was claimed during registration.
 399  */
 400 int pci_register_driver(struct pci_driver *drv)
 401 {
 402         int error;
 403
 404         /* initialize common driver fields */
 405         drv->driver.name = drv->name;
 406         drv->driver.bus = &pci_bus_type;
 407         drv->driver.probe = pci_device_probe;
 408         drv->driver.remove = pci_device_remove;
 409         drv->driver.owner = drv->owner;
 410         drv->driver.kobj.ktype = &pci_driver_kobj_type;
 411         pci_init_dynids(&drv->dynids);
 412
 413         /* register with core */
 414         error = driver_register(&drv->driver);
 415
 416         if (!error)
 417                 pci_populate_driver_dir(drv);
 418
 419         return error;
 420 }
 421
 422 /**
 423  * pci_unregister_driver - unregister a pci driver
 424  * @drv: the driver structure to unregister
 425  *
 426  * Deletes the driver structure from the list of registered PCI drivers,
 427  * gives it a chance to clean up by calling its remove() function for
 428  * each device it was responsible for, and marks those devices as
 429  * driverless.
 430  */
 431
 432 void
 433 pci_unregister_driver(struct pci_driver *drv)
 434 {
 435         driver_unregister(&drv->driver);
 436         pci_free_dynids(drv);
 437 }
 438
 439 static struct pci_driver pci_compat_driver = {
 440         .name = "compat"
 441 };
 442
 443 /**
 444  * pci_dev_driver - get the pci_driver of a device
 445  * @dev: the device to query
 446  *
 447  * Returns the appropriate pci_driver structure or %NULL if there is no
 448  * registered driver for the device.
 449  */
 450 struct pci_driver *
 451 pci_dev_driver(const struct pci_dev *dev)
 452 {
 453         if (dev->driver)
 454                 return dev->driver;
 455         else {
 456                 int i;
 457                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
 458                         if (dev->resource[i].flags & IORESOURCE_BUSY)
 459                                 return &pci_compat_driver;
 460         }
 461         return NULL;
 462 }
 463
 464 /**
 465  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
 466  * @ids: array of PCI device id structures to search in
 467  * @dev: the PCI device structure to match against
 468  *
 469  * Used by a driver to check whether a PCI device present in the
 470  * system is in its list of supported devices.Returns the matching
 471  * pci_device_id structure or %NULL if there is no match.
 472  */
 473 static int pci_bus_match(struct device * dev, struct device_driver * drv)
 474 {
 475         const struct pci_dev * pci_dev = to_pci_dev(dev);
 476         struct pci_driver * pci_drv = to_pci_driver(drv);
 477         const struct pci_device_id * ids = pci_drv->id_table;
 478         const struct pci_device_id *found_id;
 479
 480         if (!ids)
 481                 return 0;
 482
 483         found_id = pci_match_device(ids, pci_dev);
 484         if (found_id)
 485                 return 1;
 486
 487         return pci_bus_match_dynids(pci_dev, pci_drv);
 488 }
 489
 490 /**
 491  * pci_dev_get - increments the reference count of the pci device structure
 492  * @dev: the device being referenced
 493  *
 494  * Each live reference to a device should be refcounted.
 495  *
 496  * Drivers for PCI devices should normally record such references in
 497  * their probe() methods, when they bind to a device, and release
 498  * them by calling pci_dev_put(), in their disconnect() methods.
 499  *
 500  * A pointer to the device with the incremented reference counter is returned.
 501  */
 502 struct pci_dev *pci_dev_get(struct pci_dev *dev)
 503 {
 504         if (dev)
 505                 get_device(&dev->dev);
 506         return dev;
 507 }
 508
 509 /**
 510  * pci_dev_put - release a use of the pci device structure
 511  * @dev: device that's been disconnected
 512  *
 513  * Must be called when a user of a device is finished with it.  When the last
 514  * user of the device calls this function, the memory of the device is freed.
 515  */
 516 void pci_dev_put(struct pci_dev *dev)
 517 {
 518         if (dev)
 519                 put_device(&dev->dev);
 520 }
 521
 522 #ifndef CONFIG_HOTPLUG
 523 int pci_hotplug (struct device *dev, char **envp, int num_envp,
 524                  char *buffer, int buffer_size)
 525 {
 526         return -ENODEV;
 527 }
 528 #endif
 529
 530 struct bus_type pci_bus_type = {
 531         .name           = "pci",
 532         .match          = pci_bus_match,
 533         .hotplug        = pci_hotplug,
 534         .suspend        = pci_device_suspend,
 535         .resume         = pci_device_resume,
 536         .dev_attrs      = pci_dev_attrs,
 537 };
 538
 539 static int __init pci_driver_init(void)
 540 {
 541         return bus_register(&pci_bus_type);
 542 }
 543
 544 postcore_initcall(pci_driver_init);
 545
 546 EXPORT_SYMBOL(pci_match_device);
 547 EXPORT_SYMBOL(pci_register_driver);
 548 EXPORT_SYMBOL(pci_unregister_driver);
 549 EXPORT_SYMBOL(pci_dev_driver);
 550 EXPORT_SYMBOL(pci_bus_type);
 551 EXPORT_SYMBOL(pci_dev_get);
 552 EXPORT_SYMBOL(pci_dev_put);