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