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 ret = drv->probe(dev); 518 if (ret) 519 dev_pm_domain_detach(_dev, true); 520 } 521 522 if (drv->prevent_deferred_probe && ret == -EPROBE_DEFER) { 523 dev_warn(_dev, "probe deferral not supported\n"); 524 ret = -ENXIO; 525 } 526 527 return ret; 528} 529 530static int platform_drv_probe_fail(struct device *_dev) 531{ 532 return -ENXIO; 533} 534 535static int platform_drv_remove(struct device *_dev) 536{ 537 struct platform_driver *drv = to_platform_driver(_dev->driver); 538 struct platform_device *dev = to_platform_device(_dev); 539 int ret; 540 541 ret = drv->remove(dev); 542 dev_pm_domain_detach(_dev, true); 543 544 return ret; 545} 546 547static void platform_drv_shutdown(struct device *_dev) 548{ 549 struct platform_driver *drv = to_platform_driver(_dev->driver); 550 struct platform_device *dev = to_platform_device(_dev); 551 552 drv->shutdown(dev); 553 dev_pm_domain_detach(_dev, true); 554} 555 556/** 557 * __platform_driver_register - register a driver for platform-level devices 558 * @drv: platform driver structure 559 * @owner: owning module/driver 560 */ 561int __platform_driver_register(struct platform_driver *drv, 562 struct module *owner) 563{ 564 drv->driver.owner = owner; 565 drv->driver.bus = &platform_bus_type; 566 if (drv->probe) 567 drv->driver.probe = platform_drv_probe; 568 if (drv->remove) 569 drv->driver.remove = platform_drv_remove; 570 if (drv->shutdown) 571 drv->driver.shutdown = platform_drv_shutdown; 572 573 return driver_register(&drv->driver); 574} 575EXPORT_SYMBOL_GPL(__platform_driver_register); 576 577/** 578 * platform_driver_unregister - unregister a driver for platform-level devices 579 * @drv: platform driver structure 580 */ 581void platform_driver_unregister(struct platform_driver *drv) 582{ 583 driver_unregister(&drv->driver); 584} 585EXPORT_SYMBOL_GPL(platform_driver_unregister); 586 587/** 588 * __platform_driver_probe - register driver for non-hotpluggable device 589 * @drv: platform driver structure 590 * @probe: the driver probe routine, probably from an __init section 591 * @module: module which will be the owner of the driver 592 * 593 * Use this instead of platform_driver_register() when you know the device 594 * is not hotpluggable and has already been registered, and you want to 595 * remove its run-once probe() infrastructure from memory after the driver 596 * has bound to the device. 597 * 598 * One typical use for this would be with drivers for controllers integrated 599 * into system-on-chip processors, where the controller devices have been 600 * configured as part of board setup. 601 * 602 * Note that this is incompatible with deferred probing. 603 * 604 * Returns zero if the driver registered and bound to a device, else returns 605 * a negative error code and with the driver not registered. 606 */ 607int __init_or_module __platform_driver_probe(struct platform_driver *drv, 608 int (*probe)(struct platform_device *), struct module *module) 609{ 610 int retval, code; 611 612 /* 613 * Prevent driver from requesting probe deferral to avoid further 614 * futile probe attempts. 615 */ 616 drv->prevent_deferred_probe = true; 617 618 /* make sure driver won't have bind/unbind attributes */ 619 drv->driver.suppress_bind_attrs = true; 620 621 /* temporary section violation during probe() */ 622 drv->probe = probe; 623 retval = code = __platform_driver_register(drv, module); 624 625 /* 626 * Fixup that section violation, being paranoid about code scanning 627 * the list of drivers in order to probe new devices. Check to see 628 * if the probe was successful, and make sure any forced probes of 629 * new devices fail. 630 */ 631 spin_lock(&drv->driver.bus->p->klist_drivers.k_lock); 632 drv->probe = NULL; 633 if (code == 0 && list_empty(&drv->driver.p->klist_devices.k_list)) 634 retval = -ENODEV; 635 drv->driver.probe = platform_drv_probe_fail; 636 spin_unlock(&drv->driver.bus->p->klist_drivers.k_lock); 637 638 if (code != retval) 639 platform_driver_unregister(drv); 640 return retval; 641} 642EXPORT_SYMBOL_GPL(__platform_driver_probe); 643 644/** 645 * __platform_create_bundle - register driver and create corresponding device 646 * @driver: platform driver structure 647 * @probe: the driver probe routine, probably from an __init section 648 * @res: set of resources that needs to be allocated for the device 649 * @n_res: number of resources 650 * @data: platform specific data for this platform device 651 * @size: size of platform specific data 652 * @module: module which will be the owner of the driver 653 * 654 * Use this in legacy-style modules that probe hardware directly and 655 * register a single platform device and corresponding platform driver. 656 * 657 * Returns &struct platform_device pointer on success, or ERR_PTR() on error. 658 */ 659struct platform_device * __init_or_module __platform_create_bundle( 660 struct platform_driver *driver, 661 int (*probe)(struct platform_device *), 662 struct resource *res, unsigned int n_res, 663 const void *data, size_t size, struct module *module) 664{ 665 struct platform_device *pdev; 666 int error; 667 668 pdev = platform_device_alloc(driver->driver.name, -1); 669 if (!pdev) { 670 error = -ENOMEM; 671 goto err_out; 672 } 673 674 error = platform_device_add_resources(pdev, res, n_res); 675 if (error) 676 goto err_pdev_put; 677 678 error = platform_device_add_data(pdev, data, size); 679 if (error) 680 goto err_pdev_put; 681 682 error = platform_device_add(pdev); 683 if (error) 684 goto err_pdev_put; 685 686 error = __platform_driver_probe(driver, probe, module); 687 if (error) 688 goto err_pdev_del; 689 690 return pdev; 691 692err_pdev_del: 693 platform_device_del(pdev); 694err_pdev_put: 695 platform_device_put(pdev); 696err_out: 697 return ERR_PTR(error); 698} 699EXPORT_SYMBOL_GPL(__platform_create_bundle); 700 701/* modalias support enables more hands-off userspace setup: 702 * (a) environment variable lets new-style hotplug events work once system is 703 * fully running: "modprobe $MODALIAS" 704 * (b) sysfs attribute lets new-style coldplug recover from hotplug events 705 * mishandled before system is fully running: "modprobe $(cat modalias)" 706 */ 707static ssize_t modalias_show(struct device *dev, struct device_attribute *a, 708 char *buf) 709{ 710 struct platform_device *pdev = to_platform_device(dev); 711 int len; 712 713 len = of_device_get_modalias(dev, buf, PAGE_SIZE -1); 714 if (len != -ENODEV) 715 return len; 716 717 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1); 718 if (len != -ENODEV) 719 return len; 720 721 len = snprintf(buf, PAGE_SIZE, "platform:%s\n", pdev->name); 722 723 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len; 724} 725static DEVICE_ATTR_RO(modalias); 726 727static ssize_t driver_override_store(struct device *dev, 728 struct device_attribute *attr, 729 const char *buf, size_t count) 730{ 731 struct platform_device *pdev = to_platform_device(dev); 732 char *driver_override, *old = pdev->driver_override, *cp; 733 734 if (count > PATH_MAX) 735 return -EINVAL; 736 737 driver_override = kstrndup(buf, count, GFP_KERNEL); 738 if (!driver_override) 739 return -ENOMEM; 740 741 cp = strchr(driver_override, '\n'); 742 if (cp) 743 *cp = '\0'; 744 745 if (strlen(driver_override)) { 746 pdev->driver_override = driver_override; 747 } else { 748 kfree(driver_override); 749 pdev->driver_override = NULL; 750 } 751 752 kfree(old); 753 754 return count; 755} 756 757static ssize_t driver_override_show(struct device *dev, 758 struct device_attribute *attr, char *buf) 759{ 760 struct platform_device *pdev = to_platform_device(dev); 761 762 return sprintf(buf, "%s\n", pdev->driver_override); 763} 764static DEVICE_ATTR_RW(driver_override); 765 766 767static struct attribute *platform_dev_attrs[] = { 768 &dev_attr_modalias.attr, 769 &dev_attr_driver_override.attr, 770 NULL, 771}; 772ATTRIBUTE_GROUPS(platform_dev); 773 774static int platform_uevent(struct device *dev, struct kobj_uevent_env *env) 775{ 776 struct platform_device *pdev = to_platform_device(dev); 777 int rc; 778 779 /* Some devices have extra OF data and an OF-style MODALIAS */ 780 rc = of_device_uevent_modalias(dev, env); 781 if (rc != -ENODEV) 782 return rc; 783 784 rc = acpi_device_uevent_modalias(dev, env); 785 if (rc != -ENODEV) 786 return rc; 787 788 add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX, 789 pdev->name); 790 return 0; 791} 792 793static const struct platform_device_id *platform_match_id( 794 const struct platform_device_id *id, 795 struct platform_device *pdev) 796{ 797 while (id->name[0]) { 798 if (strcmp(pdev->name, id->name) == 0) { 799 pdev->id_entry = id; 800 return id; 801 } 802 id++; 803 } 804 return NULL; 805} 806 807/** 808 * platform_match - bind platform device to platform driver. 809 * @dev: device. 810 * @drv: driver. 811 * 812 * Platform device IDs are assumed to be encoded like this: 813 * "<name><instance>", where <name> is a short description of the type of 814 * device, like "pci" or "floppy", and <instance> is the enumerated 815 * instance of the device, like '0' or '42'. Driver IDs are simply 816 * "<name>". So, extract the <name> from the platform_device structure, 817 * and compare it against the name of the driver. Return whether they match 818 * or not. 819 */ 820static int platform_match(struct device *dev, struct device_driver *drv) 821{ 822 struct platform_device *pdev = to_platform_device(dev); 823 struct platform_driver *pdrv = to_platform_driver(drv); 824 825 /* When driver_override is set, only bind to the matching driver */ 826 if (pdev->driver_override) 827 return !strcmp(pdev->driver_override, drv->name); 828 829 /* Attempt an OF style match first */ 830 if (of_driver_match_device(dev, drv)) 831 return 1; 832 833 /* Then try ACPI style match */ 834 if (acpi_driver_match_device(dev, drv)) 835 return 1; 836 837 /* Then try to match against the id table */ 838 if (pdrv->id_table) 839 return platform_match_id(pdrv->id_table, pdev) != NULL; 840 841 /* fall-back to driver name match */ 842 return (strcmp(pdev->name, drv->name) == 0); 843} 844 845#ifdef CONFIG_PM_SLEEP 846 847static int platform_legacy_suspend(struct device *dev, pm_message_t mesg) 848{ 849 struct platform_driver *pdrv = to_platform_driver(dev->driver); 850 struct platform_device *pdev = to_platform_device(dev); 851 int ret = 0; 852 853 if (dev->driver && pdrv->suspend) 854 ret = pdrv->suspend(pdev, mesg); 855 856 return ret; 857} 858 859static int platform_legacy_resume(struct device *dev) 860{ 861 struct platform_driver *pdrv = to_platform_driver(dev->driver); 862 struct platform_device *pdev = to_platform_device(dev); 863 int ret = 0; 864 865 if (dev->driver && pdrv->resume) 866 ret = pdrv->resume(pdev); 867 868 return ret; 869} 870 871#endif /* CONFIG_PM_SLEEP */ 872 873#ifdef CONFIG_SUSPEND 874 875int platform_pm_suspend(struct device *dev) 876{ 877 struct device_driver *drv = dev->driver; 878 int ret = 0; 879 880 if (!drv) 881 return 0; 882 883 if (drv->pm) { 884 if (drv->pm->suspend) 885 ret = drv->pm->suspend(dev); 886 } else { 887 ret = platform_legacy_suspend(dev, PMSG_SUSPEND); 888 } 889 890 return ret; 891} 892 893int platform_pm_resume(struct device *dev) 894{ 895 struct device_driver *drv = dev->driver; 896 int ret = 0; 897 898 if (!drv) 899 return 0; 900 901 if (drv->pm) { 902 if (drv->pm->resume) 903 ret = drv->pm->resume(dev); 904 } else { 905 ret = platform_legacy_resume(dev); 906 } 907 908 return ret; 909} 910 911#endif /* CONFIG_SUSPEND */ 912 913#ifdef CONFIG_HIBERNATE_CALLBACKS 914 915int platform_pm_freeze(struct device *dev) 916{ 917 struct device_driver *drv = dev->driver; 918 int ret = 0; 919 920 if (!drv) 921 return 0; 922 923 if (drv->pm) { 924 if (drv->pm->freeze) 925 ret = drv->pm->freeze(dev); 926 } else { 927 ret = platform_legacy_suspend(dev, PMSG_FREEZE); 928 } 929 930 return ret; 931} 932 933int platform_pm_thaw(struct device *dev) 934{ 935 struct device_driver *drv = dev->driver; 936 int ret = 0; 937 938 if (!drv) 939 return 0; 940 941 if (drv->pm) { 942 if (drv->pm->thaw) 943 ret = drv->pm->thaw(dev); 944 } else { 945 ret = platform_legacy_resume(dev); 946 } 947 948 return ret; 949} 950 951int platform_pm_poweroff(struct device *dev) 952{ 953 struct device_driver *drv = dev->driver; 954 int ret = 0; 955 956 if (!drv) 957 return 0; 958 959 if (drv->pm) { 960 if (drv->pm->poweroff) 961 ret = drv->pm->poweroff(dev); 962 } else { 963 ret = platform_legacy_suspend(dev, PMSG_HIBERNATE); 964 } 965 966 return ret; 967} 968 969int platform_pm_restore(struct device *dev) 970{ 971 struct device_driver *drv = dev->driver; 972 int ret = 0; 973 974 if (!drv) 975 return 0; 976 977 if (drv->pm) { 978 if (drv->pm->restore) 979 ret = drv->pm->restore(dev); 980 } else { 981 ret = platform_legacy_resume(dev); 982 } 983 984 return ret; 985} 986 987#endif /* CONFIG_HIBERNATE_CALLBACKS */ 988 989static const struct dev_pm_ops platform_dev_pm_ops = { 990 .runtime_suspend = pm_generic_runtime_suspend, 991 .runtime_resume = pm_generic_runtime_resume, 992 USE_PLATFORM_PM_SLEEP_OPS 993}; 994 995struct bus_type platform_bus_type = { 996 .name = "platform", 997 .dev_groups = platform_dev_groups, 998 .match = platform_match, 999 .uevent = platform_uevent, 1000 .pm = &platform_dev_pm_ops, 1001}; 1002EXPORT_SYMBOL_GPL(platform_bus_type); 1003 1004int __init platform_bus_init(void) 1005{ 1006 int error; 1007 1008 early_platform_cleanup(); 1009 1010 error = device_register(&platform_bus); 1011 if (error) 1012 return error; 1013 error = bus_register(&platform_bus_type); 1014 if (error) 1015 device_unregister(&platform_bus); 1016 of_platform_register_reconfig_notifier(); 1017 return error; 1018} 1019 1020#ifndef ARCH_HAS_DMA_GET_REQUIRED_MASK 1021u64 dma_get_required_mask(struct device *dev) 1022{ 1023 u32 low_totalram = ((max_pfn - 1) << PAGE_SHIFT); 1024 u32 high_totalram = ((max_pfn - 1) >> (32 - PAGE_SHIFT)); 1025 u64 mask; 1026 1027 if (!high_totalram) { 1028 /* convert to mask just covering totalram */ 1029 low_totalram = (1 << (fls(low_totalram) - 1)); 1030 low_totalram += low_totalram - 1; 1031 mask = low_totalram; 1032 } else { 1033 high_totalram = (1 << (fls(high_totalram) - 1)); 1034 high_totalram += high_totalram - 1; 1035 mask = (((u64)high_totalram) << 32) + 0xffffffff; 1036 } 1037 return mask; 1038} 1039EXPORT_SYMBOL_GPL(dma_get_required_mask); 1040#endif 1041 1042static __initdata LIST_HEAD(early_platform_driver_list); 1043static __initdata LIST_HEAD(early_platform_device_list); 1044 1045/** 1046 * early_platform_driver_register - register early platform driver 1047 * @epdrv: early_platform driver structure 1048 * @buf: string passed from early_param() 1049 * 1050 * Helper function for early_platform_init() / early_platform_init_buffer() 1051 */ 1052int __init early_platform_driver_register(struct early_platform_driver *epdrv, 1053 char *buf) 1054{ 1055 char *tmp; 1056 int n; 1057 1058 /* Simply add the driver to the end of the global list. 1059 * Drivers will by default be put on the list in compiled-in order. 1060 */ 1061 if (!epdrv->list.next) { 1062 INIT_LIST_HEAD(&epdrv->list); 1063 list_add_tail(&epdrv->list, &early_platform_driver_list); 1064 } 1065 1066 /* If the user has specified device then make sure the driver 1067 * gets prioritized. The driver of the last device specified on 1068 * command line will be put first on the list. 1069 */ 1070 n = strlen(epdrv->pdrv->driver.name); 1071 if (buf && !strncmp(buf, epdrv->pdrv->driver.name, n)) { 1072 list_move(&epdrv->list, &early_platform_driver_list); 1073 1074 /* Allow passing parameters after device name */ 1075 if (buf[n] == '\0' || buf[n] == ',') 1076 epdrv->requested_id = -1; 1077 else { 1078 epdrv->requested_id = simple_strtoul(&buf[n + 1], 1079 &tmp, 10); 1080 1081 if (buf[n] != '.' || (tmp == &buf[n + 1])) { 1082 epdrv->requested_id = EARLY_PLATFORM_ID_ERROR; 1083 n = 0; 1084 } else 1085 n += strcspn(&buf[n + 1], ",") + 1; 1086 } 1087 1088 if (buf[n] == ',') 1089 n++; 1090 1091 if (epdrv->bufsize) { 1092 memcpy(epdrv->buffer, &buf[n], 1093 min_t(int, epdrv->bufsize, strlen(&buf[n]) + 1)); 1094 epdrv->buffer[epdrv->bufsize - 1] = '\0'; 1095 } 1096 } 1097 1098 return 0; 1099} 1100 1101/** 1102 * early_platform_add_devices - adds a number of early platform devices 1103 * @devs: array of early platform devices to add 1104 * @num: number of early platform devices in array 1105 * 1106 * Used by early architecture code to register early platform devices and 1107 * their platform data. 1108 */ 1109void __init early_platform_add_devices(struct platform_device **devs, int num) 1110{ 1111 struct device *dev; 1112 int i; 1113 1114 /* simply add the devices to list */ 1115 for (i = 0; i < num; i++) { 1116 dev = &devs[i]->dev; 1117 1118 if (!dev->devres_head.next) { 1119 pm_runtime_early_init(dev); 1120 INIT_LIST_HEAD(&dev->devres_head); 1121 list_add_tail(&dev->devres_head, 1122 &early_platform_device_list); 1123 } 1124 } 1125} 1126 1127/** 1128 * early_platform_driver_register_all - register early platform drivers 1129 * @class_str: string to identify early platform driver class 1130 * 1131 * Used by architecture code to register all early platform drivers 1132 * for a certain class. If omitted then only early platform drivers 1133 * with matching kernel command line class parameters will be registered. 1134 */ 1135void __init early_platform_driver_register_all(char *class_str) 1136{ 1137 /* The "class_str" parameter may or may not be present on the kernel 1138 * command line. If it is present then there may be more than one 1139 * matching parameter. 1140 * 1141 * Since we register our early platform drivers using early_param() 1142 * we need to make sure that they also get registered in the case 1143 * when the parameter is missing from the kernel command line. 1144 * 1145 * We use parse_early_options() to make sure the early_param() gets 1146 * called at least once. The early_param() may be called more than 1147 * once since the name of the preferred device may be specified on 1148 * the kernel command line. early_platform_driver_register() handles 1149 * this case for us. 1150 */ 1151 parse_early_options(class_str); 1152} 1153 1154/** 1155 * early_platform_match - find early platform device matching driver 1156 * @epdrv: early platform driver structure 1157 * @id: id to match against 1158 */ 1159static struct platform_device * __init 1160early_platform_match(struct early_platform_driver *epdrv, int id) 1161{ 1162 struct platform_device *pd; 1163 1164 list_for_each_entry(pd, &early_platform_device_list, dev.devres_head) 1165 if (platform_match(&pd->dev, &epdrv->pdrv->driver)) 1166 if (pd->id == id) 1167 return pd; 1168 1169 return NULL; 1170} 1171 1172/** 1173 * early_platform_left - check if early platform driver has matching devices 1174 * @epdrv: early platform driver structure 1175 * @id: return true if id or above exists 1176 */ 1177static int __init early_platform_left(struct early_platform_driver *epdrv, 1178 int id) 1179{ 1180 struct platform_device *pd; 1181 1182 list_for_each_entry(pd, &early_platform_device_list, dev.devres_head) 1183 if (platform_match(&pd->dev, &epdrv->pdrv->driver)) 1184 if (pd->id >= id) 1185 return 1; 1186 1187 return 0; 1188} 1189 1190/** 1191 * early_platform_driver_probe_id - probe drivers matching class_str and id 1192 * @class_str: string to identify early platform driver class 1193 * @id: id to match against 1194 * @nr_probe: number of platform devices to successfully probe before exiting 1195 */ 1196static int __init early_platform_driver_probe_id(char *class_str, 1197 int id, 1198 int nr_probe) 1199{ 1200 struct early_platform_driver *epdrv; 1201 struct platform_device *match; 1202 int match_id; 1203 int n = 0; 1204 int left = 0; 1205 1206 list_for_each_entry(epdrv, &early_platform_driver_list, list) { 1207 /* only use drivers matching our class_str */ 1208 if (strcmp(class_str, epdrv->class_str)) 1209 continue; 1210 1211 if (id == -2) { 1212 match_id = epdrv->requested_id; 1213 left = 1; 1214 1215 } else { 1216 match_id = id; 1217 left += early_platform_left(epdrv, id); 1218 1219 /* skip requested id */ 1220 switch (epdrv->requested_id) { 1221 case EARLY_PLATFORM_ID_ERROR: 1222 case EARLY_PLATFORM_ID_UNSET: 1223 break; 1224 default: 1225 if (epdrv->requested_id == id) 1226 match_id = EARLY_PLATFORM_ID_UNSET; 1227 } 1228 } 1229 1230 switch (match_id) { 1231 case EARLY_PLATFORM_ID_ERROR: 1232 pr_warn("%s: unable to parse %s parameter\n", 1233 class_str, epdrv->pdrv->driver.name); 1234 /* fall-through */ 1235 case EARLY_PLATFORM_ID_UNSET: 1236 match = NULL; 1237 break; 1238 default: 1239 match = early_platform_match(epdrv, match_id); 1240 } 1241 1242 if (match) { 1243 /* 1244 * Set up a sensible init_name to enable 1245 * dev_name() and others to be used before the 1246 * rest of the driver core is initialized. 1247 */ 1248 if (!match->dev.init_name && slab_is_available()) { 1249 if (match->id != -1) 1250 match->dev.init_name = 1251 kasprintf(GFP_KERNEL, "%s.%d", 1252 match->name, 1253 match->id); 1254 else 1255 match->dev.init_name = 1256 kasprintf(GFP_KERNEL, "%s", 1257 match->name); 1258 1259 if (!match->dev.init_name) 1260 return -ENOMEM; 1261 } 1262 1263 if (epdrv->pdrv->probe(match)) 1264 pr_warn("%s: unable to probe %s early.\n", 1265 class_str, match->name); 1266 else 1267 n++; 1268 } 1269 1270 if (n >= nr_probe) 1271 break; 1272 } 1273 1274 if (left) 1275 return n; 1276 else 1277 return -ENODEV; 1278} 1279 1280/** 1281 * early_platform_driver_probe - probe a class of registered drivers 1282 * @class_str: string to identify early platform driver class 1283 * @nr_probe: number of platform devices to successfully probe before exiting 1284 * @user_only: only probe user specified early platform devices 1285 * 1286 * Used by architecture code to probe registered early platform drivers 1287 * within a certain class. For probe to happen a registered early platform 1288 * device matching a registered early platform driver is needed. 1289 */ 1290int __init early_platform_driver_probe(char *class_str, 1291 int nr_probe, 1292 int user_only) 1293{ 1294 int k, n, i; 1295 1296 n = 0; 1297 for (i = -2; n < nr_probe; i++) { 1298 k = early_platform_driver_probe_id(class_str, i, nr_probe - n); 1299 1300 if (k < 0) 1301 break; 1302 1303 n += k; 1304 1305 if (user_only) 1306 break; 1307 } 1308 1309 return n; 1310} 1311 1312/** 1313 * early_platform_cleanup - clean up early platform code 1314 */ 1315void __init early_platform_cleanup(void) 1316{ 1317 struct platform_device *pd, *pd2; 1318 1319 /* clean up the devres list used to chain devices */ 1320 list_for_each_entry_safe(pd, pd2, &early_platform_device_list, 1321 dev.devres_head) { 1322 list_del(&pd->dev.devres_head); 1323 memset(&pd->dev.devres_head, 0, sizeof(pd->dev.devres_head)); 1324 } 1325} 1326 1327