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