platform: tegra: mc: handle dec and sec mc err combo
[linux-3.10.git] / drivers / platform / tegra / mc / mcerr.c
1 /*
2  * arch/arm/mach-tegra/mcerr.c
3  *
4  * MC error code common to T3x and T11x. T20 has been left alone.
5  *
6  * Copyright (c) 2010-2014, NVIDIA Corporation. All rights reserved.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with this program; if not, write to the Free Software Foundation, Inc.,
20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21  */
22
23 #define pr_fmt(fmt) "mc-err: " fmt
24
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/interrupt.h>
28 #include <linux/spinlock.h>
29 #include <linux/stat.h>
30 #include <linux/sched.h>
31 #include <linux/debugfs.h>
32 #include <linux/seq_file.h>
33 #include <linux/moduleparam.h>
34 #include <linux/platform_device.h>
35 #include <linux/of_irq.h>
36 #include <linux/atomic.h>
37
38 #include <linux/platform/tegra/mc.h>
39 #include <linux/platform/tegra/mcerr.h>
40
41 #define mcerr_pr(fmt, ...)                                      \
42         do {                                                    \
43                 if (!mcerr_silenced) {                          \
44                         trace_printk(fmt, ##__VA_ARGS__);       \
45                         pr_err(fmt, ##__VA_ARGS__);             \
46                 }                                               \
47         } while (0)
48
49 static bool mcerr_throttle_enabled = true;
50 static u32  mcerr_silenced;
51
52 static int arb_intr_mma_set(const char *arg, const struct kernel_param *kp);
53 static int arb_intr_mma_get(char *buff, const struct kernel_param *kp);
54 static void unthrottle_prints(struct work_struct *work);
55
56 static int spurious_intrs;
57
58 static struct arb_emem_intr_info arb_intr_info = {
59         .lock = __SPIN_LOCK_UNLOCKED(arb_intr_info.lock),
60 };
61 static int arb_intr_count;
62
63 static struct kernel_param_ops arb_intr_mma_ops = {
64         .get = arb_intr_mma_get,
65         .set = arb_intr_mma_set,
66 };
67
68 module_param_cb(arb_intr_mma_in_ms, &arb_intr_mma_ops,
69                 &arb_intr_info.arb_intr_mma, S_IRUGO | S_IWUSR);
70 module_param(arb_intr_count, int, S_IRUGO | S_IWUSR);
71 module_param(spurious_intrs, int, S_IRUGO | S_IWUSR);
72
73 static const char *const smmu_page_attrib[] = {
74         "nr-nw-s",
75         "nr-nw-ns",
76         "nr-wr-s",
77         "nr-wr-ns",
78         "rd-nw-s",
79         "rd-nw-ns",
80         "rd-wr-s",
81         "rd-wr-ns"
82 };
83
84 /*
85  * Table of known errors and their interrupt signatures.
86  */
87 static const struct mc_error mc_errors[] = {
88         MC_ERR(MC_INT_DECERR_EMEM,
89                "EMEM address decode error",
90                0, MC_ERR_STATUS, MC_ERR_ADR),
91         MC_ERR(MC_INT_DECERR_EMEM | MC_INT_SECURITY_VIOLATION,
92                "EMEM address decode error",
93                0, MC_ERR_STATUS, MC_ERR_ADR),
94         MC_ERR(MC_INT_DECERR_VPR,
95                "MC request violates VPR requirements",
96                0, MC_ERR_VPR_STATUS, MC_ERR_VPR_ADR),
97         MC_ERR(MC_INT_SECURITY_VIOLATION,
98                "non secure access to secure region",
99                0, MC_ERR_STATUS, MC_ERR_ADR),
100         MC_ERR(MC_INT_SECERR_SEC,
101                "MC request violated SEC carveout requirements",
102                0, MC_ERR_SEC_STATUS, MC_ERR_SEC_ADR),
103
104         /*
105          * SMMU related faults.
106          */
107         MC_ERR(MC_INT_INVALID_SMMU_PAGE,
108                "SMMU address translation fault",
109                E_SMMU, MC_ERR_STATUS, MC_ERR_ADR),
110         MC_ERR(MC_INT_INVALID_SMMU_PAGE | MC_INT_DECERR_EMEM,
111                "EMEM decode error on PDE or PTE entry",
112                E_SMMU, MC_ERR_STATUS, MC_ERR_ADR),
113         MC_ERR(MC_INT_INVALID_SMMU_PAGE | MC_INT_SECERR_SEC,
114                "secure SMMU address translation fault",
115                E_SMMU, MC_ERR_SEC_STATUS, MC_ERR_SEC_ADR),
116         MC_ERR(MC_INT_INVALID_SMMU_PAGE | MC_INT_DECERR_VPR,
117                "VPR SMMU address translation fault",
118                E_SMMU, MC_ERR_VPR_STATUS, MC_ERR_VPR_ADR),
119         MC_ERR(MC_INT_INVALID_SMMU_PAGE | MC_INT_DECERR_VPR |
120                MC_INT_DECERR_EMEM,
121                "EMEM decode error on PDE or PTE entry on VPR context",
122                E_SMMU, MC_ERR_VPR_STATUS, MC_ERR_VPR_ADR),
123
124         /*
125          * Baseband controller related faults.
126          */
127         MC_ERR(MC_INT_BBC_PRIVATE_MEM_VIOLATION,
128                "client accessed BBC aperture",
129                0, MC_ERR_BBC_STATUS, MC_ERR_BBC_ADR),
130         MC_ERR(MC_INT_DECERR_BBC,
131                "BBC accessed memory outside of its aperture",
132                E_NO_STATUS, 0, 0),
133
134         /*
135          * MTS access violation.
136          */
137         MC_ERR(MC_INT_DECERR_MTS,
138                "MTS carveout access violation",
139                0, MC_ERR_STATUS, MC_ERR_ADR),
140
141         /*
142          * Generalized carveouts.
143          */
144 #ifdef CONFIG_ARCH_TEGRA_21x_SOC
145         MC_ERR(MC_INT_DECERR_GENERALIZED_CARVEOUT,
146                "GSC access violation", 0,
147                MC_ERR_GENERALIZED_CARVEOUT_STATUS,
148                MC_ERR_GENERALIZED_CARVEOUT_ADR),
149         MC_ERR(MC_INT_DECERR_GENERALIZED_CARVEOUT | MC_INT_DECERR_EMEM,
150                "EMEM GSC access violation", 0,
151                MC_ERR_GENERALIZED_CARVEOUT_STATUS,
152                MC_ERR_GENERALIZED_CARVEOUT_ADR),
153 #endif
154
155         /*
156          * Miscellaneous errors.
157          */
158         MC_ERR(MC_INT_INVALID_APB_ASID_UPDATE,
159                "invalid APB ASID update", 0,
160                MC_ERR_STATUS, MC_ERR_ADR),
161
162         /* NULL terminate. */
163         MC_ERR(0, NULL, 0, 0, 0),
164 };
165
166 static atomic_t error_count;
167
168 static DECLARE_DELAYED_WORK(unthrottle_prints_work, unthrottle_prints);
169
170 static struct dentry *mcerr_debugfs_dir;
171
172 u32 mc_int_mask;
173 static u32 mc_intr;
174 static int err_channel;
175
176 /*
177  * Allow the top and bottom halfs of the MC error handlers to be overwritten.
178  */
179 irqreturn_t __weak tegra_mc_error_thread_ovr(int irq, void *data);
180 irqreturn_t __weak tegra_mc_error_hard_irq_ovr(int irq, void *data);
181
182 /*
183  * Chip specific functions.
184  */
185 static struct mcerr_chip_specific chip_specific;
186
187 static int arb_intr_mma_set(const char *arg, const struct kernel_param *kp)
188 {
189         int ret;
190         unsigned long flags;
191
192         spin_lock_irqsave(&arb_intr_info.lock, flags);
193         ret = param_set_int(arg, kp);
194         spin_unlock_irqrestore(&arb_intr_info.lock, flags);
195         return ret;
196 }
197
198 static int arb_intr_mma_get(char *buff, const struct kernel_param *kp)
199 {
200         return param_get_int(buff, kp);
201 }
202
203 static void arb_intr(void)
204 {
205         u64 time;
206         u32 time_diff_ms;
207         unsigned long flags;
208
209         spin_lock_irqsave(&arb_intr_info.lock, flags);
210         arb_intr_count++;
211         time = sched_clock();
212         time_diff_ms = (time - arb_intr_info.time) >> 20;
213         arb_intr_info.time = time;
214         arb_intr_info.arb_intr_mma =
215                 ((MMA_HISTORY_SAMPLES - 1) * time_diff_ms +
216                  arb_intr_info.arb_intr_mma) / MMA_HISTORY_SAMPLES;
217         spin_unlock_irqrestore(&arb_intr_info.lock, flags);
218 }
219
220 static void unthrottle_prints(struct work_struct *work)
221 {
222         atomic_set(&error_count, 0);
223 }
224
225 static void mcerr_info_update(struct mc_client *c, u32 stat)
226 {
227         int i;
228
229         for (i = 0; i < (sizeof(stat) * 8); i++) {
230                 if (stat & (1 << i))
231                         c->intr_counts[i]++;
232         }
233 }
234
235 /*
236  * Common MC error handling code.
237  */
238 static irqreturn_t tegra_mc_error_thread(int irq, void *data)
239 {
240         struct mc_client *client = NULL;
241         const struct mc_error *fault;
242         const char *smmu_info;
243         unsigned long count;
244         phys_addr_t addr;
245         u32 status, intr = mc_intr;
246         u32 write, secure;
247         u32 client_id;
248
249         cancel_delayed_work(&unthrottle_prints_work);
250
251         if (intr & MC_INT_ARBITRATION_EMEM) {
252                 arb_intr();
253                 if (intr == MC_INT_ARBITRATION_EMEM)
254                         goto out;
255                 intr &= ~MC_INT_ARBITRATION_EMEM;
256         }
257
258         count = atomic_inc_return(&error_count);
259
260         fault = chip_specific.mcerr_info(intr & mc_int_mask);
261         if (WARN(!fault, "Unknown error! intr sig: 0x%08x\n",
262                  intr & mc_int_mask))
263                 goto out;
264
265         if (fault->flags & E_NO_STATUS) {
266                 mcerr_pr("MC fault - no status: %s\n", fault->msg);
267                 goto out;
268         }
269
270         status = __mc_readl(err_channel, fault->stat_reg);
271         addr = __mc_readl(err_channel, fault->addr_reg);
272         secure = !!(status & MC_ERR_STATUS_SECURE);
273         write = !!(status & MC_ERR_STATUS_WRITE);
274         client_id = status & 0xff;
275         client = &mc_clients[client_id <= mc_client_last
276                              ? client_id : mc_client_last];
277
278         /*
279          * LPAE: make sure we get the extra 2 physical address bits available
280          * and pass them down to the printing function.
281          */
282         addr |= (((phys_addr_t)(status & MC_ERR_STATUS_ADR_HI)) << 12);
283
284         if (fault->flags & E_SMMU)
285                 smmu_info = smmu_page_attrib[MC_ERR_SMMU_BITS(status)];
286         else
287                 smmu_info = NULL;
288
289         mcerr_info_update(client, intr & mc_int_mask);
290
291         if (mcerr_throttle_enabled && count >= MAX_PRINTS) {
292                 schedule_delayed_work(&unthrottle_prints_work, HZ/2);
293                 if (count == MAX_PRINTS)
294                         mcerr_pr("Too many MC errors; throttling prints\n");
295                 goto out;
296         }
297
298         chip_specific.mcerr_print(fault, client, status, addr, secure, write,
299                                   smmu_info);
300 out:
301         mc_writel(intr, MC_INT_STATUS);
302         mc_readl(MC_INT_MASK);
303
304         mc_writel(mc_int_mask, MC_INT_MASK);
305         return IRQ_HANDLED;
306 }
307
308 /*
309  * The actual error handling takes longer than is ideal so this must be
310  * threaded.
311  */
312 static irqreturn_t tegra_mc_error_hard_irq(int irq, void *data)
313 {
314         u32 intr;
315
316         err_channel = 0;
317         intr = mc_readl(MC_INT_STATUS);
318
319         /*
320          * Sometimes the MC seems to generate spurious interrupts - that
321          * is interrupts with an interrupt status register equal to 0.
322          * Not much we can do other than keep a count of them.
323          */
324         if (!intr) {
325                 spurious_intrs++;
326                 return IRQ_NONE;
327         }
328
329         trace_printk("MCERR detected.\n");
330
331         /*
332          * We have an interrupt; disable the rest until this one is handled.
333          * This means we will potentially miss interrupts. We can live with
334          * that.
335          */
336         mc_writel(0, MC_INT_MASK);
337         mc_readl(MC_INT_STATUS);
338
339         mc_intr = intr & mc_int_mask;
340         return IRQ_WAKE_THREAD;
341 }
342
343 static const struct mc_error *mcerr_default_info(u32 intr)
344 {
345         const struct mc_error *err;
346
347         for (err = mc_errors; err->sig && err->msg; err++) {
348                 if (intr != err->sig)
349                         continue;
350                 return err;
351         }
352
353         return NULL;
354 }
355
356 void __weak smmu_dump_pagetable(int swgid, dma_addr_t addr)
357 {
358 }
359
360 /*
361  * This will print at least 8 hex digits for address. If the address is bigger
362  * then more digits will be printed but the full 16 hex digits for a 64 bit
363  * address will not get printed by the current code.
364  */
365 static void mcerr_default_print(const struct mc_error *err,
366                                 const struct mc_client *client,
367                                 u32 status, phys_addr_t addr,
368                                 int secure, int rw, const char *smmu_info)
369 {
370         if (smmu_info)
371                 smmu_dump_pagetable(client->swgid, addr);
372
373         mcerr_pr("(%d) %s: %s\n", client->swgid, client->name, err->msg);
374         mcerr_pr("  status = 0x%08x; addr = 0x%08llx\n", status,
375                  (long long unsigned int)addr);
376         mcerr_pr("  secure: %s, access-type: %s, SMMU fault: %s\n",
377                  secure ? "yes" : "no", rw ? "write" : "read",
378                  smmu_info ? smmu_info : "none");
379 }
380
381 /*
382  * Print the MC err stats for each client.
383  */
384 static int mcerr_default_debugfs_show(struct seq_file *s, void *v)
385 {
386         int i, j;
387         int do_print;
388
389         seq_printf(s, "%-18s %-18s", "swgroup", "client");
390         for (i = 0; i < (sizeof(u32) * 8); i++) {
391                 if (chip_specific.intr_descriptions[i])
392                         seq_printf(s, " %-12s",
393                                    chip_specific.intr_descriptions[i]);
394         }
395         seq_puts(s, "\n");
396
397         for (i = 0; i < chip_specific.nr_clients; i++) {
398                 do_print = 0;
399
400                 /* Only print clients who actually have errors. */
401                 for (j = 0; j < (sizeof(u32) * 8); j++) {
402                         if (chip_specific.intr_descriptions[j] &&
403                             mc_clients[i].intr_counts[j]) {
404                                 do_print = 1;
405                                 break;
406                         }
407                 }
408
409                 if (do_print) {
410                         seq_printf(s, "%-18s %-18s",
411                                    mc_clients[i].name,
412                                    mc_clients[i].swgroup);
413                         for (j = 0; j < (sizeof(u32) * 8); j++) {
414                                 if (!chip_specific.intr_descriptions[j])
415                                         continue;
416                                 seq_printf(s, " %-12u",
417                                            mc_clients[i].intr_counts[j]);
418                         }
419                         seq_puts(s, "\n");
420                 }
421         }
422
423         return 0;
424 }
425
426 static int mcerr_debugfs_open(struct inode *inode, struct file *file)
427 {
428         return single_open(file, chip_specific.mcerr_debugfs_show, NULL);
429 }
430
431 static const struct file_operations mcerr_debugfs_fops = {
432         .open           = mcerr_debugfs_open,
433         .read           = seq_read,
434         .llseek         = seq_lseek,
435         .release        = single_release,
436 };
437
438 static int __get_throttle(void *data, u64 *val)
439 {
440         *val = mcerr_throttle_enabled;
441         return 0;
442 }
443
444 static int __set_throttle(void *data, u64 val)
445 {
446         atomic_set(&error_count, 0);
447
448         mcerr_throttle_enabled = (bool) val;
449         return 0;
450 }
451 DEFINE_SIMPLE_ATTRIBUTE(mcerr_throttle_debugfs_fops, __get_throttle,
452                         __set_throttle, "%llu\n");
453
454 /*
455  * This will always e successful. However, if something goes wrong in the
456  * init a message will be printed to the kernel log. Since this is a
457  * non-essential piece of the kernel no reason to fail the entire MC init
458  * if this fails.
459  */
460 int tegra_mcerr_init(struct dentry *mc_parent, struct platform_device *pdev)
461 {
462         int irq;
463         const void *prop;
464
465         irqreturn_t (*irq_top)(int irq, void *data) =
466                 tegra_mc_error_hard_irq;
467         irqreturn_t (*irq_bot)(int irq, void *data) =
468                 tegra_mc_error_thread;
469
470         chip_specific.mcerr_info         = mcerr_default_info;
471         chip_specific.mcerr_print        = mcerr_default_print;
472         chip_specific.mcerr_debugfs_show = mcerr_default_debugfs_show;
473         chip_specific.nr_clients = 0;
474
475         /*
476          * mcerr_chip_specific_setup() can override any of the default
477          * functions as it wishes.
478          */
479         mcerr_chip_specific_setup(&chip_specific);
480         if (chip_specific.nr_clients == 0 ||
481             chip_specific.intr_descriptions == NULL) {
482                 pr_err("Missing necessary chip_specific functionality!\n");
483                 return -ENODEV;
484         }
485
486         if (tegra_mc_error_hard_irq_ovr)
487                 irq_top = tegra_mc_error_hard_irq_ovr;
488         if (tegra_mc_error_thread_ovr)
489                 irq_bot = tegra_mc_error_thread_ovr;
490
491         prop = of_get_property(pdev->dev.of_node, "int_mask", NULL);
492         if (!prop) {
493                 pr_err("No int_mask prop for mcerr!\n");
494                 return -EINVAL;
495         }
496
497         mc_int_mask = be32_to_cpup(prop);
498         mc_writel(mc_int_mask, MC_INT_MASK);
499
500         irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
501         if (irq < 0) {
502                 pr_err("Unable to parse/map MC error interrupt\n");
503                 goto done;
504         }
505
506         if (request_threaded_irq(irq, irq_top, irq_bot, 0, "mc_status", NULL)) {
507                 pr_err("Unable to register MC error interrupt\n");
508                 goto done;
509         }
510
511         if (!mc_parent)
512                 goto done;
513
514         mcerr_debugfs_dir = debugfs_create_dir("err", mc_parent);
515         if (mcerr_debugfs_dir == NULL) {
516                 pr_err("Failed to make debugfs node: %ld\n",
517                        PTR_ERR(mcerr_debugfs_dir));
518                 goto done;
519         }
520         debugfs_create_file("mcerr", 0644, mcerr_debugfs_dir, NULL,
521                             &mcerr_debugfs_fops);
522         debugfs_create_file("mcerr_throttle", S_IRUGO | S_IWUSR,
523                             mcerr_debugfs_dir, NULL,
524                             &mcerr_throttle_debugfs_fops);
525         debugfs_create_u32("quiet", 0644, mcerr_debugfs_dir, &mcerr_silenced);
526
527 done:
528         return 0;
529 }