2 * linux/arch/arm/common/amba.c
4 * Copyright (C) 2003 Deep Blue Solutions Ltd, All Rights Reserved.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/device.h>
13 #include <linux/string.h>
14 #include <linux/slab.h>
17 #include <linux/pm_runtime.h>
18 #include <linux/amba/bus.h>
21 #include <asm/sizes.h>
23 #define to_amba_driver(d) container_of(d, struct amba_driver, drv)
25 static const struct amba_id
*
26 amba_lookup(const struct amba_id
*table
, struct amba_device
*dev
)
31 ret
= (dev
->periphid
& table
->mask
) == table
->id
;
37 return ret
? table
: NULL
;
40 static int amba_match(struct device
*dev
, struct device_driver
*drv
)
42 struct amba_device
*pcdev
= to_amba_device(dev
);
43 struct amba_driver
*pcdrv
= to_amba_driver(drv
);
45 return amba_lookup(pcdrv
->id_table
, pcdev
) != NULL
;
49 static int amba_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
51 struct amba_device
*pcdev
= to_amba_device(dev
);
54 retval
= add_uevent_var(env
, "AMBA_ID=%08x", pcdev
->periphid
);
58 #define amba_uevent NULL
61 #define amba_attr_func(name,fmt,arg...) \
62 static ssize_t name##_show(struct device *_dev, \
63 struct device_attribute *attr, char *buf) \
65 struct amba_device *dev = to_amba_device(_dev); \
66 return sprintf(buf, fmt, arg); \
69 #define amba_attr(name,fmt,arg...) \
70 amba_attr_func(name,fmt,arg) \
71 static DEVICE_ATTR(name, S_IRUGO, name##_show, NULL)
73 amba_attr_func(id
, "%08x\n", dev
->periphid
);
74 amba_attr(irq0
, "%u\n", dev
->irq
[0]);
75 amba_attr(irq1
, "%u\n", dev
->irq
[1]);
76 amba_attr_func(resource
, "\t%016llx\t%016llx\t%016lx\n",
77 (unsigned long long)dev
->res
.start
, (unsigned long long)dev
->res
.end
,
80 static struct device_attribute amba_dev_attrs
[] = {
86 #ifdef CONFIG_PM_SLEEP
88 static int amba_legacy_suspend(struct device
*dev
, pm_message_t mesg
)
90 struct amba_driver
*adrv
= to_amba_driver(dev
->driver
);
91 struct amba_device
*adev
= to_amba_device(dev
);
94 if (dev
->driver
&& adrv
->suspend
)
95 ret
= adrv
->suspend(adev
, mesg
);
100 static int amba_legacy_resume(struct device
*dev
)
102 struct amba_driver
*adrv
= to_amba_driver(dev
->driver
);
103 struct amba_device
*adev
= to_amba_device(dev
);
106 if (dev
->driver
&& adrv
->resume
)
107 ret
= adrv
->resume(adev
);
112 static int amba_pm_prepare(struct device
*dev
)
114 struct device_driver
*drv
= dev
->driver
;
117 if (drv
&& drv
->pm
&& drv
->pm
->prepare
)
118 ret
= drv
->pm
->prepare(dev
);
123 static void amba_pm_complete(struct device
*dev
)
125 struct device_driver
*drv
= dev
->driver
;
127 if (drv
&& drv
->pm
&& drv
->pm
->complete
)
128 drv
->pm
->complete(dev
);
131 #else /* !CONFIG_PM_SLEEP */
133 #define amba_pm_prepare NULL
134 #define amba_pm_complete NULL
136 #endif /* !CONFIG_PM_SLEEP */
138 #ifdef CONFIG_SUSPEND
140 static int amba_pm_suspend(struct device
*dev
)
142 struct device_driver
*drv
= dev
->driver
;
149 if (drv
->pm
->suspend
)
150 ret
= drv
->pm
->suspend(dev
);
152 ret
= amba_legacy_suspend(dev
, PMSG_SUSPEND
);
158 static int amba_pm_suspend_noirq(struct device
*dev
)
160 struct device_driver
*drv
= dev
->driver
;
167 if (drv
->pm
->suspend_noirq
)
168 ret
= drv
->pm
->suspend_noirq(dev
);
174 static int amba_pm_resume(struct device
*dev
)
176 struct device_driver
*drv
= dev
->driver
;
184 ret
= drv
->pm
->resume(dev
);
186 ret
= amba_legacy_resume(dev
);
192 static int amba_pm_resume_noirq(struct device
*dev
)
194 struct device_driver
*drv
= dev
->driver
;
201 if (drv
->pm
->resume_noirq
)
202 ret
= drv
->pm
->resume_noirq(dev
);
208 #else /* !CONFIG_SUSPEND */
210 #define amba_pm_suspend NULL
211 #define amba_pm_resume NULL
212 #define amba_pm_suspend_noirq NULL
213 #define amba_pm_resume_noirq NULL
215 #endif /* !CONFIG_SUSPEND */
217 #ifdef CONFIG_HIBERNATE_CALLBACKS
219 static int amba_pm_freeze(struct device
*dev
)
221 struct device_driver
*drv
= dev
->driver
;
229 ret
= drv
->pm
->freeze(dev
);
231 ret
= amba_legacy_suspend(dev
, PMSG_FREEZE
);
237 static int amba_pm_freeze_noirq(struct device
*dev
)
239 struct device_driver
*drv
= dev
->driver
;
246 if (drv
->pm
->freeze_noirq
)
247 ret
= drv
->pm
->freeze_noirq(dev
);
253 static int amba_pm_thaw(struct device
*dev
)
255 struct device_driver
*drv
= dev
->driver
;
263 ret
= drv
->pm
->thaw(dev
);
265 ret
= amba_legacy_resume(dev
);
271 static int amba_pm_thaw_noirq(struct device
*dev
)
273 struct device_driver
*drv
= dev
->driver
;
280 if (drv
->pm
->thaw_noirq
)
281 ret
= drv
->pm
->thaw_noirq(dev
);
287 static int amba_pm_poweroff(struct device
*dev
)
289 struct device_driver
*drv
= dev
->driver
;
296 if (drv
->pm
->poweroff
)
297 ret
= drv
->pm
->poweroff(dev
);
299 ret
= amba_legacy_suspend(dev
, PMSG_HIBERNATE
);
305 static int amba_pm_poweroff_noirq(struct device
*dev
)
307 struct device_driver
*drv
= dev
->driver
;
314 if (drv
->pm
->poweroff_noirq
)
315 ret
= drv
->pm
->poweroff_noirq(dev
);
321 static int amba_pm_restore(struct device
*dev
)
323 struct device_driver
*drv
= dev
->driver
;
330 if (drv
->pm
->restore
)
331 ret
= drv
->pm
->restore(dev
);
333 ret
= amba_legacy_resume(dev
);
339 static int amba_pm_restore_noirq(struct device
*dev
)
341 struct device_driver
*drv
= dev
->driver
;
348 if (drv
->pm
->restore_noirq
)
349 ret
= drv
->pm
->restore_noirq(dev
);
355 #else /* !CONFIG_HIBERNATE_CALLBACKS */
357 #define amba_pm_freeze NULL
358 #define amba_pm_thaw NULL
359 #define amba_pm_poweroff NULL
360 #define amba_pm_restore NULL
361 #define amba_pm_freeze_noirq NULL
362 #define amba_pm_thaw_noirq NULL
363 #define amba_pm_poweroff_noirq NULL
364 #define amba_pm_restore_noirq NULL
366 #endif /* !CONFIG_HIBERNATE_CALLBACKS */
368 #ifdef CONFIG_PM_RUNTIME
370 * Hooks to provide runtime PM of the pclk (bus clock). It is safe to
371 * enable/disable the bus clock at runtime PM suspend/resume as this
372 * does not result in loss of context. However, disabling vcore power
373 * would do, so we leave that to the driver.
375 static int amba_pm_runtime_suspend(struct device
*dev
)
377 struct amba_device
*pcdev
= to_amba_device(dev
);
378 int ret
= pm_generic_runtime_suspend(dev
);
380 if (ret
== 0 && dev
->driver
)
381 clk_disable(pcdev
->pclk
);
386 static int amba_pm_runtime_resume(struct device
*dev
)
388 struct amba_device
*pcdev
= to_amba_device(dev
);
392 ret
= clk_enable(pcdev
->pclk
);
393 /* Failure is probably fatal to the system, but... */
398 return pm_generic_runtime_resume(dev
);
404 static const struct dev_pm_ops amba_pm
= {
405 .prepare
= amba_pm_prepare
,
406 .complete
= amba_pm_complete
,
407 .suspend
= amba_pm_suspend
,
408 .resume
= amba_pm_resume
,
409 .freeze
= amba_pm_freeze
,
410 .thaw
= amba_pm_thaw
,
411 .poweroff
= amba_pm_poweroff
,
412 .restore
= amba_pm_restore
,
413 .suspend_noirq
= amba_pm_suspend_noirq
,
414 .resume_noirq
= amba_pm_resume_noirq
,
415 .freeze_noirq
= amba_pm_freeze_noirq
,
416 .thaw_noirq
= amba_pm_thaw_noirq
,
417 .poweroff_noirq
= amba_pm_poweroff_noirq
,
418 .restore_noirq
= amba_pm_restore_noirq
,
420 amba_pm_runtime_suspend
,
421 amba_pm_runtime_resume
,
422 pm_generic_runtime_idle
426 #define AMBA_PM (&amba_pm)
428 #else /* !CONFIG_PM */
432 #endif /* !CONFIG_PM */
435 * Primecells are part of the Advanced Microcontroller Bus Architecture,
436 * so we call the bus "amba".
438 struct bus_type amba_bustype
= {
440 .dev_attrs
= amba_dev_attrs
,
442 .uevent
= amba_uevent
,
446 static int __init
amba_init(void)
448 return bus_register(&amba_bustype
);
451 postcore_initcall(amba_init
);
453 static int amba_get_enable_pclk(struct amba_device
*pcdev
)
455 struct clk
*pclk
= clk_get(&pcdev
->dev
, "apb_pclk");
461 return PTR_ERR(pclk
);
463 ret
= clk_enable(pclk
);
470 static void amba_put_disable_pclk(struct amba_device
*pcdev
)
472 struct clk
*pclk
= pcdev
->pclk
;
478 static int amba_get_enable_vcore(struct amba_device
*pcdev
)
480 struct regulator
*vcore
= regulator_get(&pcdev
->dev
, "vcore");
483 pcdev
->vcore
= vcore
;
486 /* It is OK not to supply a vcore regulator */
487 if (PTR_ERR(vcore
) == -ENODEV
)
489 return PTR_ERR(vcore
);
492 ret
= regulator_enable(vcore
);
494 regulator_put(vcore
);
495 pcdev
->vcore
= ERR_PTR(-ENODEV
);
501 static void amba_put_disable_vcore(struct amba_device
*pcdev
)
503 struct regulator
*vcore
= pcdev
->vcore
;
505 if (!IS_ERR(vcore
)) {
506 regulator_disable(vcore
);
507 regulator_put(vcore
);
512 * These are the device model conversion veneers; they convert the
513 * device model structures to our more specific structures.
515 static int amba_probe(struct device
*dev
)
517 struct amba_device
*pcdev
= to_amba_device(dev
);
518 struct amba_driver
*pcdrv
= to_amba_driver(dev
->driver
);
519 const struct amba_id
*id
= amba_lookup(pcdrv
->id_table
, pcdev
);
523 ret
= amba_get_enable_vcore(pcdev
);
527 ret
= amba_get_enable_pclk(pcdev
);
531 pm_runtime_get_noresume(dev
);
532 pm_runtime_set_active(dev
);
533 pm_runtime_enable(dev
);
535 ret
= pcdrv
->probe(pcdev
, id
);
539 pm_runtime_disable(dev
);
540 pm_runtime_set_suspended(dev
);
541 pm_runtime_put_noidle(dev
);
543 amba_put_disable_pclk(pcdev
);
544 amba_put_disable_vcore(pcdev
);
550 static int amba_remove(struct device
*dev
)
552 struct amba_device
*pcdev
= to_amba_device(dev
);
553 struct amba_driver
*drv
= to_amba_driver(dev
->driver
);
556 pm_runtime_get_sync(dev
);
557 ret
= drv
->remove(pcdev
);
558 pm_runtime_put_noidle(dev
);
560 /* Undo the runtime PM settings in amba_probe() */
561 pm_runtime_disable(dev
);
562 pm_runtime_set_suspended(dev
);
563 pm_runtime_put_noidle(dev
);
565 amba_put_disable_pclk(pcdev
);
566 amba_put_disable_vcore(pcdev
);
571 static void amba_shutdown(struct device
*dev
)
573 struct amba_driver
*drv
= to_amba_driver(dev
->driver
);
574 drv
->shutdown(to_amba_device(dev
));
578 * amba_driver_register - register an AMBA device driver
579 * @drv: amba device driver structure
581 * Register an AMBA device driver with the Linux device model
582 * core. If devices pre-exist, the drivers probe function will
585 int amba_driver_register(struct amba_driver
*drv
)
587 drv
->drv
.bus
= &amba_bustype
;
589 #define SETFN(fn) if (drv->fn) drv->drv.fn = amba_##fn
594 return driver_register(&drv
->drv
);
598 * amba_driver_unregister - remove an AMBA device driver
599 * @drv: AMBA device driver structure to remove
601 * Unregister an AMBA device driver from the Linux device
602 * model. The device model will call the drivers remove function
603 * for each device the device driver is currently handling.
605 void amba_driver_unregister(struct amba_driver
*drv
)
607 driver_unregister(&drv
->drv
);
611 static void amba_device_release(struct device
*dev
)
613 struct amba_device
*d
= to_amba_device(dev
);
616 release_resource(&d
->res
);
621 * amba_device_register - register an AMBA device
622 * @dev: AMBA device to register
623 * @parent: parent memory resource
625 * Setup the AMBA device, reading the cell ID if present.
626 * Claim the resource, and register the AMBA device with
627 * the Linux device manager.
629 int amba_device_register(struct amba_device
*dev
, struct resource
*parent
)
635 device_initialize(&dev
->dev
);
638 * Copy from device_add
640 if (dev
->dev
.init_name
) {
641 dev_set_name(&dev
->dev
, "%s", dev
->dev
.init_name
);
642 dev
->dev
.init_name
= NULL
;
645 dev
->dev
.release
= amba_device_release
;
646 dev
->dev
.bus
= &amba_bustype
;
647 dev
->dev
.dma_mask
= &dev
->dma_mask
;
648 dev
->res
.name
= dev_name(&dev
->dev
);
650 if (!dev
->dev
.coherent_dma_mask
&& dev
->dma_mask
)
651 dev_warn(&dev
->dev
, "coherent dma mask is unset\n");
653 ret
= request_resource(parent
, &dev
->res
);
657 /* Hard-coded primecell ID instead of plug-n-play */
658 if (dev
->periphid
!= 0)
662 * Dynamically calculate the size of the resource
663 * and use this for iomap
665 size
= resource_size(&dev
->res
);
666 tmp
= ioremap(dev
->res
.start
, size
);
672 ret
= amba_get_enable_pclk(dev
);
677 * Read pid and cid based on size of resource
678 * they are located at end of region
680 for (pid
= 0, i
= 0; i
< 4; i
++)
681 pid
|= (readl(tmp
+ size
- 0x20 + 4 * i
) & 255) <<
683 for (cid
= 0, i
= 0; i
< 4; i
++)
684 cid
|= (readl(tmp
+ size
- 0x10 + 4 * i
) & 255) <<
687 amba_put_disable_pclk(dev
);
702 ret
= device_add(&dev
->dev
);
706 if (dev
->irq
[0] != NO_IRQ
)
707 ret
= device_create_file(&dev
->dev
, &dev_attr_irq0
);
708 if (ret
== 0 && dev
->irq
[1] != NO_IRQ
)
709 ret
= device_create_file(&dev
->dev
, &dev_attr_irq1
);
713 device_unregister(&dev
->dev
);
716 release_resource(&dev
->res
);
722 * amba_device_unregister - unregister an AMBA device
723 * @dev: AMBA device to remove
725 * Remove the specified AMBA device from the Linux device
726 * manager. All files associated with this object will be
727 * destroyed, and device drivers notified that the device has
728 * been removed. The AMBA device's resources including
729 * the amba_device structure will be freed once all
730 * references to it have been dropped.
732 void amba_device_unregister(struct amba_device
*dev
)
734 device_unregister(&dev
->dev
);
739 struct amba_device
*dev
;
740 struct device
*parent
;
746 static int amba_find_match(struct device
*dev
, void *data
)
748 struct find_data
*d
= data
;
749 struct amba_device
*pcdev
= to_amba_device(dev
);
752 r
= (pcdev
->periphid
& d
->mask
) == d
->id
;
754 r
&= d
->parent
== dev
->parent
;
756 r
&= strcmp(dev_name(dev
), d
->busid
) == 0;
767 * amba_find_device - locate an AMBA device given a bus id
768 * @busid: bus id for device (or NULL)
769 * @parent: parent device (or NULL)
770 * @id: peripheral ID (or 0)
771 * @mask: peripheral ID mask (or 0)
773 * Return the AMBA device corresponding to the supplied parameters.
774 * If no device matches, returns NULL.
776 * NOTE: When a valid device is found, its refcount is
777 * incremented, and must be decremented before the returned
781 amba_find_device(const char *busid
, struct device
*parent
, unsigned int id
,
784 struct find_data data
;
787 data
.parent
= parent
;
792 bus_for_each_dev(&amba_bustype
, NULL
, &data
, amba_find_match
);
798 * amba_request_regions - request all mem regions associated with device
799 * @dev: amba_device structure for device
800 * @name: name, or NULL to use driver name
802 int amba_request_regions(struct amba_device
*dev
, const char *name
)
808 name
= dev
->dev
.driver
->name
;
810 size
= resource_size(&dev
->res
);
812 if (!request_mem_region(dev
->res
.start
, size
, name
))
819 * amba_release_regions - release mem regions associated with device
820 * @dev: amba_device structure for device
822 * Release regions claimed by a successful call to amba_request_regions.
824 void amba_release_regions(struct amba_device
*dev
)
828 size
= resource_size(&dev
->res
);
829 release_mem_region(dev
->res
.start
, size
);
832 EXPORT_SYMBOL(amba_driver_register
);
833 EXPORT_SYMBOL(amba_driver_unregister
);
834 EXPORT_SYMBOL(amba_device_register
);
835 EXPORT_SYMBOL(amba_device_unregister
);
836 EXPORT_SYMBOL(amba_find_device
);
837 EXPORT_SYMBOL(amba_request_regions
);
838 EXPORT_SYMBOL(amba_release_regions
);