개념 설명 전체 · v6.6 / drivers/base/platform.c
1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * platform.c - platform 'pseudo' bus for legacy devices 4 * 5 * Copyright (c) 2002-3 Patrick Mochel 6 * Copyright (c) 2002-3 Open Source Development Labs 7 * 8 * Please see Documentation/driver-api/driver-model/platform.rst for more 9 * information. 10 */ 11 12 #include <linux/string.h> 13 #include <linux/platform_device.h> 14 #include <linux/of_device.h> 15 #include <linux/of_irq.h> 16 #include <linux/module.h> 17 #include <linux/init.h> 18 #include <linux/interrupt.h> 19 #include <linux/ioport.h> 20 #include <linux/dma-mapping.h> 21 #include <linux/memblock.h> 22 #include <linux/err.h> 23 #include <linux/slab.h> 24 #include <linux/pm_runtime.h> 25 #include <linux/pm_domain.h> 26 #include <linux/idr.h> 27 #include <linux/acpi.h> 28 #include <linux/clk/clk-conf.h> 29 #include <linux/limits.h> 30 #include <linux/property.h> 31 #include <linux/kmemleak.h> 32 #include <linux/types.h> 33 #include <linux/iommu.h> 34 #include <linux/dma-map-ops.h> 35 36 #include "base.h" 37 #include "power/power.h" 38 39 /* For automatically allocated device IDs */ 40 static DEFINE_IDA(platform_devid_ida); 41 42 struct device platform_bus = { 43 .init_name = "platform", 44 }; 45 EXPORT_SYMBOL_GPL(platform_bus); 46 47 /** 48 * platform_get_resource - get a resource for a device 49 * @dev: platform device 50 * @type: resource type 51 * @num: resource index 52 * 53 * Return: a pointer to the resource or NULL on failure. 54 */ 55 struct resource *platform_get_resource(struct platform_device *dev, 56 unsigned int type, unsigned int num) 57 { 58 u32 i; 59 60 for (i = 0; i < dev->num_resources; i++) { 61 struct resource *r = &dev->resource[i]; 62 63 if (type == resource_type(r) && num-- == 0) 64 return r; 65 } 66 return NULL; 67 } 68 EXPORT_SYMBOL_GPL(platform_get_resource); 69 70 struct resource *platform_get_mem_or_io(struct platform_device *dev, 71 unsigned int num) 72 { 73 u32 i; 74 75 for (i = 0; i < dev->num_resources; i++) { 76 struct resource *r = &dev->resource[i]; 77 78 if ((resource_type(r) & (IORESOURCE_MEM|IORESOURCE_IO)) && num-- == 0) 79 return r; 80 } 81 return NULL; 82 } 83 EXPORT_SYMBOL_GPL(platform_get_mem_or_io); 84 85 #ifdef CONFIG_HAS_IOMEM 86 /** 87 * devm_platform_get_and_ioremap_resource - call devm_ioremap_resource() for a 88 * platform device and get resource 89 * 90 * @pdev: platform device to use both for memory resource lookup as well as 91 * resource management 92 * @index: resource index 93 * @res: optional output parameter to store a pointer to the obtained resource. 94 * 95 * Return: a pointer to the remapped memory or an ERR_PTR() encoded error code 96 * on failure. 97 */ 98 void __iomem * 99 devm_platform_get_and_ioremap_resource(struct platform_device *pdev, 100 unsigned int index, struct resource **res) 101 { 102 struct resource *r; 103 104 r = platform_get_resource(pdev, IORESOURCE_MEM, index); 105 if (res) 106 *res = r; 107 return devm_ioremap_resource(&pdev->dev, r); 108 } 109 EXPORT_SYMBOL_GPL(devm_platform_get_and_ioremap_resource); 110 111 /** 112 * devm_platform_ioremap_resource - call devm_ioremap_resource() for a platform 113 * device 114 * 115 * @pdev: platform device to use both for memory resource lookup as well as 116 * resource management 117 * @index: resource index 118 * 119 * Return: a pointer to the remapped memory or an ERR_PTR() encoded error code 120 * on failure. 121 */ 122 void __iomem *devm_platform_ioremap_resource(struct platform_device *pdev, 123 unsigned int index) 124 { 125 return devm_platform_get_and_ioremap_resource(pdev, index, NULL); 126 } 127 EXPORT_SYMBOL_GPL(devm_platform_ioremap_resource); 128 129 /** 130 * devm_platform_ioremap_resource_byname - call devm_ioremap_resource for 131 * a platform device, retrieve the 132 * resource by name 133 * 134 * @pdev: platform device to use both for memory resource lookup as well as 135 * resource management 136 * @name: name of the resource 137 * 138 * Return: a pointer to the remapped memory or an ERR_PTR() encoded error code 139 * on failure. 140 */ 141 void __iomem * 142 devm_platform_ioremap_resource_byname(struct platform_device *pdev, 143 const char *name) 144 { 145 struct resource *res; 146 147 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name); 148 return devm_ioremap_resource(&pdev->dev, res); 149 } 150 EXPORT_SYMBOL_GPL(devm_platform_ioremap_resource_byname); 151 #endif /* CONFIG_HAS_IOMEM */ 152 153 /** 154 * platform_get_irq_optional - get an optional IRQ for a device 155 * @dev: platform device 156 * @num: IRQ number index 157 * 158 * Gets an IRQ for a platform device. Device drivers should check the return 159 * value for errors so as to not pass a negative integer value to the 160 * request_irq() APIs. This is the same as platform_get_irq(), except that it 161 * does not print an error message if an IRQ can not be obtained. 162 * 163 * For example:: 164 * 165 * int irq = platform_get_irq_optional(pdev, 0); 166 * if (irq < 0) 167 * return irq; 168 * 169 * Return: non-zero IRQ number on success, negative error number on failure. 170 */ 171 int platform_get_irq_optional(struct platform_device *dev, unsigned int num) 172 { 173 int ret; 174 #ifdef CONFIG_SPARC 175 /* sparc does not have irqs represented as IORESOURCE_IRQ resources */ 176 if (!dev || num >= dev->archdata.num_irqs) 177 goto out_not_found; 178 ret = dev->archdata.irqs[num]; 179 goto out; 180 #else 181 struct resource *r; 182 183 if (IS_ENABLED(CONFIG_OF_IRQ) && dev->dev.of_node) { 184 ret = of_irq_get(dev->dev.of_node, num); 185 if (ret > 0 || ret == -EPROBE_DEFER) 186 goto out; 187 } 188 189 r = platform_get_resource(dev, IORESOURCE_IRQ, num); 190 if (has_acpi_companion(&dev->dev)) { 191 if (r && r->flags & IORESOURCE_DISABLED) { 192 ret = acpi_irq_get(ACPI_HANDLE(&dev->dev), num, r); 193 if (ret) 194 goto out; 195 } 196 } 197 198 /* 199 * The resources may pass trigger flags to the irqs that need 200 * to be set up. It so happens that the trigger flags for 201 * IORESOURCE_BITS correspond 1-to-1 to the IRQF_TRIGGER* 202 * settings. 203 */ 204 if (r && r->flags & IORESOURCE_BITS) { 205 struct irq_data *irqd; 206 207 irqd = irq_get_irq_data(r->start); 208 if (!irqd) 209 goto out_not_found; 210 irqd_set_trigger_type(irqd, r->flags & IORESOURCE_BITS); 211 } 212 213 if (r) { 214 ret = r->start; 215 goto out; 216 } 217 218 /* 219 * For the index 0 interrupt, allow falling back to GpioInt 220 * resources. While a device could have both Interrupt and GpioInt 221 * resources, making this fallback ambiguous, in many common cases 222 * the device will only expose one IRQ, and this fallback 223 * allows a common code path across either kind of resource. 224 */ 225 if (num == 0 && has_acpi_companion(&dev->dev)) { 226 ret = acpi_dev_gpio_irq_get(ACPI_COMPANION(&dev->dev), num); 227 /* Our callers expect -ENXIO for missing IRQs. */ 228 if (ret >= 0 || ret == -EPROBE_DEFER) 229 goto out; 230 } 231 232 #endif 233 out_not_found: 234 ret = -ENXIO; 235 out: 236 if (WARN(!ret, "0 is an invalid IRQ number\n")) 237 return -EINVAL; 238 return ret; 239 } 240 EXPORT_SYMBOL_GPL(platform_get_irq_optional); 241 242 /** 243 * platform_get_irq - get an IRQ for a device 244 * @dev: platform device 245 * @num: IRQ number index 246 * 247 * Gets an IRQ for a platform device and prints an error message if finding the 248 * IRQ fails. Device drivers should check the return value for errors so as to 249 * not pass a negative integer value to the request_irq() APIs. 250 * 251 * For example:: 252 * 253 * int irq = platform_get_irq(pdev, 0); 254 * if (irq < 0) 255 * return irq; 256 * 257 * Return: non-zero IRQ number on success, negative error number on failure. 258 */ 259 int platform_get_irq(struct platform_device *dev, unsigned int num) 260 { 261 int ret; 262 263 ret = platform_get_irq_optional(dev, num); 264 if (ret < 0) 265 return dev_err_probe(&dev->dev, ret, 266 "IRQ index %u not found\n", num); 267 268 return ret; 269 } 270 EXPORT_SYMBOL_GPL(platform_get_irq); 271 272 /** 273 * platform_irq_count - Count the number of IRQs a platform device uses 274 * @dev: platform device 275 * 276 * Return: Number of IRQs a platform device uses or EPROBE_DEFER 277 */ 278 int platform_irq_count(struct platform_device *dev) 279 { 280 int ret, nr = 0; 281 282 while ((ret = platform_get_irq_optional(dev, nr)) >= 0) 283 nr++; 284 285 if (ret == -EPROBE_DEFER) 286 return ret; 287 288 return nr; 289 } 290 EXPORT_SYMBOL_GPL(platform_irq_count); 291 292 struct irq_affinity_devres { 293 unsigned int count; 294 unsigned int irq[]; 295 }; 296 297 static void platform_disable_acpi_irq(struct platform_device *pdev, int index) 298 { 299 struct resource *r; 300 301 r = platform_get_resource(pdev, IORESOURCE_IRQ, index); 302 if (r) 303 irqresource_disabled(r, 0); 304 } 305 306 static void devm_platform_get_irqs_affinity_release(struct device *dev, 307 void *res) 308 { 309 struct irq_affinity_devres *ptr = res; 310 int i; 311 312 for (i = 0; i < ptr->count; i++) { 313 irq_dispose_mapping(ptr->irq[i]); 314 315 if (has_acpi_companion(dev)) 316 platform_disable_acpi_irq(to_platform_device(dev), i); 317 } 318 } 319 320 /** 321 * devm_platform_get_irqs_affinity - devm method to get a set of IRQs for a 322 * device using an interrupt affinity descriptor 323 * @dev: platform device pointer 324 * @affd: affinity descriptor 325 * @minvec: minimum count of interrupt vectors 326 * @maxvec: maximum count of interrupt vectors 327 * @irqs: pointer holder for IRQ numbers 328 * 329 * Gets a set of IRQs for a platform device, and updates IRQ afffinty according 330 * to the passed affinity descriptor 331 * 332 * Return: Number of vectors on success, negative error number on failure. 333 */ 334 int devm_platform_get_irqs_affinity(struct platform_device *dev, 335 struct irq_affinity *affd, 336 unsigned int minvec, 337 unsigned int maxvec, 338 int **irqs) 339 { 340 struct irq_affinity_devres *ptr; 341 struct irq_affinity_desc *desc; 342 size_t size; 343 int i, ret, nvec; 344 345 if (!affd) 346 return -EPERM; 347 348 if (maxvec < minvec) 349 return -ERANGE; 350 351 nvec = platform_irq_count(dev); 352 if (nvec < 0) 353 return nvec; 354 355 if (nvec < minvec) 356 return -ENOSPC; 357 358 nvec = irq_calc_affinity_vectors(minvec, nvec, affd); 359 if (nvec < minvec) 360 return -ENOSPC; 361 362 if (nvec > maxvec) 363 nvec = maxvec; 364 365 size = sizeof(*ptr) + sizeof(unsigned int) * nvec; 366 ptr = devres_alloc(devm_platform_get_irqs_affinity_release, size, 367 GFP_KERNEL); 368 if (!ptr) 369 return -ENOMEM; 370 371 ptr->count = nvec; 372 373 for (i = 0; i < nvec; i++) { 374 int irq = platform_get_irq(dev, i); 375 if (irq < 0) { 376 ret = irq; 377 goto err_free_devres; 378 } 379 ptr->irq[i] = irq; 380 } 381 382 desc = irq_create_affinity_masks(nvec, affd); 383 if (!desc) { 384 ret = -ENOMEM; 385 goto err_free_devres; 386 } 387 388 for (i = 0; i < nvec; i++) { 389 ret = irq_update_affinity_desc(ptr->irq[i], &desc[i]); 390 if (ret) { 391 dev_err(&dev->dev, "failed to update irq%d affinity descriptor (%d)\n", 392 ptr->irq[i], ret); 393 goto err_free_desc; 394 } 395 } 396 397 devres_add(&dev->dev, ptr); 398 399 kfree(desc); 400 401 *irqs = ptr->irq; 402 403 return nvec; 404 405 err_free_desc: 406 kfree(desc); 407 err_free_devres: 408 devres_free(ptr); 409 return ret; 410 } 411 EXPORT_SYMBOL_GPL(devm_platform_get_irqs_affinity); 412 413 /** 414 * platform_get_resource_byname - get a resource for a device by name 415 * @dev: platform device 416 * @type: resource type 417 * @name: resource name 418 */ 419 struct resource *platform_get_resource_byname(struct platform_device *dev, 420 unsigned int type, 421 const char *name) 422 { 423 u32 i; 424 425 for (i = 0; i < dev->num_resources; i++) { 426 struct resource *r = &dev->resource[i]; 427 428 if (unlikely(!r->name)) 429 continue; 430 431 if (type == resource_type(r) && !strcmp(r->name, name)) 432 return r; 433 } 434 return NULL; 435 } 436 EXPORT_SYMBOL_GPL(platform_get_resource_byname); 437 438 static int __platform_get_irq_byname(struct platform_device *dev, 439 const char *name) 440 { 441 struct resource *r; 442 int ret; 443 444 ret = fwnode_irq_get_byname(dev_fwnode(&dev->dev), name); 445 if (ret > 0 || ret == -EPROBE_DEFER) 446 return ret; 447 448 r = platform_get_resource_byname(dev, IORESOURCE_IRQ, name); 449 if (r) { 450 if (WARN(!r->start, "0 is an invalid IRQ number\n")) 451 return -EINVAL; 452 return r->start; 453 } 454 455 return -ENXIO; 456 } 457 458 /** 459 * platform_get_irq_byname - get an IRQ for a device by name 460 * @dev: platform device 461 * @name: IRQ name 462 * 463 * Get an IRQ like platform_get_irq(), but then by name rather then by index. 464 * 465 * Return: non-zero IRQ number on success, negative error number on failure. 466 */ 467 int platform_get_irq_byname(struct platform_device *dev, const char *name) 468 { 469 int ret; 470 471 ret = __platform_get_irq_byname(dev, name); 472 if (ret < 0) 473 return dev_err_probe(&dev->dev, ret, "IRQ %s not found\n", 474 name); 475 return ret; 476 } 477 EXPORT_SYMBOL_GPL(platform_get_irq_byname); 478 479 /** 480 * platform_get_irq_byname_optional - get an optional IRQ for a device by name 481 * @dev: platform device 482 * @name: IRQ name 483 * 484 * Get an optional IRQ by name like platform_get_irq_byname(). Except that it 485 * does not print an error message if an IRQ can not be obtained. 486 * 487 * Return: non-zero IRQ number on success, negative error number on failure. 488 */ 489 int platform_get_irq_byname_optional(struct platform_device *dev, 490 const char *name) 491 { 492 return __platform_get_irq_byname(dev, name); 493 } 494 EXPORT_SYMBOL_GPL(platform_get_irq_byname_optional); 495 496 /** 497 * platform_add_devices - add a numbers of platform devices 498 * @devs: array of platform devices to add 499 * @num: number of platform devices in array 500 * 501 * Return: 0 on success, negative error number on failure. 502 */ 503 int platform_add_devices(struct platform_device **devs, int num) 504 { 505 int i, ret = 0; 506 507 for (i = 0; i < num; i++) { 508 ret = platform_device_register(devs[i]); 509 if (ret) { 510 while (--i >= 0) 511 platform_device_unregister(devs[i]); 512 break; 513 } 514 } 515 516 return ret; 517 } 518 EXPORT_SYMBOL_GPL(platform_add_devices); 519 520 struct platform_object { 521 struct platform_device pdev; 522 char name[]; 523 }; 524 525 /* 526 * Set up default DMA mask for platform devices if the they weren't 527 * previously set by the architecture / DT. 528 */ 529 static void setup_pdev_dma_masks(struct platform_device *pdev) 530 { 531 pdev->dev.dma_parms = &pdev->dma_parms; 532 533 if (!pdev->dev.coherent_dma_mask) 534 pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32); 535 if (!pdev->dev.dma_mask) { 536 pdev->platform_dma_mask = DMA_BIT_MASK(32); 537 pdev->dev.dma_mask = &pdev->platform_dma_mask; 538 } 539 }; 540 541 /** 542 * platform_device_put - destroy a platform device 543 * @pdev: platform device to free 544 * 545 * Free all memory associated with a platform device. This function must 546 * _only_ be externally called in error cases. All other usage is a bug. 547 */ 548 void platform_device_put(struct platform_device *pdev) 549 { 550 if (!IS_ERR_OR_NULL(pdev)) 551 put_device(&pdev->dev); 552 } 553 EXPORT_SYMBOL_GPL(platform_device_put); 554 555 static void platform_device_release(struct device *dev) 556 { 557 struct platform_object *pa = container_of(dev, struct platform_object, 558 pdev.dev); 559 560 of_node_put(pa->pdev.dev.of_node); 561 kfree(pa->pdev.dev.platform_data); 562 kfree(pa->pdev.mfd_cell); 563 kfree(pa->pdev.resource); 564 kfree(pa->pdev.driver_override); 565 kfree(pa); 566 } 567 568 /** 569 * platform_device_alloc - create a platform device 570 * @name: base name of the device we're adding 571 * @id: instance id 572 * 573 * Create a platform device object which can have other objects attached 574 * to it, and which will have attached objects freed when it is released. 575 */ 576 struct platform_device *platform_device_alloc(const char *name, int id) 577 { 578 struct platform_object *pa; 579 580 pa = kzalloc(sizeof(*pa) + strlen(name) + 1, GFP_KERNEL); 581 if (pa) { 582 strcpy(pa->name, name); 583 pa->pdev.name = pa->name; 584 pa->pdev.id = id; 585 device_initialize(&pa->pdev.dev); 586 pa->pdev.dev.release = platform_device_release; 587 setup_pdev_dma_masks(&pa->pdev); 588 } 589 590 return pa ? &pa->pdev : NULL; 591 } 592 EXPORT_SYMBOL_GPL(platform_device_alloc); 593 594 /** 595 * platform_device_add_resources - add resources to a platform device 596 * @pdev: platform device allocated by platform_device_alloc to add resources to 597 * @res: set of resources that needs to be allocated for the device 598 * @num: number of resources 599 * 600 * Add a copy of the resources to the platform device. The memory 601 * associated with the resources will be freed when the platform device is 602 * released. 603 */ 604 int platform_device_add_resources(struct platform_device *pdev, 605 const struct resource *res, unsigned int num) 606 { 607 struct resource *r = NULL; 608 609 if (res) { 610 r = kmemdup(res, sizeof(struct resource) * num, GFP_KERNEL); 611 if (!r) 612 return -ENOMEM; 613 } 614 615 kfree(pdev->resource); 616 pdev->resource = r; 617 pdev->num_resources = num; 618 return 0; 619 } 620 EXPORT_SYMBOL_GPL(platform_device_add_resources); 621 622 /** 623 * platform_device_add_data - add platform-specific data to a platform device 624 * @pdev: platform device allocated by platform_device_alloc to add resources to 625 * @data: platform specific data for this platform device 626 * @size: size of platform specific data 627 * 628 * Add a copy of platform specific data to the platform device's 629 * platform_data pointer. The memory associated with the platform data 630 * will be freed when the platform device is released. 631 */ 632 int platform_device_add_data(struct platform_device *pdev, const void *data, 633 size_t size) 634 { 635 void *d = NULL; 636 637 if (data) { 638 d = kmemdup(data, size, GFP_KERNEL); 639 if (!d) 640 return -ENOMEM; 641 } 642 643 kfree(pdev->dev.platform_data); 644 pdev->dev.platform_data = d; 645 return 0; 646 } 647 EXPORT_SYMBOL_GPL(platform_device_add_data); 648 649 /** 650 * platform_device_add - add a platform device to device hierarchy 651 * @pdev: platform device we're adding 652 * 653 * This is part 2 of platform_device_register(), though may be called 654 * separately _iff_ pdev was allocated by platform_device_alloc(). 655 */ 656 int platform_device_add(struct platform_device *pdev) 657 { 658 u32 i; 659 int ret; 660 661 if (!pdev) 662 return -EINVAL; 663 664 if (!pdev->dev.parent) 665 pdev->dev.parent = &platform_bus; 666 667 pdev->dev.bus = &platform_bus_type; 668 669 switch (pdev->id) { 670 default: 671 dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id); 672 break; 673 case PLATFORM_DEVID_NONE: 674 dev_set_name(&pdev->dev, "%s", pdev->name); 675 break; 676 case PLATFORM_DEVID_AUTO: 677 /* 678 * Automatically allocated device ID. We mark it as such so 679 * that we remember it must be freed, and we append a suffix 680 * to avoid namespace collision with explicit IDs. 681 */ 682 ret = ida_alloc(&platform_devid_ida, GFP_KERNEL); 683 if (ret < 0) 684 goto err_out; 685 pdev->id = ret; 686 pdev->id_auto = true; 687 dev_set_name(&pdev->dev, "%s.%d.auto", pdev->name, pdev->id); 688 break; 689 } 690 691 for (i = 0; i < pdev->num_resources; i++) { 692 struct resource *p, *r = &pdev->resource[i]; 693 694 if (r->name == NULL) 695 r->name = dev_name(&pdev->dev); 696 697 p = r->parent; 698 if (!p) { 699 if (resource_type(r) == IORESOURCE_MEM) 700 p = &iomem_resource; 701 else if (resource_type(r) == IORESOURCE_IO) 702 p = &ioport_resource; 703 } 704 705 if (p) { 706 ret = insert_resource(p, r); 707 if (ret) { 708 dev_err(&pdev->dev, "failed to claim resource %d: %pR\n", i, r); 709 goto failed; 710 } 711 } 712 } 713 714 pr_debug("Registering platform device '%s'. Parent at %s\n", 715 dev_name(&pdev->dev), dev_name(pdev->dev.parent)); 716 717 ret = device_add(&pdev->dev); 718 if (ret == 0) 719 return ret; 720 721 failed: 722 if (pdev->id_auto) { 723 ida_free(&platform_devid_ida, pdev->id); 724 pdev->id = PLATFORM_DEVID_AUTO; 725 } 726 727 while (i--) { 728 struct resource *r = &pdev->resource[i]; 729 if (r->parent) 730 release_resource(r); 731 } 732 733 err_out: 734 return ret; 735 } 736 EXPORT_SYMBOL_GPL(platform_device_add); 737 738 /** 739 * platform_device_del - remove a platform-level device 740 * @pdev: platform device we're removing 741 * 742 * Note that this function will also release all memory- and port-based 743 * resources owned by the device (@dev->resource). This function must 744 * _only_ be externally called in error cases. All other usage is a bug. 745 */ 746 void platform_device_del(struct platform_device *pdev) 747 { 748 u32 i; 749 750 if (!IS_ERR_OR_NULL(pdev)) { 751 device_del(&pdev->dev); 752 753 if (pdev->id_auto) { 754 ida_free(&platform_devid_ida, pdev->id); 755 pdev->id = PLATFORM_DEVID_AUTO; 756 } 757 758 for (i = 0; i < pdev->num_resources; i++) { 759 struct resource *r = &pdev->resource[i]; 760 if (r->parent) 761 release_resource(r); 762 } 763 } 764 } 765 EXPORT_SYMBOL_GPL(platform_device_del); 766 767 /** 768 * platform_device_register - add a platform-level device 769 * @pdev: platform device we're adding 770 * 771 * NOTE: _Never_ directly free @pdev after calling this function, even if it 772 * returned an error! Always use platform_device_put() to give up the 773 * reference initialised in this function instead. 774 */ 775 int platform_device_register(struct platform_device *pdev) 776 { 777 device_initialize(&pdev->dev); 778 setup_pdev_dma_masks(pdev); 779 return platform_device_add(pdev); 780 } 781 EXPORT_SYMBOL_GPL(platform_device_register); 782 783 /** 784 * platform_device_unregister - unregister a platform-level device 785 * @pdev: platform device we're unregistering 786 * 787 * Unregistration is done in 2 steps. First we release all resources 788 * and remove it from the subsystem, then we drop reference count by 789 * calling platform_device_put(). 790 */ 791 void platform_device_unregister(struct platform_device *pdev) 792 { 793 platform_device_del(pdev); 794 platform_device_put(pdev); 795 } 796 EXPORT_SYMBOL_GPL(platform_device_unregister); 797 798 /** 799 * platform_device_register_full - add a platform-level device with 800 * resources and platform-specific data 801 * 802 * @pdevinfo: data used to create device 803 * 804 * Returns &struct platform_device pointer on success, or ERR_PTR() on error. 805 */ 806 struct platform_device *platform_device_register_full( 807 const struct platform_device_info *pdevinfo) 808 { 809 int ret; 810 struct platform_device *pdev; 811 812 pdev = platform_device_alloc(pdevinfo->name, pdevinfo->id); 813 if (!pdev) 814 return ERR_PTR(-ENOMEM); 815 816 pdev->dev.parent = pdevinfo->parent; 817 pdev->dev.fwnode = pdevinfo->fwnode; 818 pdev->dev.of_node = of_node_get(to_of_node(pdev->dev.fwnode)); 819 pdev->dev.of_node_reused = pdevinfo->of_node_reused; 820 821 if (pdevinfo->dma_mask) { 822 pdev->platform_dma_mask = pdevinfo->dma_mask; 823 pdev->dev.dma_mask = &pdev->platform_dma_mask; 824 pdev->dev.coherent_dma_mask = pdevinfo->dma_mask; 825 } 826 827 ret = platform_device_add_resources(pdev, 828 pdevinfo->res, pdevinfo->num_res); 829 if (ret) 830 goto err; 831 832 ret = platform_device_add_data(pdev, 833 pdevinfo->data, pdevinfo->size_data); 834 if (ret) 835 goto err; 836 837 if (pdevinfo->properties) { 838 ret = device_create_managed_software_node(&pdev->dev, 839 pdevinfo->properties, NULL); 840 if (ret) 841 goto err; 842 } 843 844 ret = platform_device_add(pdev); 845 if (ret) { 846 err: 847 ACPI_COMPANION_SET(&pdev->dev, NULL); 848 platform_device_put(pdev); 849 return ERR_PTR(ret); 850 } 851 852 return pdev; 853 } 854 EXPORT_SYMBOL_GPL(platform_device_register_full); 855 856 /** 857 * __platform_driver_register - register a driver for platform-level devices 858 * @drv: platform driver structure 859 * @owner: owning module/driver 860 */ 861 int __platform_driver_register(struct platform_driver *drv, 862 struct module *owner) 863 { 864 drv->driver.owner = owner; 865 drv->driver.bus = &platform_bus_type; 866 867 return driver_register(&drv->driver); 868 } 869 EXPORT_SYMBOL_GPL(__platform_driver_register); 870 871 /** 872 * platform_driver_unregister - unregister a driver for platform-level devices 873 * @drv: platform driver structure 874 */ 875 void platform_driver_unregister(struct platform_driver *drv) 876 { 877 driver_unregister(&drv->driver); 878 } 879 EXPORT_SYMBOL_GPL(platform_driver_unregister); 880 881 static int platform_probe_fail(struct platform_device *pdev) 882 { 883 return -ENXIO; 884 } 885 886 static int is_bound_to_driver(struct device *dev, void *driver) 887 { 888 if (dev->driver == driver) 889 return 1; 890 return 0; 891 } 892 893 /** 894 * __platform_driver_probe - register driver for non-hotpluggable device 895 * @drv: platform driver structure 896 * @probe: the driver probe routine, probably from an __init section 897 * @module: module which will be the owner of the driver 898 * 899 * Use this instead of platform_driver_register() when you know the device 900 * is not hotpluggable and has already been registered, and you want to 901 * remove its run-once probe() infrastructure from memory after the driver 902 * has bound to the device. 903 * 904 * One typical use for this would be with drivers for controllers integrated 905 * into system-on-chip processors, where the controller devices have been 906 * configured as part of board setup. 907 * 908 * Note that this is incompatible with deferred probing. 909 * 910 * Returns zero if the driver registered and bound to a device, else returns 911 * a negative error code and with the driver not registered. 912 */ 913 int __init_or_module __platform_driver_probe(struct platform_driver *drv, 914 int (*probe)(struct platform_device *), struct module *module) 915 { 916 int retval; 917 918 if (drv->driver.probe_type == PROBE_PREFER_ASYNCHRONOUS) { 919 pr_err("%s: drivers registered with %s can not be probed asynchronously\n", 920 drv->driver.name, __func__); 921 return -EINVAL; 922 } 923 924 /* 925 * We have to run our probes synchronously because we check if 926 * we find any devices to bind to and exit with error if there 927 * are any. 928 */ 929 drv->driver.probe_type = PROBE_FORCE_SYNCHRONOUS; 930 931 /* 932 * Prevent driver from requesting probe deferral to avoid further 933 * futile probe attempts. 934 */ 935 drv->prevent_deferred_probe = true; 936 937 /* make sure driver won't have bind/unbind attributes */ 938 drv->driver.suppress_bind_attrs = true; 939 940 /* temporary section violation during probe() */ 941 drv->probe = probe; 942 retval = __platform_driver_register(drv, module); 943 if (retval) 944 return retval; 945 946 /* Force all new probes of this driver to fail */ 947 drv->probe = platform_probe_fail; 948 949 /* Walk all platform devices and see if any actually bound to this driver. 950 * If not, return an error as the device should have done so by now. 951 */ 952 if (!bus_for_each_dev(&platform_bus_type, NULL, &drv->driver, is_bound_to_driver)) { 953 retval = -ENODEV; 954 platform_driver_unregister(drv); 955 } 956 957 return retval; 958 } 959 EXPORT_SYMBOL_GPL(__platform_driver_probe); 960 961 /** 962 * __platform_create_bundle - register driver and create corresponding device 963 * @driver: platform driver structure 964 * @probe: the driver probe routine, probably from an __init section 965 * @res: set of resources that needs to be allocated for the device 966 * @n_res: number of resources 967 * @data: platform specific data for this platform device 968 * @size: size of platform specific data 969 * @module: module which will be the owner of the driver 970 * 971 * Use this in legacy-style modules that probe hardware directly and 972 * register a single platform device and corresponding platform driver. 973 * 974 * Returns &struct platform_device pointer on success, or ERR_PTR() on error. 975 */ 976 struct platform_device * __init_or_module __platform_create_bundle( 977 struct platform_driver *driver, 978 int (*probe)(struct platform_device *), 979 struct resource *res, unsigned int n_res, 980 const void *data, size_t size, struct module *module) 981 { 982 struct platform_device *pdev; 983 int error; 984 985 pdev = platform_device_alloc(driver->driver.name, -1); 986 if (!pdev) { 987 error = -ENOMEM; 988 goto err_out; 989 } 990 991 error = platform_device_add_resources(pdev, res, n_res); 992 if (error) 993 goto err_pdev_put; 994 995 error = platform_device_add_data(pdev, data, size); 996 if (error) 997 goto err_pdev_put; 998 999 error = platform_device_add(pdev); 1000 if (error) 1001 goto err_pdev_put; 1002 1003 error = __platform_driver_probe(driver, probe, module); 1004 if (error) 1005 goto err_pdev_del; 1006 1007 return pdev; 1008 1009 err_pdev_del: 1010 platform_device_del(pdev); 1011 err_pdev_put: 1012 platform_device_put(pdev); 1013 err_out: 1014 return ERR_PTR(error); 1015 } 1016 EXPORT_SYMBOL_GPL(__platform_create_bundle); 1017 1018 /** 1019 * __platform_register_drivers - register an array of platform drivers 1020 * @drivers: an array of drivers to register 1021 * @count: the number of drivers to register 1022 * @owner: module owning the drivers 1023 * 1024 * Registers platform drivers specified by an array. On failure to register a 1025 * driver, all previously registered drivers will be unregistered. Callers of 1026 * this API should use platform_unregister_drivers() to unregister drivers in 1027 * the reverse order. 1028 * 1029 * Returns: 0 on success or a negative error code on failure. 1030 */ 1031 int __platform_register_drivers(struct platform_driver * const *drivers, 1032 unsigned int count, struct module *owner) 1033 { 1034 unsigned int i; 1035 int err; 1036 1037 for (i = 0; i < count; i++) { 1038 pr_debug("registering platform driver %ps\n", drivers[i]); 1039 1040 err = __platform_driver_register(drivers[i], owner); 1041 if (err < 0) { 1042 pr_err("failed to register platform driver %ps: %d\n", 1043 drivers[i], err); 1044 goto error; 1045 } 1046 } 1047 1048 return 0; 1049 1050 error: 1051 while (i--) { 1052 pr_debug("unregistering platform driver %ps\n", drivers[i]); 1053 platform_driver_unregister(drivers[i]); 1054 } 1055 1056 return err; 1057 } 1058 EXPORT_SYMBOL_GPL(__platform_register_drivers); 1059 1060 /** 1061 * platform_unregister_drivers - unregister an array of platform drivers 1062 * @drivers: an array of drivers to unregister 1063 * @count: the number of drivers to unregister 1064 * 1065 * Unregisters platform drivers specified by an array. This is typically used 1066 * to complement an earlier call to platform_register_drivers(). Drivers are 1067 * unregistered in the reverse order in which they were registered. 1068 */ 1069 void platform_unregister_drivers(struct platform_driver * const *drivers, 1070 unsigned int count) 1071 { 1072 while (count--) { 1073 pr_debug("unregistering platform driver %ps\n", drivers[count]); 1074 platform_driver_unregister(drivers[count]); 1075 } 1076 } 1077 EXPORT_SYMBOL_GPL(platform_unregister_drivers); 1078 1079 static const struct platform_device_id *platform_match_id( 1080 const struct platform_device_id *id, 1081 struct platform_device *pdev) 1082 { 1083 while (id->name[0]) { 1084 if (strcmp(pdev->name, id->name) == 0) { 1085 pdev->id_entry = id; 1086 return id; 1087 } 1088 id++; 1089 } 1090 return NULL; 1091 } 1092 1093 #ifdef CONFIG_PM_SLEEP 1094 1095 static int platform_legacy_suspend(struct device *dev, pm_message_t mesg) 1096 { 1097 struct platform_driver *pdrv = to_platform_driver(dev->driver); 1098 struct platform_device *pdev = to_platform_device(dev); 1099 int ret = 0; 1100 1101 if (dev->driver && pdrv->suspend) 1102 ret = pdrv->suspend(pdev, mesg); 1103 1104 return ret; 1105 } 1106 1107 static int platform_legacy_resume(struct device *dev) 1108 { 1109 struct platform_driver *pdrv = to_platform_driver(dev->driver); 1110 struct platform_device *pdev = to_platform_device(dev); 1111 int ret = 0; 1112 1113 if (dev->driver && pdrv->resume) 1114 ret = pdrv->resume(pdev); 1115 1116 return ret; 1117 } 1118 1119 #endif /* CONFIG_PM_SLEEP */ 1120 1121 #ifdef CONFIG_SUSPEND 1122 1123 int platform_pm_suspend(struct device *dev) 1124 { 1125 struct device_driver *drv = dev->driver; 1126 int ret = 0; 1127 1128 if (!drv) 1129 return 0; 1130 1131 if (drv->pm) { 1132 if (drv->pm->suspend) 1133 ret = drv->pm->suspend(dev); 1134 } else { 1135 ret = platform_legacy_suspend(dev, PMSG_SUSPEND); 1136 } 1137 1138 return ret; 1139 } 1140 1141 int platform_pm_resume(struct device *dev) 1142 { 1143 struct device_driver *drv = dev->driver; 1144 int ret = 0; 1145 1146 if (!drv) 1147 return 0; 1148 1149 if (drv->pm) { 1150 if (drv->pm->resume) 1151 ret = drv->pm->resume(dev); 1152 } else { 1153 ret = platform_legacy_resume(dev); 1154 } 1155 1156 return ret; 1157 } 1158 1159 #endif /* CONFIG_SUSPEND */ 1160 1161 #ifdef CONFIG_HIBERNATE_CALLBACKS 1162 1163 int platform_pm_freeze(struct device *dev) 1164 { 1165 struct device_driver *drv = dev->driver; 1166 int ret = 0; 1167 1168 if (!drv) 1169 return 0; 1170 1171 if (drv->pm) { 1172 if (drv->pm->freeze) 1173 ret = drv->pm->freeze(dev); 1174 } else { 1175 ret = platform_legacy_suspend(dev, PMSG_FREEZE); 1176 } 1177 1178 return ret; 1179 } 1180 1181 int platform_pm_thaw(struct device *dev) 1182 { 1183 struct device_driver *drv = dev->driver; 1184 int ret = 0; 1185 1186 if (!drv) 1187 return 0; 1188 1189 if (drv->pm) { 1190 if (drv->pm->thaw) 1191 ret = drv->pm->thaw(dev); 1192 } else { 1193 ret = platform_legacy_resume(dev); 1194 } 1195 1196 return ret; 1197 } 1198 1199 int platform_pm_poweroff(struct device *dev) 1200 { 1201 struct device_driver *drv = dev->driver; 1202 int ret = 0; 1203 1204 if (!drv) 1205 return 0; 1206 1207 if (drv->pm) { 1208 if (drv->pm->poweroff) 1209 ret = drv->pm->poweroff(dev); 1210 } else { 1211 ret = platform_legacy_suspend(dev, PMSG_HIBERNATE); 1212 } 1213 1214 return ret; 1215 } 1216 1217 int platform_pm_restore(struct device *dev) 1218 { 1219 struct device_driver *drv = dev->driver; 1220 int ret = 0; 1221 1222 if (!drv) 1223 return 0; 1224 1225 if (drv->pm) { 1226 if (drv->pm->restore) 1227 ret = drv->pm->restore(dev); 1228 } else { 1229 ret = platform_legacy_resume(dev); 1230 } 1231 1232 return ret; 1233 } 1234 1235 #endif /* CONFIG_HIBERNATE_CALLBACKS */ 1236 1237 /* modalias support enables more hands-off userspace setup: 1238 * (a) environment variable lets new-style hotplug events work once system is 1239 * fully running: "modprobe $MODALIAS" 1240 * (b) sysfs attribute lets new-style coldplug recover from hotplug events 1241 * mishandled before system is fully running: "modprobe $(cat modalias)" 1242 */ 1243 static ssize_t modalias_show(struct device *dev, 1244 struct device_attribute *attr, char *buf) 1245 { 1246 struct platform_device *pdev = to_platform_device(dev); 1247 int len; 1248 1249 len = of_device_modalias(dev, buf, PAGE_SIZE); 1250 if (len != -ENODEV) 1251 return len; 1252 1253 len = acpi_device_modalias(dev, buf, PAGE_SIZE - 1); 1254 if (len != -ENODEV) 1255 return len; 1256 1257 return sysfs_emit(buf, "platform:%s\n", pdev->name); 1258 } 1259 static DEVICE_ATTR_RO(modalias); 1260 1261 static ssize_t numa_node_show(struct device *dev, 1262 struct device_attribute *attr, char *buf) 1263 { 1264 return sysfs_emit(buf, "%d\n", dev_to_node(dev)); 1265 } 1266 static DEVICE_ATTR_RO(numa_node); 1267 1268 static ssize_t driver_override_show(struct device *dev, 1269 struct device_attribute *attr, char *buf) 1270 { 1271 struct platform_device *pdev = to_platform_device(dev); 1272 ssize_t len; 1273 1274 device_lock(dev); 1275 len = sysfs_emit(buf, "%s\n", pdev->driver_override); 1276 device_unlock(dev); 1277 1278 return len; 1279 } 1280 1281 static ssize_t driver_override_store(struct device *dev, 1282 struct device_attribute *attr, 1283 const char *buf, size_t count) 1284 { 1285 struct platform_device *pdev = to_platform_device(dev); 1286 int ret; 1287 1288 ret = driver_set_override(dev, &pdev->driver_override, buf, count); 1289 if (ret) 1290 return ret; 1291 1292 return count; 1293 } 1294 static DEVICE_ATTR_RW(driver_override); 1295 1296 static struct attribute *platform_dev_attrs[] = { 1297 &dev_attr_modalias.attr, 1298 &dev_attr_numa_node.attr, 1299 &dev_attr_driver_override.attr, 1300 NULL, 1301 }; 1302 1303 static umode_t platform_dev_attrs_visible(struct kobject *kobj, struct attribute *a, 1304 int n) 1305 { 1306 struct device *dev = container_of(kobj, typeof(*dev), kobj); 1307 1308 if (a == &dev_attr_numa_node.attr && 1309 dev_to_node(dev) == NUMA_NO_NODE) 1310 return 0; 1311 1312 return a->mode; 1313 } 1314 1315 static const struct attribute_group platform_dev_group = { 1316 .attrs = platform_dev_attrs, 1317 .is_visible = platform_dev_attrs_visible, 1318 }; 1319 __ATTRIBUTE_GROUPS(platform_dev); 1320 1321 1322 /** 1323 * platform_match - bind platform device to platform driver. 1324 * @dev: device. 1325 * @drv: driver. 1326 * 1327 * Platform device IDs are assumed to be encoded like this: 1328 * "<name><instance>", where <name> is a short description of the type of 1329 * device, like "pci" or "floppy", and <instance> is the enumerated 1330 * instance of the device, like '0' or '42'. Driver IDs are simply 1331 * "<name>". So, extract the <name> from the platform_device structure, 1332 * and compare it against the name of the driver. Return whether they match 1333 * or not. 1334 */ 1335 static int platform_match(struct device *dev, struct device_driver *drv) 1336 { 1337 struct platform_device *pdev = to_platform_device(dev); 1338 struct platform_driver *pdrv = to_platform_driver(drv); 1339 1340 /* When driver_override is set, only bind to the matching driver */ 1341 if (pdev->driver_override) 1342 return !strcmp(pdev->driver_override, drv->name); 1343 1344 /* Attempt an OF style match first */ 1345 if (of_driver_match_device(dev, drv)) 1346 return 1; 1347 1348 /* Then try ACPI style match */ 1349 if (acpi_driver_match_device(dev, drv)) 1350 return 1; 1351 1352 /* Then try to match against the id table */ 1353 if (pdrv->id_table) 1354 return platform_match_id(pdrv->id_table, pdev) != NULL; 1355 1356 /* fall-back to driver name match */ 1357 return (strcmp(pdev->name, drv->name) == 0); 1358 } 1359 1360 static int platform_uevent(const struct device *dev, struct kobj_uevent_env *env) 1361 { 1362 const struct platform_device *pdev = to_platform_device(dev); 1363 int rc; 1364 1365 /* Some devices have extra OF data and an OF-style MODALIAS */ 1366 rc = of_device_uevent_modalias(dev, env); 1367 if (rc != -ENODEV) 1368 return rc; 1369 1370 rc = acpi_device_uevent_modalias(dev, env); 1371 if (rc != -ENODEV) 1372 return rc; 1373 1374 add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX, 1375 pdev->name); 1376 return 0; 1377 } 1378 1379 static int platform_probe(struct device *_dev) 1380 { 1381 struct platform_driver *drv = to_platform_driver(_dev->driver); 1382 struct platform_device *dev = to_platform_device(_dev); 1383 int ret; 1384 1385 /* 1386 * A driver registered using platform_driver_probe() cannot be bound 1387 * again later because the probe function usually lives in __init code 1388 * and so is gone. For these drivers .probe is set to 1389 * platform_probe_fail in __platform_driver_probe(). Don't even prepare 1390 * clocks and PM domains for these to match the traditional behaviour. 1391 */ 1392 if (unlikely(drv->probe == platform_probe_fail)) 1393 return -ENXIO; 1394 1395 ret = of_clk_set_defaults(_dev->of_node, false); 1396 if (ret < 0) 1397 return ret; 1398 1399 ret = dev_pm_domain_attach(_dev, true); 1400 if (ret) 1401 goto out; 1402 1403 if (drv->probe) { 1404 ret = drv->probe(dev); 1405 if (ret) 1406 dev_pm_domain_detach(_dev, true); 1407 } 1408 1409 out: 1410 if (drv->prevent_deferred_probe && ret == -EPROBE_DEFER) { 1411 dev_warn(_dev, "probe deferral not supported\n"); 1412 ret = -ENXIO; 1413 } 1414 1415 return ret; 1416 } 1417 1418 static void platform_remove(struct device *_dev) 1419 { 1420 struct platform_driver *drv = to_platform_driver(_dev->driver); 1421 struct platform_device *dev = to_platform_device(_dev); 1422 1423 if (drv->remove_new) { 1424 drv->remove_new(dev); 1425 } else if (drv->remove) { 1426 int ret = drv->remove(dev); 1427 1428 if (ret) 1429 dev_warn(_dev, "remove callback returned a non-zero value. This will be ignored.\n"); 1430 } 1431 dev_pm_domain_detach(_dev, true); 1432 } 1433 1434 static void platform_shutdown(struct device *_dev) 1435 { 1436 struct platform_device *dev = to_platform_device(_dev); 1437 struct platform_driver *drv; 1438 1439 if (!_dev->driver) 1440 return; 1441 1442 drv = to_platform_driver(_dev->driver); 1443 if (drv->shutdown) 1444 drv->shutdown(dev); 1445 } 1446 1447 static int platform_dma_configure(struct device *dev) 1448 { 1449 struct platform_driver *drv = to_platform_driver(dev->driver); 1450 enum dev_dma_attr attr; 1451 int ret = 0; 1452 1453 if (dev->of_node) { 1454 ret = of_dma_configure(dev, dev->of_node, true); 1455 } else if (has_acpi_companion(dev)) { 1456 attr = acpi_get_dma_attr(to_acpi_device_node(dev->fwnode)); 1457 ret = acpi_dma_configure(dev, attr); 1458 } 1459 1460 if (!ret && !drv->driver_managed_dma) { 1461 ret = iommu_device_use_default_domain(dev); 1462 if (ret) 1463 arch_teardown_dma_ops(dev); 1464 } 1465 1466 return ret; 1467 } 1468 1469 static void platform_dma_cleanup(struct device *dev) 1470 { 1471 struct platform_driver *drv = to_platform_driver(dev->driver); 1472 1473 if (!drv->driver_managed_dma) 1474 iommu_device_unuse_default_domain(dev); 1475 } 1476 1477 static const struct dev_pm_ops platform_dev_pm_ops = { 1478 SET_RUNTIME_PM_OPS(pm_generic_runtime_suspend, pm_generic_runtime_resume, NULL) 1479 USE_PLATFORM_PM_SLEEP_OPS 1480 }; 1481 1482 struct bus_type platform_bus_type = { 1483 .name = "platform", 1484 .dev_groups = platform_dev_groups, 1485 .match = platform_match, 1486 .uevent = platform_uevent, 1487 .probe = platform_probe, 1488 .remove = platform_remove, 1489 .shutdown = platform_shutdown, 1490 .dma_configure = platform_dma_configure, 1491 .dma_cleanup = platform_dma_cleanup, 1492 .pm = &platform_dev_pm_ops, 1493 }; 1494 EXPORT_SYMBOL_GPL(platform_bus_type); 1495 1496 static inline int __platform_match(struct device *dev, const void *drv) 1497 { 1498 return platform_match(dev, (struct device_driver *)drv); 1499 } 1500 1501 /** 1502 * platform_find_device_by_driver - Find a platform device with a given 1503 * driver. 1504 * @start: The device to start the search from. 1505 * @drv: The device driver to look for. 1506 */ 1507 struct device *platform_find_device_by_driver(struct device *start, 1508 const struct device_driver *drv) 1509 { 1510 return bus_find_device(&platform_bus_type, start, drv, 1511 __platform_match); 1512 } 1513 EXPORT_SYMBOL_GPL(platform_find_device_by_driver); 1514 1515 void __weak __init early_platform_cleanup(void) { } 1516 1517 int __init platform_bus_init(void) 1518 { 1519 int error; 1520 1521 early_platform_cleanup(); 1522 1523 error = device_register(&platform_bus); 1524 if (error) { 1525 put_device(&platform_bus); 1526 return error; 1527 } 1528 error = bus_register(&platform_bus_type); 1529 if (error) 1530 device_unregister(&platform_bus); 1531 1532 return error; 1533 }