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