2 * Copyright (C) 2014 Broadcom Corporation
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
14 #include <linux/init.h>
15 #include <linux/types.h>
16 #include <linux/module.h>
17 #include <linux/platform_device.h>
18 #include <linux/interrupt.h>
19 #include <linux/sysfs.h>
21 #include <linux/string.h>
22 #include <linux/device.h>
23 #include <linux/list.h>
25 #include <linux/bitops.h>
29 #include <asm/signal.h>
31 #define ARB_TIMER 0x008
32 #define ARB_ERR_CAP_CLR 0x7e4
33 #define ARB_ERR_CAP_CLEAR (1 << 0)
34 #define ARB_ERR_CAP_HI_ADDR 0x7e8
35 #define ARB_ERR_CAP_ADDR 0x7ec
36 #define ARB_ERR_CAP_DATA 0x7f0
37 #define ARB_ERR_CAP_STATUS 0x7f4
38 #define ARB_ERR_CAP_STATUS_TIMEOUT (1 << 12)
39 #define ARB_ERR_CAP_STATUS_TEA (1 << 11)
40 #define ARB_ERR_CAP_STATUS_BS_SHIFT (1 << 2)
41 #define ARB_ERR_CAP_STATUS_BS_MASK 0x3c
42 #define ARB_ERR_CAP_STATUS_WRITE (1 << 1)
43 #define ARB_ERR_CAP_STATUS_VALID (1 << 0)
44 #define ARB_ERR_CAP_MASTER 0x7f8
46 struct brcmstb_gisb_arb_device {
49 struct list_head next;
51 const char *master_names[sizeof(u32) * BITS_PER_BYTE];
55 static LIST_HEAD(brcmstb_gisb_arb_device_list);
57 static ssize_t gisb_arb_get_timeout(struct device *dev,
58 struct device_attribute *attr,
61 struct platform_device *pdev = to_platform_device(dev);
62 struct brcmstb_gisb_arb_device *gdev = platform_get_drvdata(pdev);
65 mutex_lock(&gdev->lock);
66 timeout = ioread32(gdev->base + ARB_TIMER);
67 mutex_unlock(&gdev->lock);
69 return sprintf(buf, "%d", timeout);
72 static ssize_t gisb_arb_set_timeout(struct device *dev,
73 struct device_attribute *attr,
74 const char *buf, size_t count)
76 struct platform_device *pdev = to_platform_device(dev);
77 struct brcmstb_gisb_arb_device *gdev = platform_get_drvdata(pdev);
80 ret = kstrtoint(buf, 10, &val);
84 if (val == 0 || val >= 0xffffffff)
87 mutex_lock(&gdev->lock);
88 iowrite32(val, gdev->base + ARB_TIMER);
89 mutex_unlock(&gdev->lock);
95 brcmstb_gisb_master_to_str(struct brcmstb_gisb_arb_device *gdev,
98 u32 mask = gdev->valid_mask & masters;
100 if (hweight_long(mask) != 1)
103 return gdev->master_names[ffs(mask) - 1];
106 static int brcmstb_gisb_arb_decode_addr(struct brcmstb_gisb_arb_device *gdev,
110 unsigned long arb_addr;
115 cap_status = ioread32(gdev->base + ARB_ERR_CAP_STATUS);
117 /* Invalid captured address, bail out */
118 if (!(cap_status & ARB_ERR_CAP_STATUS_VALID))
121 /* Read the address and master */
122 arb_addr = ioread32(gdev->base + ARB_ERR_CAP_ADDR) & 0xffffffff;
123 #if (IS_ENABLED(CONFIG_PHYS_ADDR_T_64BIT))
124 arb_addr |= (u64)ioread32(gdev->base + ARB_ERR_CAP_HI_ADDR) << 32;
126 master = ioread32(gdev->base + ARB_ERR_CAP_MASTER);
128 m_name = brcmstb_gisb_master_to_str(gdev, master);
130 snprintf(m_fmt, sizeof(m_fmt), "0x%08x", master);
134 pr_crit("%s: %s at 0x%lx [%c %s], core: %s\n",
135 __func__, reason, arb_addr,
136 cap_status & ARB_ERR_CAP_STATUS_WRITE ? 'W' : 'R',
137 cap_status & ARB_ERR_CAP_STATUS_TIMEOUT ? "timeout" : "",
140 /* clear the GISB error */
141 iowrite32(ARB_ERR_CAP_CLEAR, gdev->base + ARB_ERR_CAP_CLR);
146 static int brcmstb_bus_error_handler(unsigned long addr, unsigned int fsr,
147 struct pt_regs *regs)
150 struct brcmstb_gisb_arb_device *gdev;
152 /* iterate over each GISB arb registered handlers */
153 list_for_each_entry(gdev, &brcmstb_gisb_arb_device_list, next)
154 ret |= brcmstb_gisb_arb_decode_addr(gdev, "bus error");
156 * If it was an imprecise abort, then we need to correct the
157 * return address to be _after_ the instruction.
165 static irqreturn_t brcmstb_gisb_timeout_handler(int irq, void *dev_id)
167 brcmstb_gisb_arb_decode_addr(dev_id, "timeout");
172 static irqreturn_t brcmstb_gisb_tea_handler(int irq, void *dev_id)
174 brcmstb_gisb_arb_decode_addr(dev_id, "target abort");
179 static DEVICE_ATTR(gisb_arb_timeout, S_IWUSR | S_IRUGO,
180 gisb_arb_get_timeout, gisb_arb_set_timeout);
182 static struct attribute *gisb_arb_sysfs_attrs[] = {
183 &dev_attr_gisb_arb_timeout.attr,
187 static struct attribute_group gisb_arb_sysfs_attr_group = {
188 .attrs = gisb_arb_sysfs_attrs,
191 static int brcmstb_gisb_arb_probe(struct platform_device *pdev)
193 struct device_node *dn = pdev->dev.of_node;
194 struct brcmstb_gisb_arb_device *gdev;
196 int err, timeout_irq, tea_irq;
197 unsigned int num_masters, j = 0;
200 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
201 timeout_irq = platform_get_irq(pdev, 0);
202 tea_irq = platform_get_irq(pdev, 1);
204 gdev = devm_kzalloc(&pdev->dev, sizeof(*gdev), GFP_KERNEL);
208 mutex_init(&gdev->lock);
209 INIT_LIST_HEAD(&gdev->next);
211 gdev->base = devm_ioremap_resource(&pdev->dev, r);
212 if (IS_ERR(gdev->base))
213 return PTR_ERR(gdev->base);
215 err = devm_request_irq(&pdev->dev, timeout_irq,
216 brcmstb_gisb_timeout_handler, 0, pdev->name,
221 err = devm_request_irq(&pdev->dev, tea_irq,
222 brcmstb_gisb_tea_handler, 0, pdev->name,
227 /* If we do not have a valid mask, assume all masters are enabled */
228 if (of_property_read_u32(dn, "brcm,gisb-arb-master-mask",
230 gdev->valid_mask = 0xffffffff;
232 /* Proceed with reading the litteral names if we agree on the
235 num_masters = of_property_count_strings(dn,
236 "brcm,gisb-arb-master-names");
237 if (hweight_long(gdev->valid_mask) == num_masters) {
238 first = ffs(gdev->valid_mask) - 1;
239 last = fls(gdev->valid_mask) - 1;
241 for (i = first; i < last; i++) {
242 if (!(gdev->valid_mask & BIT(i)))
245 of_property_read_string_index(dn,
246 "brcm,gisb-arb-master-names", j,
247 &gdev->master_names[i]);
252 err = sysfs_create_group(&pdev->dev.kobj, &gisb_arb_sysfs_attr_group);
256 platform_set_drvdata(pdev, gdev);
258 list_add_tail(&gdev->next, &brcmstb_gisb_arb_device_list);
260 hook_fault_code(22, brcmstb_bus_error_handler, SIGBUS, 0,
261 "imprecise external abort");
263 dev_info(&pdev->dev, "registered mem: %p, irqs: %d, %d\n",
264 gdev->base, timeout_irq, tea_irq);
269 #ifdef CONFIG_PM_SLEEP
270 static int brcmstb_gisb_arb_suspend(struct device *dev)
272 struct platform_device *pdev = to_platform_device(dev);
273 struct brcmstb_gisb_arb_device *gdev = platform_get_drvdata(pdev);
275 gdev->saved_timeout = ioread32(gdev->base + ARB_TIMER);
280 /* Make sure we provide the same timeout value that was configured before, and
281 * do this before the GISB timeout interrupt handler has any chance to run.
283 static int brcmstb_gisb_arb_resume_noirq(struct device *dev)
285 struct platform_device *pdev = to_platform_device(dev);
286 struct brcmstb_gisb_arb_device *gdev = platform_get_drvdata(pdev);
288 iowrite32(gdev->saved_timeout, gdev->base + ARB_TIMER);
293 #define brcmstb_gisb_arb_suspend NULL
294 #define brcmstb_gisb_arb_resume_noirq NULL
297 static const struct dev_pm_ops brcmstb_gisb_arb_pm_ops = {
298 .suspend = brcmstb_gisb_arb_suspend,
299 .resume_noirq = brcmstb_gisb_arb_resume_noirq,
302 static const struct of_device_id brcmstb_gisb_arb_of_match[] = {
303 { .compatible = "brcm,gisb-arb" },
307 static struct platform_driver brcmstb_gisb_arb_driver = {
308 .probe = brcmstb_gisb_arb_probe,
310 .name = "brcm-gisb-arb",
311 .owner = THIS_MODULE,
312 .of_match_table = brcmstb_gisb_arb_of_match,
313 .pm = &brcmstb_gisb_arb_pm_ops,
317 static int __init brcm_gisb_driver_init(void)
319 return platform_driver_register(&brcmstb_gisb_arb_driver);
322 module_init(brcm_gisb_driver_init);