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