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(map: axi->sys_regs, BT1_AXI_WERRL, val: &low); |
64 | regmap_read(map: axi->sys_regs, BT1_AXI_WERRH, val: &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, size: sizeof(*axi), GFP_KERNEL); |
99 | if (!axi) |
100 | return ERR_PTR(error: -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(error: ret); |
106 | } |
107 | |
108 | axi->dev = dev; |
109 | atomic_set(v: &axi->count, i: 0); |
110 | platform_set_drvdata(pdev, data: 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(np: dev->of_node, property: "syscon" ); |
121 | if (IS_ERR(ptr: axi->sys_regs)) { |
122 | dev_err(dev, "Couldn't find syscon registers\n" ); |
123 | return PTR_ERR(ptr: axi->sys_regs); |
124 | } |
125 | |
126 | axi->qos_regs = devm_platform_ioremap_resource_byname(pdev, name: "qos" ); |
127 | if (IS_ERR(ptr: axi->qos_regs)) |
128 | dev_err(dev, "Couldn't map AXI-bus QoS registers\n" ); |
129 | |
130 | return PTR_ERR_OR_ZERO(ptr: axi->qos_regs); |
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(dev: axi->dev, id: "arst" ); |
138 | if (IS_ERR(ptr: axi->arst)) |
139 | return dev_err_probe(dev: axi->dev, err: PTR_ERR(ptr: axi->arst), |
140 | fmt: "Couldn't get reset control line\n" ); |
141 | |
142 | ret = reset_control_deassert(rstc: 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(clk: 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(dev: axi->dev, id: "aclk" ); |
161 | if (IS_ERR(ptr: axi->aclk)) |
162 | return dev_err_probe(dev: axi->dev, err: PTR_ERR(ptr: axi->aclk), |
163 | fmt: "Couldn't get AXI Interconnect clock\n" ); |
164 | |
165 | ret = clk_prepare_enable(clk: 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); |
172 | if (ret) |
173 | dev_err(axi->dev, "Can't add AXI clock disable action\n" ); |
174 | |
175 | return ret; |
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(dev: axi->dev, irq: axi->irq, handler: bt1_axi_isr, IRQF_SHARED, |
188 | devname: "bt1-axi" , dev_id: axi); |
189 | if (ret) |
190 | dev_err(axi->dev, "Couldn't request AXI EHB IRQ\n" ); |
191 | |
192 | return ret; |
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, fmt: "%d\n" , atomic_read(v: &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, fmt: "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 | */ |
221 | if (sysfs_streq(s1: data, s2: "bus" )) |
222 | readb(addr: axi->qos_regs); |
223 | else if (sysfs_streq(s1: data, s2: "unaligned" )) |
224 | writeb(val: 0, addr: 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(dev: axi->dev, groups: 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(dev: axi->dev, groups: 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(ptr: axi)) |
270 | return PTR_ERR(ptr: 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" ); |
312 | |