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