d1bc12c61278b917556da56a4ed85941b8411efc
[linux-2.6.git] / arch / arm / mach-tegra / 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-2012, 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 #include <linux/kernel.h>
24 #include <linux/io.h>
25 #include <linux/interrupt.h>
26 #include <linux/spinlock.h>
27 #include <linux/stat.h>
28 #include <linux/sched.h>
29 #include <linux/debugfs.h>
30 #include <linux/seq_file.h>
31 #include <linux/moduleparam.h>
32 #include <linux/spinlock_types.h>
33
34 #include <mach/hardware.h>
35 #include <mach/iomap.h>
36 #include <mach/irqs.h>
37
38 #include "mcerr.h"
39
40 void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
41 #ifdef MC_DUAL_CHANNEL
42 void __iomem *mc1 = IO_ADDRESS(TEGRA_MC1_BASE);
43 #endif
44
45 static int arb_intr_mma_set(const char *arg, const struct kernel_param *kp);
46 static int arb_intr_mma_get(char *buff, const struct kernel_param *kp);
47 static void unthrottle_prints(struct work_struct *work);
48
49 #ifdef CONFIG_ARCH_TEGRA_11x_SOC
50 static int spurious_mc1_intr;
51 #endif
52
53 static struct arb_emem_intr_info arb_intr_info = {
54         .lock = __SPIN_LOCK_UNLOCKED(arb_intr_info.lock),
55 };
56 static int arb_intr_count;
57
58 static struct kernel_param_ops arb_intr_mma_ops = {
59         .get = arb_intr_mma_get,
60         .set = arb_intr_mma_set,
61 };
62
63 module_param_cb(arb_intr_mma_in_ms, &arb_intr_mma_ops,
64                 &arb_intr_info.arb_intr_mma, S_IRUGO | S_IWUSR);
65 module_param(arb_intr_count, int, S_IRUGO | S_IWUSR);
66 #ifdef CONFIG_ARCH_TEGRA_11x_SOC
67 module_param(spurious_mc1_intr, int, S_IRUGO | S_IWUSR);
68 #endif
69
70 static const char *const smmu_page_attrib[] = {
71         "SMMU: nr-nw-s",
72         "SMMU: nr-nw-ns",
73         "SMMU: nr-wr-s",
74         "SMMU: nr-wr-ns",
75         "SMMU: rd-nw-s",
76         "SMMU: rd-nw-ns",
77         "SMMU: rd-wr-s",
78         "SMMU: rd-wr-ns"
79 };
80
81 static DEFINE_SPINLOCK(mc_lock);
82 static unsigned long error_count;
83
84 static DECLARE_DELAYED_WORK(unthrottle_prints_work, unthrottle_prints);
85
86 static struct dentry *mcerr_debugfs_dir;
87
88 /*
89  * Chip specific functions.
90  */
91 static struct mcerr_chip_specific chip_specific;
92
93 static int arb_intr_mma_set(const char *arg, const struct kernel_param *kp)
94 {
95         int ret;
96         unsigned long flags;
97
98         spin_lock_irqsave(&arb_intr_info.lock, flags);
99         ret = param_set_int(arg, kp);
100         spin_unlock_irqrestore(&arb_intr_info.lock, flags);
101         return ret;
102 }
103
104 static int arb_intr_mma_get(char *buff, const struct kernel_param *kp)
105 {
106         return param_get_int(buff, kp);
107 }
108
109 static void arb_intr(void)
110 {
111         u64 time;
112         u32 time_diff_ms;
113         unsigned long flags;
114
115         spin_lock_irqsave(&arb_intr_info.lock, flags);
116         arb_intr_count++;
117         time = sched_clock();
118         time_diff_ms = (time - arb_intr_info.time) >> 20;
119         arb_intr_info.time = time;
120         arb_intr_info.arb_intr_mma =
121                 ((MMA_HISTORY_SAMPLES - 1) * time_diff_ms +
122                  arb_intr_info.arb_intr_mma) / MMA_HISTORY_SAMPLES;
123         spin_unlock_irqrestore(&arb_intr_info.lock, flags);
124 }
125
126 static void unthrottle_prints(struct work_struct *work)
127 {
128         unsigned long flags;
129
130         spin_lock_irqsave(&mc_lock, flags);
131         error_count = 0;
132         spin_unlock_irqrestore(&mc_lock, flags);
133 }
134
135 /*
136  * Common T3x/T11x MC error handling code.
137  */
138 static irqreturn_t tegra_mc_error_isr(int irq, void *data)
139 {
140         void __iomem *err_mc = mc;
141         struct mc_client *client = NULL;
142         const char *mc_type;
143         const char *mc_info;
144         unsigned long count;
145         u32 addr, err, stat;
146         u32 is_write, is_secure;
147         u32 client_id;
148
149         stat = readl(mc + MC_INT_STATUS) & MC_INT_EN_MASK;
150
151         __cancel_delayed_work(&unthrottle_prints_work);
152
153 #ifdef MC_DUAL_CHANNEL
154         /*
155          * Interrupts can come from either MC; handle the case in which the
156          * interrupt is generated by the second MC.
157          */
158         if (stat & MC_INT_EXT_INTR_IN) {
159                 err_mc = mc1;
160                 stat = readl(err_mc + MC_INT_STATUS);
161
162 #ifdef CONFIG_ARCH_TEGRA_11x_SOC
163                 /*
164                  * It appears like the secondary MC occasionally generates a
165                  * spurious interrupt. If so, just ignore this interrupt.
166                  */
167                 if (!stat) {
168                         spurious_mc1_intr++;
169                         goto out;
170                 }
171         }
172 #endif /* CONFIG_ARCH_TEGRA_11x_SOC */
173 #endif
174
175         if (stat & MC_INT_ARBITRATION_EMEM) {
176                 arb_intr();
177                 if (stat == MC_INT_ARBITRATION_EMEM)
178                         goto out;
179         }
180
181         spin_lock(&mc_lock);
182         count = ++error_count;
183         spin_unlock(&mc_lock);
184
185         err = readl(err_mc + MC_ERROR_STATUS);
186         addr = readl(err_mc + MC_ERROR_ADDRESS);
187         is_write = err & (1 << 16);
188         is_secure = err & (1 << 17);
189         client_id = err & 0x7f;
190         client = &mc_clients[client_id];
191
192         mc_type = chip_specific.mcerr_type(err);
193         mc_info = chip_specific.mcerr_info(stat);
194         chip_specific.mcerr_info_update(client, stat);
195
196         if (count >= MAX_PRINTS) {
197                 schedule_delayed_work(&unthrottle_prints_work, HZ/2);
198                 if (count == MAX_PRINTS)
199                         pr_err("Too many MC errors; throttling prints\n");
200                 goto out;
201         }
202
203         chip_specific.mcerr_print(mc_type, err, addr, client,
204                                   is_secure, is_write, mc_info);
205 out:
206         writel(stat, err_mc + MC_INT_STATUS);
207         if (err_mc != mc) {
208                 readl(err_mc + MC_INT_STATUS);
209                 writel(MC_INT_EXT_INTR_IN, mc + MC_INT_STATUS);
210         }
211         return IRQ_HANDLED;
212 }
213
214 /*
215  * Read the type of error that occured.
216  */
217 static const char *mcerr_default_type(u32 err)
218 {
219         u32 type = (err >> 28) & 0x7;
220         u32 attrib;
221
222         switch (type) {
223         case MC_ERR_DECERR_EMEM:
224                 return "DECERR_EMEM";
225         case MC_ERR_SECURITY_TRUSTZONE:
226                 return "SECURITY_TRUSTZONE";
227         case MC_ERR_SECURITY_CARVEOUT:
228                 return "SECURITY_CARVEOUT";
229         case MC_ERR_INVALID_SMMU_PAGE:
230                 attrib = (err >> 25) & 7;
231                 return smmu_page_attrib[attrib];
232         default:
233                 return "BAD";
234         }
235 }
236
237 static const char *mcerr_default_info(u32 stat)
238 {
239         if (stat & MC_INT_DECERR_EMEM)
240                 return "MC_DECERR";
241         else if (stat & MC_INT_SECURITY_VIOLATION)
242                 return "MC_SECURITY_ERR";
243         else if (stat & MC_INT_INVALID_SMMU_PAGE)
244                 return "MC_SMMU_ERR";
245         else
246                 return "unknown";
247 }
248
249 static void mcerr_default_info_update(struct mc_client *c, u32 stat)
250 {
251         if (stat & MC_INT_DECERR_EMEM)
252                 c->intr_counts[0]++;
253         else if (stat & MC_INT_SECURITY_VIOLATION)
254                 c->intr_counts[1]++;
255         else if (stat & MC_INT_INVALID_SMMU_PAGE)
256                 c->intr_counts[2]++;
257         else
258                 c->intr_counts[3]++;
259 }
260
261 static void mcerr_default_print(const char *mc_err, u32 err, u32 addr,
262                                 const struct mc_client *client, int is_secure,
263                                 int is_write, const char *mc_err_info)
264 {
265         pr_err("%s (0x%08X): %p %s (%s %s %s)\n", mc_err, err, (void *)addr,
266                (client) ? client->name : "unknown",
267                (is_secure) ? "secure" : "non-secure",
268                (is_write) ? "write" : "read",
269                mc_err_info);
270 }
271
272 /*
273  * Print the MC err stats for each client.
274  */
275 static int mcerr_default_debugfs_show(struct seq_file *s, void *v)
276 {
277         int i, j;
278         int do_print;
279
280         seq_printf(s, "%-24s %-9s %-9s %-9s %-9s\n", "client", "decerr",
281                    "secerr", "smmuerr", "unknown");
282         for (i = 0; i < chip_specific.nr_clients; i++) {
283                 do_print = 0;
284
285                 /* Only print clients who actually have errors. */
286                 for (j = 0; j < INTR_COUNT; j++) {
287                         if (mc_clients[i].intr_counts[j]) {
288                                 do_print = 1;
289                                 break;
290                         }
291                 }
292
293                 if (do_print)
294                         seq_printf(s, "%-24s %-9u %-9u %-9u %-9u\n",
295                                    mc_clients[i].name,
296                                    mc_clients[i].intr_counts[0],
297                                    mc_clients[i].intr_counts[1],
298                                    mc_clients[i].intr_counts[2],
299                                    mc_clients[i].intr_counts[3]);
300         }
301         return 0;
302 }
303
304 static int mcerr_debugfs_open(struct inode *inode, struct file *file)
305 {
306         return single_open(file, chip_specific.mcerr_debugfs_show, NULL);
307 }
308
309 static const struct file_operations mcerr_debugfs_fops = {
310         .open           = mcerr_debugfs_open,
311         .read           = seq_read,
312         .llseek         = seq_lseek,
313         .release        = single_release,
314 };
315
316 static int __init tegra_mcerr_init(void)
317 {
318         u32 reg;
319         int ret = 0;
320
321         reg = 0x0F7F1010;
322         writel(reg, mc + MC_RESERVED_RSV);
323
324 #if defined(CONFIG_TEGRA_MC_EARLY_ACK)
325         reg = readl(mc + MC_EMEM_ARB_OVERRIDE);
326         reg |= 3;
327 #if defined(CONFIG_TEGRA_ERRATA_1157520)
328         if (tegra_revision == TEGRA_REVISION_A01)
329                 reg &= ~2;
330 #endif
331         writel(reg, mc + MC_EMEM_ARB_OVERRIDE);
332 #endif
333
334         chip_specific.mcerr_type         = mcerr_default_type;
335         chip_specific.mcerr_info         = mcerr_default_info;
336         chip_specific.mcerr_info_update  = mcerr_default_info_update;
337         chip_specific.mcerr_print        = mcerr_default_print;
338         chip_specific.mcerr_debugfs_show = mcerr_default_debugfs_show;
339         chip_specific.nr_clients = 0;
340
341         /*
342          * mcerr_chip_specific_setup() can override any of the default
343          * functions as it wishes.
344          */
345         mcerr_chip_specific_setup(&chip_specific);
346
347         if (request_irq(INT_MC_GENERAL, tegra_mc_error_isr, 0,
348                         "mc_status", NULL)) {
349                 pr_err("%s: unable to register MC error interrupt\n", __func__);
350                 ret = -ENXIO;
351         } else {
352                 reg = MC_INT_EN_MASK;
353                 writel(reg, mc + MC_INT_MASK);
354         }
355
356         /*
357          * Init the debugfs node for reporting errors from the MC. If this
358          * fails thats a shame, but not a big enough deal to warrent failing
359          * the init of the MC itself.
360          */
361         mcerr_debugfs_dir = debugfs_create_dir("mc", NULL);
362         if (mcerr_debugfs_dir == NULL) {
363                 pr_err("Failed to make debugfs node: %ld\n",
364                        PTR_ERR(mcerr_debugfs_dir));
365                 goto done;
366         }
367         debugfs_create_file("mcerr", 0644, mcerr_debugfs_dir, NULL,
368                             &mcerr_debugfs_fops);
369 done:
370         return ret;
371 }
372 arch_initcall(tegra_mcerr_init);