drivers/base/platform.c

   1 /*
   2  * platform.c - platform 'pseudo' bus for legacy devices
   3  *
   4  * Copyright (c) 2002-3 Patrick Mochel
   5  * Copyright (c) 2002-3 Open Source Development Labs
   6  *
   7  * This file is released under the GPLv2
   8  *
   9  * Please see Documentation/driver-model/platform.txt for more
  10  * information.
  11  */
  12
  13 #include <linux/platform_device.h>
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/dma-mapping.h>
  17 #include <linux/bootmem.h>
  18 #include <linux/err.h>
  19 #include <linux/slab.h>
  20
  21 #include "base.h"
  22
  23 #define to_platform_driver(drv) (container_of((drv), struct platform_driver, \
  24                                  driver))
  25
  26 struct device platform_bus = {
  27         .init_name      = "platform",
  28 };
  29 EXPORT_SYMBOL_GPL(platform_bus);
  30
  31 /**
  32  * platform_get_resource - get a resource for a device
  33  * @dev: platform device
  34  * @type: resource type
  35  * @num: resource index
  36  */
  37 struct resource *platform_get_resource(struct platform_device *dev,
  38                                        unsigned int type, unsigned int num)
  39 {
  40         int i;
  41
  42         for (i = 0; i < dev->num_resources; i++) {
  43                 struct resource *r = &dev->resource[i];
  44
  45                 if (type == resource_type(r) && num-- == 0)
  46                         return r;
  47         }
  48         return NULL;
  49 }
  50 EXPORT_SYMBOL_GPL(platform_get_resource);
  51
  52 /**
  53  * platform_get_irq - get an IRQ for a device
  54  * @dev: platform device
  55  * @num: IRQ number index
  56  */
  57 int platform_get_irq(struct platform_device *dev, unsigned int num)
  58 {
  59         struct resource *r = platform_get_resource(dev, IORESOURCE_IRQ, num);
  60
  61         return r ? r->start : -ENXIO;
  62 }
  63 EXPORT_SYMBOL_GPL(platform_get_irq);
  64
  65 /**
  66  * platform_get_resource_byname - get a resource for a device by name
  67  * @dev: platform device
  68  * @type: resource type
  69  * @name: resource name
  70  */
  71 struct resource *platform_get_resource_byname(struct platform_device *dev,
  72                                               unsigned int type, char *name)
  73 {
  74         int i;
  75
  76         for (i = 0; i < dev->num_resources; i++) {
  77                 struct resource *r = &dev->resource[i];
  78
  79                 if (type == resource_type(r) && !strcmp(r->name, name))
  80                         return r;
  81         }
  82         return NULL;
  83 }
  84 EXPORT_SYMBOL_GPL(platform_get_resource_byname);
  85
  86 /**
  87  * platform_get_irq - get an IRQ for a device
  88  * @dev: platform device
  89  * @name: IRQ name
  90  */
  91 int platform_get_irq_byname(struct platform_device *dev, char *name)
  92 {
  93         struct resource *r = platform_get_resource_byname(dev, IORESOURCE_IRQ,
  94                                                           name);
  95
  96         return r ? r->start : -ENXIO;
  97 }
  98 EXPORT_SYMBOL_GPL(platform_get_irq_byname);
  99
 100 /**
 101  * platform_add_devices - add a numbers of platform devices
 102  * @devs: array of platform devices to add
 103  * @num: number of platform devices in array
 104  */
 105 int platform_add_devices(struct platform_device **devs, int num)
 106 {
 107         int i, ret = 0;
 108
 109         for (i = 0; i < num; i++) {
 110                 ret = platform_device_register(devs[i]);
 111                 if (ret) {
 112                         while (--i >= 0)
 113                                 platform_device_unregister(devs[i]);
 114                         break;
 115                 }
 116         }
 117
 118         return ret;
 119 }
 120 EXPORT_SYMBOL_GPL(platform_add_devices);
 121
 122 struct platform_object {
 123         struct platform_device pdev;
 124         char name[1];
 125 };
 126
 127 /**
 128  * platform_device_put
 129  * @pdev: platform device to free
 130  *
 131  * Free all memory associated with a platform device.  This function must
 132  * _only_ be externally called in error cases.  All other usage is a bug.
 133  */
 134 void platform_device_put(struct platform_device *pdev)
 135 {
 136         if (pdev)
 137                 put_device(&pdev->dev);
 138 }
 139 EXPORT_SYMBOL_GPL(platform_device_put);
 140
 141 static void platform_device_release(struct device *dev)
 142 {
 143         struct platform_object *pa = container_of(dev, struct platform_object,
 144                                                   pdev.dev);
 145
 146         kfree(pa->pdev.dev.platform_data);
 147         kfree(pa->pdev.resource);
 148         kfree(pa);
 149 }
 150
 151 /**
 152  * platform_device_alloc
 153  * @name: base name of the device we're adding
 154  * @id: instance id
 155  *
 156  * Create a platform device object which can have other objects attached
 157  * to it, and which will have attached objects freed when it is released.
 158  */
 159 struct platform_device *platform_device_alloc(const char *name, int id)
 160 {
 161         struct platform_object *pa;
 162
 163         pa = kzalloc(sizeof(struct platform_object) + strlen(name), GFP_KERNEL);
 164         if (pa) {
 165                 strcpy(pa->name, name);
 166                 pa->pdev.name = pa->name;
 167                 pa->pdev.id = id;
 168                 device_initialize(&pa->pdev.dev);
 169                 pa->pdev.dev.release = platform_device_release;
 170         }
 171
 172         return pa ? &pa->pdev : NULL;
 173 }
 174 EXPORT_SYMBOL_GPL(platform_device_alloc);
 175
 176 /**
 177  * platform_device_add_resources
 178  * @pdev: platform device allocated by platform_device_alloc to add resources to
 179  * @res: set of resources that needs to be allocated for the device
 180  * @num: number of resources
 181  *
 182  * Add a copy of the resources to the platform device.  The memory
 183  * associated with the resources will be freed when the platform device is
 184  * released.
 185  */
 186 int platform_device_add_resources(struct platform_device *pdev,
 187                                   struct resource *res, unsigned int num)
 188 {
 189         struct resource *r;
 190
 191         r = kmalloc(sizeof(struct resource) * num, GFP_KERNEL);
 192         if (r) {
 193                 memcpy(r, res, sizeof(struct resource) * num);
 194                 pdev->resource = r;
 195                 pdev->num_resources = num;
 196         }
 197         return r ? 0 : -ENOMEM;
 198 }
 199 EXPORT_SYMBOL_GPL(platform_device_add_resources);
 200
 201 /**
 202  * platform_device_add_data
 203  * @pdev: platform device allocated by platform_device_alloc to add resources to
 204  * @data: platform specific data for this platform device
 205  * @size: size of platform specific data
 206  *
 207  * Add a copy of platform specific data to the platform device's
 208  * platform_data pointer.  The memory associated with the platform data
 209  * will be freed when the platform device is released.
 210  */
 211 int platform_device_add_data(struct platform_device *pdev, const void *data,
 212                              size_t size)
 213 {
 214         void *d;
 215
 216         d = kmalloc(size, GFP_KERNEL);
 217         if (d) {
 218                 memcpy(d, data, size);
 219                 pdev->dev.platform_data = d;
 220                 pdev->platform_data = d;
 221         }
 222         return d ? 0 : -ENOMEM;
 223 }
 224 EXPORT_SYMBOL_GPL(platform_device_add_data);
 225
 226 /**
 227  * platform_device_add - add a platform device to device hierarchy
 228  * @pdev: platform device we're adding
 229  *
 230  * This is part 2 of platform_device_register(), though may be called
 231  * separately _iff_ pdev was allocated by platform_device_alloc().
 232  */
 233 int platform_device_add(struct platform_device *pdev)
 234 {
 235         int i, ret = 0;
 236
 237         if (!pdev)
 238                 return -EINVAL;
 239
 240         if (!pdev->dev.parent)
 241                 pdev->dev.parent = &platform_bus;
 242
 243         pdev->dev.bus = &platform_bus_type;
 244
 245         if (pdev->id != -1)
 246                 dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);
 247         else
 248                 dev_set_name(&pdev->dev, pdev->name);
 249
 250         /* We will remove platform_data field from struct device
 251         * if all platform devices pass its platform specific data
 252         * from platform_device. The conversion is going to be a
 253         * long time, so we allow the two cases coexist to make
 254         * this kind of fix more easily*/
 255         if (pdev->platform_data && pdev->dev.platform_data) {
 256                 printk(KERN_ERR
 257                                "%s: use which platform_data?\n",
 258                                dev_name(&pdev->dev));
 259         } else if (pdev->platform_data) {
 260                 pdev->dev.platform_data = pdev->platform_data;
 261         } else if (pdev->dev.platform_data) {
 262                 pdev->platform_data = pdev->dev.platform_data;
 263         }
 264
 265         for (i = 0; i < pdev->num_resources; i++) {
 266                 struct resource *p, *r = &pdev->resource[i];
 267
 268                 if (r->name == NULL)
 269                         r->name = dev_name(&pdev->dev);
 270
 271                 p = r->parent;
 272                 if (!p) {
 273                         if (resource_type(r) == IORESOURCE_MEM)
 274                                 p = &iomem_resource;
 275                         else if (resource_type(r) == IORESOURCE_IO)
 276                                 p = &ioport_resource;
 277                 }
 278
 279                 if (p && insert_resource(p, r)) {
 280                         printk(KERN_ERR
 281                                "%s: failed to claim resource %d\n",
 282                                dev_name(&pdev->dev), i);
 283                         ret = -EBUSY;
 284                         goto failed;
 285                 }
 286         }
 287
 288         pr_debug("Registering platform device '%s'. Parent at %s\n",
 289                  dev_name(&pdev->dev), dev_name(pdev->dev.parent));
 290
 291         ret = device_add(&pdev->dev);
 292         if (ret == 0)
 293                 return ret;
 294
 295  failed:
 296         while (--i >= 0) {
 297                 struct resource *r = &pdev->resource[i];
 298                 unsigned long type = resource_type(r);
 299
 300                 if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
 301                         release_resource(r);
 302         }
 303
 304         return ret;
 305 }
 306 EXPORT_SYMBOL_GPL(platform_device_add);
 307
 308 /**
 309  * platform_device_del - remove a platform-level device
 310  * @pdev: platform device we're removing
 311  *
 312  * Note that this function will also release all memory- and port-based
 313  * resources owned by the device (@dev->resource).  This function must
 314  * _only_ be externally called in error cases.  All other usage is a bug.
 315  */
 316 void platform_device_del(struct platform_device *pdev)
 317 {
 318         int i;
 319
 320         if (pdev) {
 321                 device_del(&pdev->dev);
 322
 323                 for (i = 0; i < pdev->num_resources; i++) {
 324                         struct resource *r = &pdev->resource[i];
 325                         unsigned long type = resource_type(r);
 326
 327                         if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
 328                                 release_resource(r);
 329                 }
 330         }
 331 }
 332 EXPORT_SYMBOL_GPL(platform_device_del);
 333
 334 /**
 335  * platform_device_register - add a platform-level device
 336  * @pdev: platform device we're adding
 337  */
 338 int platform_device_register(struct platform_device *pdev)
 339 {
 340         device_initialize(&pdev->dev);
 341         return platform_device_add(pdev);
 342 }
 343 EXPORT_SYMBOL_GPL(platform_device_register);
 344
 345 /**
 346  * platform_device_unregister - unregister a platform-level device
 347  * @pdev: platform device we're unregistering
 348  *
 349  * Unregistration is done in 2 steps. First we release all resources
 350  * and remove it from the subsystem, then we drop reference count by
 351  * calling platform_device_put().
 352  */
 353 void platform_device_unregister(struct platform_device *pdev)
 354 {
 355         platform_device_del(pdev);
 356         platform_device_put(pdev);
 357 }
 358 EXPORT_SYMBOL_GPL(platform_device_unregister);
 359
 360 /**
 361  * platform_device_register_simple
 362  * @name: base name of the device we're adding
 363  * @id: instance id
 364  * @res: set of resources that needs to be allocated for the device
 365  * @num: number of resources
 366  *
 367  * This function creates a simple platform device that requires minimal
 368  * resource and memory management. Canned release function freeing memory
 369  * allocated for the device allows drivers using such devices to be
 370  * unloaded without waiting for the last reference to the device to be
 371  * dropped.
 372  *
 373  * This interface is primarily intended for use with legacy drivers which
 374  * probe hardware directly.  Because such drivers create sysfs device nodes
 375  * themselves, rather than letting system infrastructure handle such device
 376  * enumeration tasks, they don't fully conform to the Linux driver model.
 377  * In particular, when such drivers are built as modules, they can't be
 378  * "hotplugged".
 379  */
 380 struct platform_device *platform_device_register_simple(const char *name,
 381                                                         int id,
 382                                                         struct resource *res,
 383                                                         unsigned int num)
 384 {
 385         struct platform_device *pdev;
 386         int retval;
 387
 388         pdev = platform_device_alloc(name, id);
 389         if (!pdev) {
 390                 retval = -ENOMEM;
 391                 goto error;
 392         }
 393
 394         if (num) {
 395                 retval = platform_device_add_resources(pdev, res, num);
 396                 if (retval)
 397                         goto error;
 398         }
 399
 400         retval = platform_device_add(pdev);
 401         if (retval)
 402                 goto error;
 403
 404         return pdev;
 405
 406 error:
 407         platform_device_put(pdev);
 408         return ERR_PTR(retval);
 409 }
 410 EXPORT_SYMBOL_GPL(platform_device_register_simple);
 411
 412 /**
 413  * platform_device_register_data
 414  * @parent: parent device for the device we're adding
 415  * @name: base name of the device we're adding
 416  * @id: instance id
 417  * @data: platform specific data for this platform device
 418  * @size: size of platform specific data
 419  *
 420  * This function creates a simple platform device that requires minimal
 421  * resource and memory management. Canned release function freeing memory
 422  * allocated for the device allows drivers using such devices to be
 423  * unloaded without waiting for the last reference to the device to be
 424  * dropped.
 425  */
 426 struct platform_device *platform_device_register_data(
 427                 struct device *parent,
 428                 const char *name, int id,
 429                 const void *data, size_t size)
 430 {
 431         struct platform_device *pdev;
 432         int retval;
 433
 434         pdev = platform_device_alloc(name, id);
 435         if (!pdev) {
 436                 retval = -ENOMEM;
 437                 goto error;
 438         }
 439
 440         pdev->dev.parent = parent;
 441
 442         if (size) {
 443                 retval = platform_device_add_data(pdev, data, size);
 444                 if (retval)
 445                         goto error;
 446         }
 447
 448         retval = platform_device_add(pdev);
 449         if (retval)
 450                 goto error;
 451
 452         return pdev;
 453
 454 error:
 455         platform_device_put(pdev);
 456         return ERR_PTR(retval);
 457 }
 458
 459 static int platform_drv_probe(struct device *_dev)
 460 {
 461         struct platform_driver *drv = to_platform_driver(_dev->driver);
 462         struct platform_device *dev = to_platform_device(_dev);
 463
 464         return drv->probe(dev);
 465 }
 466
 467 static int platform_drv_probe_fail(struct device *_dev)
 468 {
 469         return -ENXIO;
 470 }
 471
 472 static int platform_drv_remove(struct device *_dev)
 473 {
 474         struct platform_driver *drv = to_platform_driver(_dev->driver);
 475         struct platform_device *dev = to_platform_device(_dev);
 476
 477         return drv->remove(dev);
 478 }
 479
 480 static void platform_drv_shutdown(struct device *_dev)
 481 {
 482         struct platform_driver *drv = to_platform_driver(_dev->driver);
 483         struct platform_device *dev = to_platform_device(_dev);
 484
 485         drv->shutdown(dev);
 486 }
 487
 488 static int platform_drv_suspend(struct device *_dev, pm_message_t state)
 489 {
 490         struct platform_driver *drv = to_platform_driver(_dev->driver);
 491         struct platform_device *dev = to_platform_device(_dev);
 492
 493         return drv->suspend(dev, state);
 494 }
 495
 496 static int platform_drv_resume(struct device *_dev)
 497 {
 498         struct platform_driver *drv = to_platform_driver(_dev->driver);
 499         struct platform_device *dev = to_platform_device(_dev);
 500
 501         return drv->resume(dev);
 502 }
 503
 504 /**
 505  * platform_driver_register
 506  * @drv: platform driver structure
 507  */
 508 int platform_driver_register(struct platform_driver *drv)
 509 {
 510         drv->driver.bus = &platform_bus_type;
 511         if (drv->probe)
 512                 drv->driver.probe = platform_drv_probe;
 513         if (drv->remove)
 514                 drv->driver.remove = platform_drv_remove;
 515         if (drv->shutdown)
 516                 drv->driver.shutdown = platform_drv_shutdown;
 517         if (drv->suspend)
 518                 drv->driver.suspend = platform_drv_suspend;
 519         if (drv->resume)
 520                 drv->driver.resume = platform_drv_resume;
 521         return driver_register(&drv->driver);
 522 }
 523 EXPORT_SYMBOL_GPL(platform_driver_register);
 524
 525 /**
 526  * platform_driver_unregister
 527  * @drv: platform driver structure
 528  */
 529 void platform_driver_unregister(struct platform_driver *drv)
 530 {
 531         driver_unregister(&drv->driver);
 532 }
 533 EXPORT_SYMBOL_GPL(platform_driver_unregister);
 534
 535 /**
 536  * platform_driver_probe - register driver for non-hotpluggable device
 537  * @drv: platform driver structure
 538  * @probe: the driver probe routine, probably from an __init section
 539  *
 540  * Use this instead of platform_driver_register() when you know the device
 541  * is not hotpluggable and has already been registered, and you want to
 542  * remove its run-once probe() infrastructure from memory after the driver
 543  * has bound to the device.
 544  *
 545  * One typical use for this would be with drivers for controllers integrated
 546  * into system-on-chip processors, where the controller devices have been
 547  * configured as part of board setup.
 548  *
 549  * Returns zero if the driver registered and bound to a device, else returns
 550  * a negative error code and with the driver not registered.
 551  */
 552 int __init_or_module platform_driver_probe(struct platform_driver *drv,
 553                 int (*probe)(struct platform_device *))
 554 {
 555         int retval, code;
 556
 557         /* temporary section violation during probe() */
 558         drv->probe = probe;
 559         retval = code = platform_driver_register(drv);
 560
 561         /* Fixup that section violation, being paranoid about code scanning
 562          * the list of drivers in order to probe new devices.  Check to see
 563          * if the probe was successful, and make sure any forced probes of
 564          * new devices fail.
 565          */
 566         spin_lock(&platform_bus_type.p->klist_drivers.k_lock);
 567         drv->probe = NULL;
 568         if (code == 0 && list_empty(&drv->driver.p->klist_devices.k_list))
 569                 retval = -ENODEV;
 570         drv->driver.probe = platform_drv_probe_fail;
 571         spin_unlock(&platform_bus_type.p->klist_drivers.k_lock);
 572
 573         if (code != retval)
 574                 platform_driver_unregister(drv);
 575         return retval;
 576 }
 577 EXPORT_SYMBOL_GPL(platform_driver_probe);
 578
 579 /* modalias support enables more hands-off userspace setup:
 580  * (a) environment variable lets new-style hotplug events work once system is
 581  *     fully running:  "modprobe $MODALIAS"
 582  * (b) sysfs attribute lets new-style coldplug recover from hotplug events
 583  *     mishandled before system is fully running:  "modprobe $(cat modalias)"
 584  */
 585 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
 586                              char *buf)
 587 {
 588         struct platform_device  *pdev = to_platform_device(dev);
 589         int len = snprintf(buf, PAGE_SIZE, "platform:%s\n", pdev->name);
 590
 591         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
 592 }
 593
 594 static struct device_attribute platform_dev_attrs[] = {
 595         __ATTR_RO(modalias),
 596         __ATTR_NULL,
 597 };
 598
 599 static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
 600 {
 601         struct platform_device  *pdev = to_platform_device(dev);
 602
 603         add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX,
 604                 (pdev->id_entry) ? pdev->id_entry->name : pdev->name);
 605         return 0;
 606 }
 607
 608 static const struct platform_device_id *platform_match_id(
 609                         struct platform_device_id *id,
 610                         struct platform_device *pdev)
 611 {
 612         while (id->name[0]) {
 613                 if (strcmp(pdev->name, id->name) == 0) {
 614                         pdev->id_entry = id;
 615                         return id;
 616                 }
 617                 id++;
 618         }
 619         return NULL;
 620 }
 621
 622 /**
 623  * platform_match - bind platform device to platform driver.
 624  * @dev: device.
 625  * @drv: driver.
 626  *
 627  * Platform device IDs are assumed to be encoded like this:
 628  * "<name><instance>", where <name> is a short description of the type of
 629  * device, like "pci" or "floppy", and <instance> is the enumerated
 630  * instance of the device, like '0' or '42'.  Driver IDs are simply
 631  * "<name>".  So, extract the <name> from the platform_device structure,
 632  * and compare it against the name of the driver. Return whether they match
 633  * or not.
 634  */
 635 static int platform_match(struct device *dev, struct device_driver *drv)
 636 {
 637         struct platform_device *pdev = to_platform_device(dev);
 638         struct platform_driver *pdrv = to_platform_driver(drv);
 639
 640         /* match against the id table first */
 641         if (pdrv->id_table)
 642                 return platform_match_id(pdrv->id_table, pdev) != NULL;
 643
 644         /* fall-back to driver name match */
 645         return (strcmp(pdev->name, drv->name) == 0);
 646 }
 647
 648 #ifdef CONFIG_PM_SLEEP
 649
 650 static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
 651 {
 652         int ret = 0;
 653
 654         if (dev->driver && dev->driver->suspend)
 655                 ret = dev->driver->suspend(dev, mesg);
 656
 657         return ret;
 658 }
 659
 660 static int platform_legacy_suspend_late(struct device *dev, pm_message_t mesg)
 661 {
 662         struct platform_driver *pdrv = to_platform_driver(dev->driver);
 663         struct platform_device *pdev = to_platform_device(dev);
 664         int ret = 0;
 665
 666         if (dev->driver && pdrv->suspend_late)
 667                 ret = pdrv->suspend_late(pdev, mesg);
 668
 669         return ret;
 670 }
 671
 672 static int platform_legacy_resume_early(struct device *dev)
 673 {
 674         struct platform_driver *pdrv = to_platform_driver(dev->driver);
 675         struct platform_device *pdev = to_platform_device(dev);
 676         int ret = 0;
 677
 678         if (dev->driver && pdrv->resume_early)
 679                 ret = pdrv->resume_early(pdev);
 680
 681         return ret;
 682 }
 683
 684 static int platform_legacy_resume(struct device *dev)
 685 {
 686         int ret = 0;
 687
 688         if (dev->driver && dev->driver->resume)
 689                 ret = dev->driver->resume(dev);
 690
 691         return ret;
 692 }
 693
 694 static int platform_pm_prepare(struct device *dev)
 695 {
 696         struct device_driver *drv = dev->driver;
 697         int ret = 0;
 698
 699         if (drv && drv->pm && drv->pm->prepare)
 700                 ret = drv->pm->prepare(dev);
 701
 702         return ret;
 703 }
 704
 705 static void platform_pm_complete(struct device *dev)
 706 {
 707         struct device_driver *drv = dev->driver;
 708
 709         if (drv && drv->pm && drv->pm->complete)
 710                 drv->pm->complete(dev);
 711 }
 712
 713 #ifdef CONFIG_SUSPEND
 714
 715 static int platform_pm_suspend(struct device *dev)
 716 {
 717         struct device_driver *drv = dev->driver;
 718         int ret = 0;
 719
 720         if (!drv)
 721                 return 0;
 722
 723         if (drv->pm) {
 724                 if (drv->pm->suspend)
 725                         ret = drv->pm->suspend(dev);
 726         } else {
 727                 ret = platform_legacy_suspend(dev, PMSG_SUSPEND);
 728         }
 729
 730         return ret;
 731 }
 732
 733 static int platform_pm_suspend_noirq(struct device *dev)
 734 {
 735         struct device_driver *drv = dev->driver;
 736         int ret = 0;
 737
 738         if (!drv)
 739                 return 0;
 740
 741         if (drv->pm) {
 742                 if (drv->pm->suspend_noirq)
 743                         ret = drv->pm->suspend_noirq(dev);
 744         } else {
 745                 ret = platform_legacy_suspend_late(dev, PMSG_SUSPEND);
 746         }
 747
 748         return ret;
 749 }
 750
 751 static int platform_pm_resume(struct device *dev)
 752 {
 753         struct device_driver *drv = dev->driver;
 754         int ret = 0;
 755
 756         if (!drv)
 757                 return 0;
 758
 759         if (drv->pm) {
 760                 if (drv->pm->resume)
 761                         ret = drv->pm->resume(dev);
 762         } else {
 763                 ret = platform_legacy_resume(dev);
 764         }
 765
 766         return ret;
 767 }
 768
 769 static int platform_pm_resume_noirq(struct device *dev)
 770 {
 771         struct device_driver *drv = dev->driver;
 772         int ret = 0;
 773
 774         if (!drv)
 775                 return 0;
 776
 777         if (drv->pm) {
 778                 if (drv->pm->resume_noirq)
 779                         ret = drv->pm->resume_noirq(dev);
 780         } else {
 781                 ret = platform_legacy_resume_early(dev);
 782         }
 783
 784         return ret;
 785 }
 786
 787 #else /* !CONFIG_SUSPEND */
 788
 789 #define platform_pm_suspend             NULL
 790 #define platform_pm_resume              NULL
 791 #define platform_pm_suspend_noirq       NULL
 792 #define platform_pm_resume_noirq        NULL
 793
 794 #endif /* !CONFIG_SUSPEND */
 795
 796 #ifdef CONFIG_HIBERNATION
 797
 798 static int platform_pm_freeze(struct device *dev)
 799 {
 800         struct device_driver *drv = dev->driver;
 801         int ret = 0;
 802
 803         if (!drv)
 804                 return 0;
 805
 806         if (drv->pm) {
 807                 if (drv->pm->freeze)
 808                         ret = drv->pm->freeze(dev);
 809         } else {
 810                 ret = platform_legacy_suspend(dev, PMSG_FREEZE);
 811         }
 812
 813         return ret;
 814 }
 815
 816 static int platform_pm_freeze_noirq(struct device *dev)
 817 {
 818         struct device_driver *drv = dev->driver;
 819         int ret = 0;
 820
 821         if (!drv)
 822                 return 0;
 823
 824         if (drv->pm) {
 825                 if (drv->pm->freeze_noirq)
 826                         ret = drv->pm->freeze_noirq(dev);
 827         } else {
 828                 ret = platform_legacy_suspend_late(dev, PMSG_FREEZE);
 829         }
 830
 831         return ret;
 832 }
 833
 834 static int platform_pm_thaw(struct device *dev)
 835 {
 836         struct device_driver *drv = dev->driver;
 837         int ret = 0;
 838
 839         if (!drv)
 840                 return 0;
 841
 842         if (drv->pm) {
 843                 if (drv->pm->thaw)
 844                         ret = drv->pm->thaw(dev);
 845         } else {
 846                 ret = platform_legacy_resume(dev);
 847         }
 848
 849         return ret;
 850 }
 851
 852 static int platform_pm_thaw_noirq(struct device *dev)
 853 {
 854         struct device_driver *drv = dev->driver;
 855         int ret = 0;
 856
 857         if (!drv)
 858                 return 0;
 859
 860         if (drv->pm) {
 861                 if (drv->pm->thaw_noirq)
 862                         ret = drv->pm->thaw_noirq(dev);
 863         } else {
 864                 ret = platform_legacy_resume_early(dev);
 865         }
 866
 867         return ret;
 868 }
 869
 870 static int platform_pm_poweroff(struct device *dev)
 871 {
 872         struct device_driver *drv = dev->driver;
 873         int ret = 0;
 874
 875         if (!drv)
 876                 return 0;
 877
 878         if (drv->pm) {
 879                 if (drv->pm->poweroff)
 880                         ret = drv->pm->poweroff(dev);
 881         } else {
 882                 ret = platform_legacy_suspend(dev, PMSG_HIBERNATE);
 883         }
 884
 885         return ret;
 886 }
 887
 888 static int platform_pm_poweroff_noirq(struct device *dev)
 889 {
 890         struct device_driver *drv = dev->driver;
 891         int ret = 0;
 892
 893         if (!drv)
 894                 return 0;
 895
 896         if (drv->pm) {
 897                 if (drv->pm->poweroff_noirq)
 898                         ret = drv->pm->poweroff_noirq(dev);
 899         } else {
 900                 ret = platform_legacy_suspend_late(dev, PMSG_HIBERNATE);
 901         }
 902
 903         return ret;
 904 }
 905
 906 static int platform_pm_restore(struct device *dev)
 907 {
 908         struct device_driver *drv = dev->driver;
 909         int ret = 0;
 910
 911         if (!drv)
 912                 return 0;
 913
 914         if (drv->pm) {
 915                 if (drv->pm->restore)
 916                         ret = drv->pm->restore(dev);
 917         } else {
 918                 ret = platform_legacy_resume(dev);
 919         }
 920
 921         return ret;
 922 }
 923
 924 static int platform_pm_restore_noirq(struct device *dev)
 925 {
 926         struct device_driver *drv = dev->driver;
 927         int ret = 0;
 928
 929         if (!drv)
 930                 return 0;
 931
 932         if (drv->pm) {
 933                 if (drv->pm->restore_noirq)
 934                         ret = drv->pm->restore_noirq(dev);
 935         } else {
 936                 ret = platform_legacy_resume_early(dev);
 937         }
 938
 939         return ret;
 940 }
 941
 942 #else /* !CONFIG_HIBERNATION */
 943
 944 #define platform_pm_freeze              NULL
 945 #define platform_pm_thaw                NULL
 946 #define platform_pm_poweroff            NULL
 947 #define platform_pm_restore             NULL
 948 #define platform_pm_freeze_noirq        NULL
 949 #define platform_pm_thaw_noirq          NULL
 950 #define platform_pm_poweroff_noirq      NULL
 951 #define platform_pm_restore_noirq       NULL
 952
 953 #endif /* !CONFIG_HIBERNATION */
 954
 955 static struct dev_pm_ops platform_dev_pm_ops = {
 956         .prepare = platform_pm_prepare,
 957         .complete = platform_pm_complete,
 958         .suspend = platform_pm_suspend,
 959         .resume = platform_pm_resume,
 960         .freeze = platform_pm_freeze,
 961         .thaw = platform_pm_thaw,
 962         .poweroff = platform_pm_poweroff,
 963         .restore = platform_pm_restore,
 964         .suspend_noirq = platform_pm_suspend_noirq,
 965         .resume_noirq = platform_pm_resume_noirq,
 966         .freeze_noirq = platform_pm_freeze_noirq,
 967         .thaw_noirq = platform_pm_thaw_noirq,
 968         .poweroff_noirq = platform_pm_poweroff_noirq,
 969         .restore_noirq = platform_pm_restore_noirq,
 970 };
 971
 972 #define PLATFORM_PM_OPS_PTR     (&platform_dev_pm_ops)
 973
 974 #else /* !CONFIG_PM_SLEEP */
 975
 976 #define PLATFORM_PM_OPS_PTR     NULL
 977
 978 #endif /* !CONFIG_PM_SLEEP */
 979
 980 struct bus_type platform_bus_type = {
 981         .name           = "platform",
 982         .dev_attrs      = platform_dev_attrs,
 983         .match          = platform_match,
 984         .uevent         = platform_uevent,
 985         .pm             = PLATFORM_PM_OPS_PTR,
 986 };
 987 EXPORT_SYMBOL_GPL(platform_bus_type);
 988
 989 int __init platform_bus_init(void)
 990 {
 991         int error;
 992
 993         early_platform_cleanup();
 994
 995         error = device_register(&platform_bus);
 996         if (error)
 997                 return error;
 998         error =  bus_register(&platform_bus_type);
 999         if (error)
1000                 device_unregister(&platform_bus);
1001         return error;
1002 }
1003
1004 #ifndef ARCH_HAS_DMA_GET_REQUIRED_MASK
1005 u64 dma_get_required_mask(struct device *dev)
1006 {
1007         u32 low_totalram = ((max_pfn - 1) << PAGE_SHIFT);
1008         u32 high_totalram = ((max_pfn - 1) >> (32 - PAGE_SHIFT));
1009         u64 mask;
1010
1011         if (!high_totalram) {
1012                 /* convert to mask just covering totalram */
1013                 low_totalram = (1 << (fls(low_totalram) - 1));
1014                 low_totalram += low_totalram - 1;
1015                 mask = low_totalram;
1016         } else {
1017                 high_totalram = (1 << (fls(high_totalram) - 1));
1018                 high_totalram += high_totalram - 1;
1019                 mask = (((u64)high_totalram) << 32) + 0xffffffff;
1020         }
1021         return mask;
1022 }
1023 EXPORT_SYMBOL_GPL(dma_get_required_mask);
1024 #endif
1025
1026 static __initdata LIST_HEAD(early_platform_driver_list);
1027 static __initdata LIST_HEAD(early_platform_device_list);
1028
1029 /**
1030  * early_platform_driver_register
1031  * @edrv: early_platform driver structure
1032  * @buf: string passed from early_param()
1033  */
1034 int __init early_platform_driver_register(struct early_platform_driver *epdrv,
1035                                           char *buf)
1036 {
1037         unsigned long index;
1038         int n;
1039
1040         /* Simply add the driver to the end of the global list.
1041          * Drivers will by default be put on the list in compiled-in order.
1042          */
1043         if (!epdrv->list.next) {
1044                 INIT_LIST_HEAD(&epdrv->list);
1045                 list_add_tail(&epdrv->list, &early_platform_driver_list);
1046         }
1047
1048         /* If the user has specified device then make sure the driver
1049          * gets prioritized. The driver of the last device specified on
1050          * command line will be put first on the list.
1051          */
1052         n = strlen(epdrv->pdrv->driver.name);
1053         if (buf && !strncmp(buf, epdrv->pdrv->driver.name, n)) {
1054                 list_move(&epdrv->list, &early_platform_driver_list);
1055
1056                 if (!strcmp(buf, epdrv->pdrv->driver.name))
1057                         epdrv->requested_id = -1;
1058                 else if (buf[n] == '.' && strict_strtoul(&buf[n + 1], 10,
1059                                                          &index) == 0)
1060                         epdrv->requested_id = index;
1061                 else
1062                         epdrv->requested_id = EARLY_PLATFORM_ID_ERROR;
1063         }
1064
1065         return 0;
1066 }
1067
1068 /**
1069  * early_platform_add_devices - add a numbers of early platform devices
1070  * @devs: array of early platform devices to add
1071  * @num: number of early platform devices in array
1072  */
1073 void __init early_platform_add_devices(struct platform_device **devs, int num)
1074 {
1075         struct device *dev;
1076         int i;
1077
1078         /* simply add the devices to list */
1079         for (i = 0; i < num; i++) {
1080                 dev = &devs[i]->dev;
1081
1082                 if (!dev->devres_head.next) {
1083                         INIT_LIST_HEAD(&dev->devres_head);
1084                         list_add_tail(&dev->devres_head,
1085                                       &early_platform_device_list);
1086                 }
1087         }
1088 }
1089
1090 /**
1091  * early_platform_driver_register_all
1092  * @class_str: string to identify early platform driver class
1093  */
1094 void __init early_platform_driver_register_all(char *class_str)
1095 {
1096         /* The "class_str" parameter may or may not be present on the kernel
1097          * command line. If it is present then there may be more than one
1098          * matching parameter.
1099          *
1100          * Since we register our early platform drivers using early_param()
1101          * we need to make sure that they also get registered in the case
1102          * when the parameter is missing from the kernel command line.
1103          *
1104          * We use parse_early_options() to make sure the early_param() gets
1105          * called at least once. The early_param() may be called more than
1106          * once since the name of the preferred device may be specified on
1107          * the kernel command line. early_platform_driver_register() handles
1108          * this case for us.
1109          */
1110         parse_early_options(class_str);
1111 }
1112
1113 /**
1114  * early_platform_match
1115  * @edrv: early platform driver structure
1116  * @id: id to match against
1117  */
1118 static  __init struct platform_device *
1119 early_platform_match(struct early_platform_driver *epdrv, int id)
1120 {
1121         struct platform_device *pd;
1122
1123         list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
1124                 if (platform_match(&pd->dev, &epdrv->pdrv->driver))
1125                         if (pd->id == id)
1126                                 return pd;
1127
1128         return NULL;
1129 }
1130
1131 /**
1132  * early_platform_left
1133  * @edrv: early platform driver structure
1134  * @id: return true if id or above exists
1135  */
1136 static  __init int early_platform_left(struct early_platform_driver *epdrv,
1137                                        int id)
1138 {
1139         struct platform_device *pd;
1140
1141         list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
1142                 if (platform_match(&pd->dev, &epdrv->pdrv->driver))
1143                         if (pd->id >= id)
1144                                 return 1;
1145
1146         return 0;
1147 }
1148
1149 /**
1150  * early_platform_driver_probe_id
1151  * @class_str: string to identify early platform driver class
1152  * @id: id to match against
1153  * @nr_probe: number of platform devices to successfully probe before exiting
1154  */
1155 static int __init early_platform_driver_probe_id(char *class_str,
1156                                                  int id,
1157                                                  int nr_probe)
1158 {
1159         struct early_platform_driver *epdrv;
1160         struct platform_device *match;
1161         int match_id;
1162         int n = 0;
1163         int left = 0;
1164
1165         list_for_each_entry(epdrv, &early_platform_driver_list, list) {
1166                 /* only use drivers matching our class_str */
1167                 if (strcmp(class_str, epdrv->class_str))
1168                         continue;
1169
1170                 if (id == -2) {
1171                         match_id = epdrv->requested_id;
1172                         left = 1;
1173
1174                 } else {
1175                         match_id = id;
1176                         left += early_platform_left(epdrv, id);
1177
1178                         /* skip requested id */
1179                         switch (epdrv->requested_id) {
1180                         case EARLY_PLATFORM_ID_ERROR:
1181                         case EARLY_PLATFORM_ID_UNSET:
1182                                 break;
1183                         default:
1184                                 if (epdrv->requested_id == id)
1185                                         match_id = EARLY_PLATFORM_ID_UNSET;
1186                         }
1187                 }
1188
1189                 switch (match_id) {
1190                 case EARLY_PLATFORM_ID_ERROR:
1191                         pr_warning("%s: unable to parse %s parameter\n",
1192                                    class_str, epdrv->pdrv->driver.name);
1193                         /* fall-through */
1194                 case EARLY_PLATFORM_ID_UNSET:
1195                         match = NULL;
1196                         break;
1197                 default:
1198                         match = early_platform_match(epdrv, match_id);
1199                 }
1200
1201                 if (match) {
1202                         if (epdrv->pdrv->probe(match))
1203                                 pr_warning("%s: unable to probe %s early.\n",
1204                                            class_str, match->name);
1205                         else
1206                                 n++;
1207                 }
1208
1209                 if (n >= nr_probe)
1210                         break;
1211         }
1212
1213         if (left)
1214                 return n;
1215         else
1216                 return -ENODEV;
1217 }
1218
1219 /**
1220  * early_platform_driver_probe
1221  * @class_str: string to identify early platform driver class
1222  * @nr_probe: number of platform devices to successfully probe before exiting
1223  * @user_only: only probe user specified early platform devices
1224  */
1225 int __init early_platform_driver_probe(char *class_str,
1226                                        int nr_probe,
1227                                        int user_only)
1228 {
1229         int k, n, i;
1230
1231         n = 0;
1232         for (i = -2; n < nr_probe; i++) {
1233                 k = early_platform_driver_probe_id(class_str, i, nr_probe - n);
1234
1235                 if (k < 0)
1236                         break;
1237
1238                 n += k;
1239
1240                 if (user_only)
1241                         break;
1242         }
1243
1244         return n;
1245 }
1246
1247 /**
1248  * early_platform_cleanup - clean up early platform code
1249  */
1250 void __init early_platform_cleanup(void)
1251 {
1252         struct platform_device *pd, *pd2;
1253
1254         /* clean up the devres list used to chain devices */
1255         list_for_each_entry_safe(pd, pd2, &early_platform_device_list,
1256                                  dev.devres_head) {
1257                 list_del(&pd->dev.devres_head);
1258                 memset(&pd->dev.devres_head, 0, sizeof(pd->dev.devres_head));
1259         }
1260 }
1261