1 | // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause |
2 | /* |
3 | * Amlogic Meson Reset Controller driver |
4 | * |
5 | * Copyright (c) 2016 BayLibre, SAS. |
6 | * Author: Neil Armstrong <narmstrong@baylibre.com> |
7 | */ |
8 | #include <linux/err.h> |
9 | #include <linux/init.h> |
10 | #include <linux/io.h> |
11 | #include <linux/of.h> |
12 | #include <linux/module.h> |
13 | #include <linux/platform_device.h> |
14 | #include <linux/reset-controller.h> |
15 | #include <linux/slab.h> |
16 | #include <linux/types.h> |
17 | |
18 | #define BITS_PER_REG 32 |
19 | |
20 | struct meson_reset_param { |
21 | int reg_count; |
22 | int level_offset; |
23 | }; |
24 | |
25 | struct meson_reset { |
26 | void __iomem *reg_base; |
27 | const struct meson_reset_param *param; |
28 | struct reset_controller_dev rcdev; |
29 | spinlock_t lock; |
30 | }; |
31 | |
32 | static int meson_reset_reset(struct reset_controller_dev *rcdev, |
33 | unsigned long id) |
34 | { |
35 | struct meson_reset *data = |
36 | container_of(rcdev, struct meson_reset, rcdev); |
37 | unsigned int bank = id / BITS_PER_REG; |
38 | unsigned int offset = id % BITS_PER_REG; |
39 | void __iomem *reg_addr = data->reg_base + (bank << 2); |
40 | |
41 | writel(BIT(offset), addr: reg_addr); |
42 | |
43 | return 0; |
44 | } |
45 | |
46 | static int meson_reset_level(struct reset_controller_dev *rcdev, |
47 | unsigned long id, bool assert) |
48 | { |
49 | struct meson_reset *data = |
50 | container_of(rcdev, struct meson_reset, rcdev); |
51 | unsigned int bank = id / BITS_PER_REG; |
52 | unsigned int offset = id % BITS_PER_REG; |
53 | void __iomem *reg_addr; |
54 | unsigned long flags; |
55 | u32 reg; |
56 | |
57 | reg_addr = data->reg_base + data->param->level_offset + (bank << 2); |
58 | |
59 | spin_lock_irqsave(&data->lock, flags); |
60 | |
61 | reg = readl(addr: reg_addr); |
62 | if (assert) |
63 | writel(val: reg & ~BIT(offset), addr: reg_addr); |
64 | else |
65 | writel(val: reg | BIT(offset), addr: reg_addr); |
66 | |
67 | spin_unlock_irqrestore(lock: &data->lock, flags); |
68 | |
69 | return 0; |
70 | } |
71 | |
72 | static int meson_reset_assert(struct reset_controller_dev *rcdev, |
73 | unsigned long id) |
74 | { |
75 | return meson_reset_level(rcdev, id, assert: true); |
76 | } |
77 | |
78 | static int meson_reset_deassert(struct reset_controller_dev *rcdev, |
79 | unsigned long id) |
80 | { |
81 | return meson_reset_level(rcdev, id, assert: false); |
82 | } |
83 | |
84 | static const struct reset_control_ops meson_reset_ops = { |
85 | .reset = meson_reset_reset, |
86 | .assert = meson_reset_assert, |
87 | .deassert = meson_reset_deassert, |
88 | }; |
89 | |
90 | static const struct meson_reset_param meson8b_param = { |
91 | .reg_count = 8, |
92 | .level_offset = 0x7c, |
93 | }; |
94 | |
95 | static const struct meson_reset_param meson_a1_param = { |
96 | .reg_count = 3, |
97 | .level_offset = 0x40, |
98 | }; |
99 | |
100 | static const struct meson_reset_param meson_s4_param = { |
101 | .reg_count = 6, |
102 | .level_offset = 0x40, |
103 | }; |
104 | |
105 | static const struct of_device_id meson_reset_dt_ids[] = { |
106 | { .compatible = "amlogic,meson8b-reset" , .data = &meson8b_param}, |
107 | { .compatible = "amlogic,meson-gxbb-reset" , .data = &meson8b_param}, |
108 | { .compatible = "amlogic,meson-axg-reset" , .data = &meson8b_param}, |
109 | { .compatible = "amlogic,meson-a1-reset" , .data = &meson_a1_param}, |
110 | { .compatible = "amlogic,meson-s4-reset" , .data = &meson_s4_param}, |
111 | { .compatible = "amlogic,c3-reset" , .data = &meson_s4_param}, |
112 | { /* sentinel */ }, |
113 | }; |
114 | MODULE_DEVICE_TABLE(of, meson_reset_dt_ids); |
115 | |
116 | static int meson_reset_probe(struct platform_device *pdev) |
117 | { |
118 | struct meson_reset *data; |
119 | |
120 | data = devm_kzalloc(dev: &pdev->dev, size: sizeof(*data), GFP_KERNEL); |
121 | if (!data) |
122 | return -ENOMEM; |
123 | |
124 | data->reg_base = devm_platform_ioremap_resource(pdev, index: 0); |
125 | if (IS_ERR(ptr: data->reg_base)) |
126 | return PTR_ERR(ptr: data->reg_base); |
127 | |
128 | data->param = of_device_get_match_data(dev: &pdev->dev); |
129 | if (!data->param) |
130 | return -ENODEV; |
131 | |
132 | spin_lock_init(&data->lock); |
133 | |
134 | data->rcdev.owner = THIS_MODULE; |
135 | data->rcdev.nr_resets = data->param->reg_count * BITS_PER_REG; |
136 | data->rcdev.ops = &meson_reset_ops; |
137 | data->rcdev.of_node = pdev->dev.of_node; |
138 | |
139 | return devm_reset_controller_register(dev: &pdev->dev, rcdev: &data->rcdev); |
140 | } |
141 | |
142 | static struct platform_driver meson_reset_driver = { |
143 | .probe = meson_reset_probe, |
144 | .driver = { |
145 | .name = "meson_reset" , |
146 | .of_match_table = meson_reset_dt_ids, |
147 | }, |
148 | }; |
149 | module_platform_driver(meson_reset_driver); |
150 | |
151 | MODULE_DESCRIPTION("Amlogic Meson Reset Controller driver" ); |
152 | MODULE_AUTHOR("Neil Armstrong <narmstrong@baylibre.com>" ); |
153 | MODULE_LICENSE("Dual BSD/GPL" ); |
154 | |