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