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