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