Commit | Line | Data |
---|---|---|
63cb7713 SS |
1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* | |
3 | * Copyright (C) 2020 BAIKAL ELECTRONICS, JSC | |
4 | * | |
5 | * Authors: | |
6 | * Serge Semin <Sergey.Semin@baikalelectronics.ru> | |
7 | * | |
8 | * Baikal-T1 AXI-bus driver | |
9 | */ | |
10 | ||
11 | #include <linux/kernel.h> | |
12 | #include <linux/module.h> | |
13 | #include <linux/types.h> | |
14 | #include <linux/bitfield.h> | |
15 | #include <linux/device.h> | |
16 | #include <linux/atomic.h> | |
17 | #include <linux/regmap.h> | |
18 | #include <linux/platform_device.h> | |
19 | #include <linux/mfd/syscon.h> | |
20 | #include <linux/interrupt.h> | |
21 | #include <linux/io.h> | |
22 | #include <linux/nmi.h> | |
23 | #include <linux/of.h> | |
24 | #include <linux/clk.h> | |
25 | #include <linux/reset.h> | |
26 | #include <linux/sysfs.h> | |
27 | ||
28 | #define BT1_AXI_WERRL 0x110 | |
29 | #define BT1_AXI_WERRH 0x114 | |
30 | #define BT1_AXI_WERRH_TYPE BIT(23) | |
31 | #define BT1_AXI_WERRH_ADDR_FLD 24 | |
32 | #define BT1_AXI_WERRH_ADDR_MASK GENMASK(31, BT1_AXI_WERRH_ADDR_FLD) | |
33 | ||
34 | /* | |
35 | * struct bt1_axi - Baikal-T1 AXI-bus private data | |
36 | * @dev: Pointer to the device structure. | |
37 | * @qos_regs: AXI Interconnect QoS tuning registers. | |
38 | * @sys_regs: Baikal-T1 System Controller registers map. | |
39 | * @irq: Errors IRQ number. | |
40 | * @aclk: AXI reference clock. | |
41 | * @arst: AXI Interconnect reset line. | |
42 | * @count: Number of errors detected. | |
43 | */ | |
44 | struct bt1_axi { | |
45 | struct device *dev; | |
46 | ||
47 | void __iomem *qos_regs; | |
48 | struct regmap *sys_regs; | |
49 | int irq; | |
50 | ||
51 | struct clk *aclk; | |
52 | ||
53 | struct reset_control *arst; | |
54 | ||
55 | atomic_t count; | |
56 | }; | |
57 | ||
58 | static irqreturn_t bt1_axi_isr(int irq, void *data) | |
59 | { | |
60 | struct bt1_axi *axi = data; | |
61 | u32 low = 0, high = 0; | |
62 | ||
63 | regmap_read(axi->sys_regs, BT1_AXI_WERRL, &low); | |
64 | regmap_read(axi->sys_regs, BT1_AXI_WERRH, &high); | |
65 | ||
66 | dev_crit_ratelimited(axi->dev, | |
67 | "AXI-bus fault %d: %s at 0x%x%08x\n", | |
68 | atomic_inc_return(&axi->count), | |
69 | high & BT1_AXI_WERRH_TYPE ? "no slave" : "slave protocol error", | |
70 | high, low); | |
71 | ||
72 | /* | |
73 | * Print backtrace on each CPU. This might be pointless if the fault | |
74 | * has happened on the same CPU as the IRQ handler is executed or | |
75 | * the other core proceeded further execution despite the error. | |
76 | * But if it's not, by looking at the trace we would get straight to | |
77 | * the cause of the problem. | |
78 | */ | |
79 | trigger_all_cpu_backtrace(); | |
80 | ||
81 | return IRQ_HANDLED; | |
82 | } | |
83 | ||
84 | static void bt1_axi_clear_data(void *data) | |
85 | { | |
86 | struct bt1_axi *axi = data; | |
87 | struct platform_device *pdev = to_platform_device(axi->dev); | |
88 | ||
89 | platform_set_drvdata(pdev, NULL); | |
90 | } | |
91 | ||
92 | static struct bt1_axi *bt1_axi_create_data(struct platform_device *pdev) | |
93 | { | |
94 | struct device *dev = &pdev->dev; | |
95 | struct bt1_axi *axi; | |
96 | int ret; | |
97 | ||
98 | axi = devm_kzalloc(dev, sizeof(*axi), GFP_KERNEL); | |
99 | if (!axi) | |
100 | return ERR_PTR(-ENOMEM); | |
101 | ||
102 | ret = devm_add_action(dev, bt1_axi_clear_data, axi); | |
103 | if (ret) { | |
104 | dev_err(dev, "Can't add AXI EHB data clear action\n"); | |
105 | return ERR_PTR(ret); | |
106 | } | |
107 | ||
108 | axi->dev = dev; | |
109 | atomic_set(&axi->count, 0); | |
110 | platform_set_drvdata(pdev, axi); | |
111 | ||
112 | return axi; | |
113 | } | |
114 | ||
115 | static int bt1_axi_request_regs(struct bt1_axi *axi) | |
116 | { | |
117 | struct platform_device *pdev = to_platform_device(axi->dev); | |
118 | struct device *dev = axi->dev; | |
119 | ||
120 | axi->sys_regs = syscon_regmap_lookup_by_phandle(dev->of_node, "syscon"); | |
121 | if (IS_ERR(axi->sys_regs)) { | |
122 | dev_err(dev, "Couldn't find syscon registers\n"); | |
123 | return PTR_ERR(axi->sys_regs); | |
124 | } | |
125 | ||
126 | axi->qos_regs = devm_platform_ioremap_resource_byname(pdev, "qos"); | |
7f57416f | 127 | if (IS_ERR(axi->qos_regs)) |
63cb7713 | 128 | dev_err(dev, "Couldn't map AXI-bus QoS registers\n"); |
63cb7713 | 129 | |
7f57416f | 130 | return PTR_ERR_OR_ZERO(axi->qos_regs); |
63cb7713 SS |
131 | } |
132 | ||
133 | static int bt1_axi_request_rst(struct bt1_axi *axi) | |
134 | { | |
135 | int ret; | |
136 | ||
137 | axi->arst = devm_reset_control_get_optional_exclusive(axi->dev, "arst"); | |
5e93207e SS |
138 | if (IS_ERR(axi->arst)) |
139 | return dev_err_probe(axi->dev, PTR_ERR(axi->arst), | |
140 | "Couldn't get reset control line\n"); | |
63cb7713 SS |
141 | |
142 | ret = reset_control_deassert(axi->arst); | |
143 | if (ret) | |
144 | dev_err(axi->dev, "Failed to deassert the reset line\n"); | |
145 | ||
146 | return ret; | |
147 | } | |
148 | ||
149 | static void bt1_axi_disable_clk(void *data) | |
150 | { | |
151 | struct bt1_axi *axi = data; | |
152 | ||
153 | clk_disable_unprepare(axi->aclk); | |
154 | } | |
155 | ||
156 | static int bt1_axi_request_clk(struct bt1_axi *axi) | |
157 | { | |
158 | int ret; | |
159 | ||
160 | axi->aclk = devm_clk_get(axi->dev, "aclk"); | |
5e93207e SS |
161 | if (IS_ERR(axi->aclk)) |
162 | return dev_err_probe(axi->dev, PTR_ERR(axi->aclk), | |
163 | "Couldn't get AXI Interconnect clock\n"); | |
63cb7713 SS |
164 | |
165 | ret = clk_prepare_enable(axi->aclk); | |
166 | if (ret) { | |
167 | dev_err(axi->dev, "Couldn't enable the AXI clock\n"); | |
168 | return ret; | |
169 | } | |
170 | ||
171 | ret = devm_add_action_or_reset(axi->dev, bt1_axi_disable_clk, axi); | |
7f57416f | 172 | if (ret) |
63cb7713 | 173 | dev_err(axi->dev, "Can't add AXI clock disable action\n"); |
63cb7713 | 174 | |
7f57416f | 175 | return ret; |
63cb7713 SS |
176 | } |
177 | ||
178 | static int bt1_axi_request_irq(struct bt1_axi *axi) | |
179 | { | |
180 | struct platform_device *pdev = to_platform_device(axi->dev); | |
181 | int ret; | |
182 | ||
183 | axi->irq = platform_get_irq(pdev, 0); | |
184 | if (axi->irq < 0) | |
185 | return axi->irq; | |
186 | ||
187 | ret = devm_request_irq(axi->dev, axi->irq, bt1_axi_isr, IRQF_SHARED, | |
188 | "bt1-axi", axi); | |
7f57416f | 189 | if (ret) |
63cb7713 | 190 | dev_err(axi->dev, "Couldn't request AXI EHB IRQ\n"); |
63cb7713 | 191 | |
7f57416f | 192 | return ret; |
63cb7713 SS |
193 | } |
194 | ||
195 | static ssize_t count_show(struct device *dev, | |
196 | struct device_attribute *attr, char *buf) | |
197 | { | |
198 | struct bt1_axi *axi = dev_get_drvdata(dev); | |
199 | ||
200 | return scnprintf(buf, PAGE_SIZE, "%d\n", atomic_read(&axi->count)); | |
201 | } | |
202 | static DEVICE_ATTR_RO(count); | |
203 | ||
204 | static ssize_t inject_error_show(struct device *dev, | |
205 | struct device_attribute *attr, char *buf) | |
206 | { | |
207 | return scnprintf(buf, PAGE_SIZE, "Error injection: bus unaligned\n"); | |
208 | } | |
209 | ||
210 | static ssize_t inject_error_store(struct device *dev, | |
211 | struct device_attribute *attr, | |
212 | const char *data, size_t count) | |
213 | { | |
214 | struct bt1_axi *axi = dev_get_drvdata(dev); | |
215 | ||
216 | /* | |
217 | * Performing unaligned read from the memory will cause the CM2 bus | |
218 | * error while unaligned writing - the AXI bus write error handled | |
219 | * by this driver. | |
220 | */ | |
91920088 | 221 | if (sysfs_streq(data, "bus")) |
63cb7713 | 222 | readb(axi->qos_regs); |
91920088 | 223 | else if (sysfs_streq(data, "unaligned")) |
63cb7713 SS |
224 | writeb(0, axi->qos_regs); |
225 | else | |
226 | return -EINVAL; | |
227 | ||
228 | return count; | |
229 | } | |
230 | static DEVICE_ATTR_RW(inject_error); | |
231 | ||
232 | static struct attribute *bt1_axi_sysfs_attrs[] = { | |
233 | &dev_attr_count.attr, | |
234 | &dev_attr_inject_error.attr, | |
235 | NULL | |
236 | }; | |
237 | ATTRIBUTE_GROUPS(bt1_axi_sysfs); | |
238 | ||
239 | static void bt1_axi_remove_sysfs(void *data) | |
240 | { | |
241 | struct bt1_axi *axi = data; | |
242 | ||
243 | device_remove_groups(axi->dev, bt1_axi_sysfs_groups); | |
244 | } | |
245 | ||
246 | static int bt1_axi_init_sysfs(struct bt1_axi *axi) | |
247 | { | |
248 | int ret; | |
249 | ||
250 | ret = device_add_groups(axi->dev, bt1_axi_sysfs_groups); | |
251 | if (ret) { | |
252 | dev_err(axi->dev, "Failed to add sysfs files group\n"); | |
253 | return ret; | |
254 | } | |
255 | ||
256 | ret = devm_add_action_or_reset(axi->dev, bt1_axi_remove_sysfs, axi); | |
257 | if (ret) | |
258 | dev_err(axi->dev, "Can't add AXI EHB sysfs remove action\n"); | |
259 | ||
260 | return ret; | |
261 | } | |
262 | ||
263 | static int bt1_axi_probe(struct platform_device *pdev) | |
264 | { | |
265 | struct bt1_axi *axi; | |
266 | int ret; | |
267 | ||
268 | axi = bt1_axi_create_data(pdev); | |
269 | if (IS_ERR(axi)) | |
270 | return PTR_ERR(axi); | |
271 | ||
272 | ret = bt1_axi_request_regs(axi); | |
273 | if (ret) | |
274 | return ret; | |
275 | ||
276 | ret = bt1_axi_request_rst(axi); | |
277 | if (ret) | |
278 | return ret; | |
279 | ||
280 | ret = bt1_axi_request_clk(axi); | |
281 | if (ret) | |
282 | return ret; | |
283 | ||
284 | ret = bt1_axi_request_irq(axi); | |
285 | if (ret) | |
286 | return ret; | |
287 | ||
288 | ret = bt1_axi_init_sysfs(axi); | |
289 | if (ret) | |
290 | return ret; | |
291 | ||
292 | return 0; | |
293 | } | |
294 | ||
295 | static const struct of_device_id bt1_axi_of_match[] = { | |
296 | { .compatible = "baikal,bt1-axi" }, | |
297 | { } | |
298 | }; | |
299 | MODULE_DEVICE_TABLE(of, bt1_axi_of_match); | |
300 | ||
301 | static struct platform_driver bt1_axi_driver = { | |
302 | .probe = bt1_axi_probe, | |
303 | .driver = { | |
304 | .name = "bt1-axi", | |
305 | .of_match_table = bt1_axi_of_match | |
306 | } | |
307 | }; | |
308 | module_platform_driver(bt1_axi_driver); | |
309 | ||
310 | MODULE_AUTHOR("Serge Semin <Sergey.Semin@baikalelectronics.ru>"); | |
311 | MODULE_DESCRIPTION("Baikal-T1 AXI-bus driver"); |