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