1 /* 2 * Copyright (C) 2014 Broadcom Corporation 3 * 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. 7 * 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. 12 */ 13 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> 20 #include <linux/io.h> 21 #include <linux/string.h> 22 #include <linux/device.h> 23 #include <linux/list.h> 24 #include <linux/of.h> 25 #include <linux/bitops.h> 26 #include <linux/pm.h> 27 28 #ifdef CONFIG_ARM 29 #include <asm/bug.h> 30 #include <asm/signal.h> 31 #endif 32 33 #define ARB_ERR_CAP_CLEAR (1 << 0) 34 #define ARB_ERR_CAP_STATUS_TIMEOUT (1 << 12) 35 #define ARB_ERR_CAP_STATUS_TEA (1 << 11) 36 #define ARB_ERR_CAP_STATUS_BS_SHIFT (1 << 2) 37 #define ARB_ERR_CAP_STATUS_BS_MASK 0x3c 38 #define ARB_ERR_CAP_STATUS_WRITE (1 << 1) 39 #define ARB_ERR_CAP_STATUS_VALID (1 << 0) 40 41 enum { 42 ARB_TIMER, 43 ARB_ERR_CAP_CLR, 44 ARB_ERR_CAP_HI_ADDR, 45 ARB_ERR_CAP_ADDR, 46 ARB_ERR_CAP_DATA, 47 ARB_ERR_CAP_STATUS, 48 ARB_ERR_CAP_MASTER, 49 }; 50 51 static const int gisb_offsets_bcm7038[] = { 52 [ARB_TIMER] = 0x00c, 53 [ARB_ERR_CAP_CLR] = 0x0c4, 54 [ARB_ERR_CAP_HI_ADDR] = -1, 55 [ARB_ERR_CAP_ADDR] = 0x0c8, 56 [ARB_ERR_CAP_DATA] = 0x0cc, 57 [ARB_ERR_CAP_STATUS] = 0x0d0, 58 [ARB_ERR_CAP_MASTER] = -1, 59 }; 60 61 static const int gisb_offsets_bcm7400[] = { 62 [ARB_TIMER] = 0x00c, 63 [ARB_ERR_CAP_CLR] = 0x0c8, 64 [ARB_ERR_CAP_HI_ADDR] = -1, 65 [ARB_ERR_CAP_ADDR] = 0x0cc, 66 [ARB_ERR_CAP_DATA] = 0x0d0, 67 [ARB_ERR_CAP_STATUS] = 0x0d4, 68 [ARB_ERR_CAP_MASTER] = 0x0d8, 69 }; 70 71 static const int gisb_offsets_bcm7435[] = { 72 [ARB_TIMER] = 0x00c, 73 [ARB_ERR_CAP_CLR] = 0x168, 74 [ARB_ERR_CAP_HI_ADDR] = -1, 75 [ARB_ERR_CAP_ADDR] = 0x16c, 76 [ARB_ERR_CAP_DATA] = 0x170, 77 [ARB_ERR_CAP_STATUS] = 0x174, 78 [ARB_ERR_CAP_MASTER] = 0x178, 79 }; 80 81 static const int gisb_offsets_bcm7445[] = { 82 [ARB_TIMER] = 0x008, 83 [ARB_ERR_CAP_CLR] = 0x7e4, 84 [ARB_ERR_CAP_HI_ADDR] = 0x7e8, 85 [ARB_ERR_CAP_ADDR] = 0x7ec, 86 [ARB_ERR_CAP_DATA] = 0x7f0, 87 [ARB_ERR_CAP_STATUS] = 0x7f4, 88 [ARB_ERR_CAP_MASTER] = 0x7f8, 89 }; 90 91 struct brcmstb_gisb_arb_device { 92 void __iomem *base; 93 const int *gisb_offsets; 94 struct mutex lock; 95 struct list_head next; 96 u32 valid_mask; 97 const char *master_names[sizeof(u32) * BITS_PER_BYTE]; 98 u32 saved_timeout; 99 }; 100 101 static LIST_HEAD(brcmstb_gisb_arb_device_list); 102 103 static u32 gisb_read(struct brcmstb_gisb_arb_device *gdev, int reg) 104 { 105 int offset = gdev->gisb_offsets[reg]; 106 107 /* return 1 if the hardware doesn't have ARB_ERR_CAP_MASTER */ 108 if (offset == -1) 109 return 1; 110 111 return ioread32(gdev->base + offset); 112 } 113 114 static void gisb_write(struct brcmstb_gisb_arb_device *gdev, u32 val, int reg) 115 { 116 int offset = gdev->gisb_offsets[reg]; 117 118 if (offset == -1) 119 return; 120 iowrite32(val, gdev->base + reg); 121 } 122 123 static ssize_t gisb_arb_get_timeout(struct device *dev, 124 struct device_attribute *attr, 125 char *buf) 126 { 127 struct platform_device *pdev = to_platform_device(dev); 128 struct brcmstb_gisb_arb_device *gdev = platform_get_drvdata(pdev); 129 u32 timeout; 130 131 mutex_lock(&gdev->lock); 132 timeout = gisb_read(gdev, ARB_TIMER); 133 mutex_unlock(&gdev->lock); 134 135 return sprintf(buf, "%d", timeout); 136 } 137 138 static ssize_t gisb_arb_set_timeout(struct device *dev, 139 struct device_attribute *attr, 140 const char *buf, size_t count) 141 { 142 struct platform_device *pdev = to_platform_device(dev); 143 struct brcmstb_gisb_arb_device *gdev = platform_get_drvdata(pdev); 144 int val, ret; 145 146 ret = kstrtoint(buf, 10, &val); 147 if (ret < 0) 148 return ret; 149 150 if (val == 0 || val >= 0xffffffff) 151 return -EINVAL; 152 153 mutex_lock(&gdev->lock); 154 gisb_write(gdev, val, ARB_TIMER); 155 mutex_unlock(&gdev->lock); 156 157 return count; 158 } 159 160 static const char * 161 brcmstb_gisb_master_to_str(struct brcmstb_gisb_arb_device *gdev, 162 u32 masters) 163 { 164 u32 mask = gdev->valid_mask & masters; 165 166 if (hweight_long(mask) != 1) 167 return NULL; 168 169 return gdev->master_names[ffs(mask) - 1]; 170 } 171 172 static int brcmstb_gisb_arb_decode_addr(struct brcmstb_gisb_arb_device *gdev, 173 const char *reason) 174 { 175 u32 cap_status; 176 unsigned long arb_addr; 177 u32 master; 178 const char *m_name; 179 char m_fmt[11]; 180 181 cap_status = gisb_read(gdev, ARB_ERR_CAP_STATUS); 182 183 /* Invalid captured address, bail out */ 184 if (!(cap_status & ARB_ERR_CAP_STATUS_VALID)) 185 return 1; 186 187 /* Read the address and master */ 188 arb_addr = gisb_read(gdev, ARB_ERR_CAP_ADDR) & 0xffffffff; 189 #if (IS_ENABLED(CONFIG_PHYS_ADDR_T_64BIT)) 190 arb_addr |= (u64)gisb_read(gdev, ARB_ERR_CAP_HI_ADDR) << 32; 191 #endif 192 master = gisb_read(gdev, ARB_ERR_CAP_MASTER); 193 194 m_name = brcmstb_gisb_master_to_str(gdev, master); 195 if (!m_name) { 196 snprintf(m_fmt, sizeof(m_fmt), "0x%08x", master); 197 m_name = m_fmt; 198 } 199 200 pr_crit("%s: %s at 0x%lx [%c %s], core: %s\n", 201 __func__, reason, arb_addr, 202 cap_status & ARB_ERR_CAP_STATUS_WRITE ? 'W' : 'R', 203 cap_status & ARB_ERR_CAP_STATUS_TIMEOUT ? "timeout" : "", 204 m_name); 205 206 /* clear the GISB error */ 207 gisb_write(gdev, ARB_ERR_CAP_CLEAR, ARB_ERR_CAP_CLR); 208 209 return 0; 210 } 211 212 #ifdef CONFIG_ARM 213 static int brcmstb_bus_error_handler(unsigned long addr, unsigned int fsr, 214 struct pt_regs *regs) 215 { 216 int ret = 0; 217 struct brcmstb_gisb_arb_device *gdev; 218 219 /* iterate over each GISB arb registered handlers */ 220 list_for_each_entry(gdev, &brcmstb_gisb_arb_device_list, next) 221 ret |= brcmstb_gisb_arb_decode_addr(gdev, "bus error"); 222 /* 223 * If it was an imprecise abort, then we need to correct the 224 * return address to be _after_ the instruction. 225 */ 226 if (fsr & (1 << 10)) 227 regs->ARM_pc += 4; 228 229 return ret; 230 } 231 #endif 232 233 static irqreturn_t brcmstb_gisb_timeout_handler(int irq, void *dev_id) 234 { 235 brcmstb_gisb_arb_decode_addr(dev_id, "timeout"); 236 237 return IRQ_HANDLED; 238 } 239 240 static irqreturn_t brcmstb_gisb_tea_handler(int irq, void *dev_id) 241 { 242 brcmstb_gisb_arb_decode_addr(dev_id, "target abort"); 243 244 return IRQ_HANDLED; 245 } 246 247 static DEVICE_ATTR(gisb_arb_timeout, S_IWUSR | S_IRUGO, 248 gisb_arb_get_timeout, gisb_arb_set_timeout); 249 250 static struct attribute *gisb_arb_sysfs_attrs[] = { 251 &dev_attr_gisb_arb_timeout.attr, 252 NULL, 253 }; 254 255 static struct attribute_group gisb_arb_sysfs_attr_group = { 256 .attrs = gisb_arb_sysfs_attrs, 257 }; 258 259 static const struct of_device_id brcmstb_gisb_arb_of_match[] = { 260 { .compatible = "brcm,gisb-arb", .data = gisb_offsets_bcm7445 }, 261 { .compatible = "brcm,bcm7445-gisb-arb", .data = gisb_offsets_bcm7445 }, 262 { .compatible = "brcm,bcm7435-gisb-arb", .data = gisb_offsets_bcm7435 }, 263 { .compatible = "brcm,bcm7400-gisb-arb", .data = gisb_offsets_bcm7400 }, 264 { .compatible = "brcm,bcm7038-gisb-arb", .data = gisb_offsets_bcm7038 }, 265 { }, 266 }; 267 268 static int __init brcmstb_gisb_arb_probe(struct platform_device *pdev) 269 { 270 struct device_node *dn = pdev->dev.of_node; 271 struct brcmstb_gisb_arb_device *gdev; 272 const struct of_device_id *of_id; 273 struct resource *r; 274 int err, timeout_irq, tea_irq; 275 unsigned int num_masters, j = 0; 276 int i, first, last; 277 278 r = platform_get_resource(pdev, IORESOURCE_MEM, 0); 279 timeout_irq = platform_get_irq(pdev, 0); 280 tea_irq = platform_get_irq(pdev, 1); 281 282 gdev = devm_kzalloc(&pdev->dev, sizeof(*gdev), GFP_KERNEL); 283 if (!gdev) 284 return -ENOMEM; 285 286 mutex_init(&gdev->lock); 287 INIT_LIST_HEAD(&gdev->next); 288 289 gdev->base = devm_ioremap_resource(&pdev->dev, r); 290 if (IS_ERR(gdev->base)) 291 return PTR_ERR(gdev->base); 292 293 of_id = of_match_node(brcmstb_gisb_arb_of_match, dn); 294 if (!of_id) { 295 pr_err("failed to look up compatible string\n"); 296 return -EINVAL; 297 } 298 gdev->gisb_offsets = of_id->data; 299 300 err = devm_request_irq(&pdev->dev, timeout_irq, 301 brcmstb_gisb_timeout_handler, 0, pdev->name, 302 gdev); 303 if (err < 0) 304 return err; 305 306 err = devm_request_irq(&pdev->dev, tea_irq, 307 brcmstb_gisb_tea_handler, 0, pdev->name, 308 gdev); 309 if (err < 0) 310 return err; 311 312 /* If we do not have a valid mask, assume all masters are enabled */ 313 if (of_property_read_u32(dn, "brcm,gisb-arb-master-mask", 314 &gdev->valid_mask)) 315 gdev->valid_mask = 0xffffffff; 316 317 /* Proceed with reading the litteral names if we agree on the 318 * number of masters 319 */ 320 num_masters = of_property_count_strings(dn, 321 "brcm,gisb-arb-master-names"); 322 if (hweight_long(gdev->valid_mask) == num_masters) { 323 first = ffs(gdev->valid_mask) - 1; 324 last = fls(gdev->valid_mask) - 1; 325 326 for (i = first; i < last; i++) { 327 if (!(gdev->valid_mask & BIT(i))) 328 continue; 329 330 of_property_read_string_index(dn, 331 "brcm,gisb-arb-master-names", j, 332 &gdev->master_names[i]); 333 j++; 334 } 335 } 336 337 err = sysfs_create_group(&pdev->dev.kobj, &gisb_arb_sysfs_attr_group); 338 if (err) 339 return err; 340 341 platform_set_drvdata(pdev, gdev); 342 343 list_add_tail(&gdev->next, &brcmstb_gisb_arb_device_list); 344 345 #ifdef CONFIG_ARM 346 hook_fault_code(22, brcmstb_bus_error_handler, SIGBUS, 0, 347 "imprecise external abort"); 348 #endif 349 350 dev_info(&pdev->dev, "registered mem: %p, irqs: %d, %d\n", 351 gdev->base, timeout_irq, tea_irq); 352 353 return 0; 354 } 355 356 #ifdef CONFIG_PM_SLEEP 357 static int brcmstb_gisb_arb_suspend(struct device *dev) 358 { 359 struct platform_device *pdev = to_platform_device(dev); 360 struct brcmstb_gisb_arb_device *gdev = platform_get_drvdata(pdev); 361 362 gdev->saved_timeout = gisb_read(gdev, ARB_TIMER); 363 364 return 0; 365 } 366 367 /* Make sure we provide the same timeout value that was configured before, and 368 * do this before the GISB timeout interrupt handler has any chance to run. 369 */ 370 static int brcmstb_gisb_arb_resume_noirq(struct device *dev) 371 { 372 struct platform_device *pdev = to_platform_device(dev); 373 struct brcmstb_gisb_arb_device *gdev = platform_get_drvdata(pdev); 374 375 gisb_write(gdev, gdev->saved_timeout, ARB_TIMER); 376 377 return 0; 378 } 379 #else 380 #define brcmstb_gisb_arb_suspend NULL 381 #define brcmstb_gisb_arb_resume_noirq NULL 382 #endif 383 384 static const struct dev_pm_ops brcmstb_gisb_arb_pm_ops = { 385 .suspend = brcmstb_gisb_arb_suspend, 386 .resume_noirq = brcmstb_gisb_arb_resume_noirq, 387 }; 388 389 static struct platform_driver brcmstb_gisb_arb_driver = { 390 .driver = { 391 .name = "brcm-gisb-arb", 392 .of_match_table = brcmstb_gisb_arb_of_match, 393 .pm = &brcmstb_gisb_arb_pm_ops, 394 }, 395 }; 396 397 static int __init brcm_gisb_driver_init(void) 398 { 399 return platform_driver_probe(&brcmstb_gisb_arb_driver, 400 brcmstb_gisb_arb_probe); 401 } 402 403 module_init(brcm_gisb_driver_init); 404