ARM: tegra12: set CPU rate to 2.2GHz for sku 0x87
[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-2013, 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/spinlock_types.h>
35
36 #include <mach/mc.h>
37 #include <mach/irqs.h>
38 #include <mach/mcerr.h>
39
40 #include "iomap.h"
41
42 static bool mcerr_throttle_enabled = true;
43
44 static int arb_intr_mma_set(const char *arg, const struct kernel_param *kp);
45 static int arb_intr_mma_get(char *buff, const struct kernel_param *kp);
46 static void unthrottle_prints(struct work_struct *work);
47
48 static int spurious_intrs;
49
50 static struct arb_emem_intr_info arb_intr_info = {
51         .lock = __SPIN_LOCK_UNLOCKED(arb_intr_info.lock),
52 };
53 static int arb_intr_count;
54
55 static struct kernel_param_ops arb_intr_mma_ops = {
56         .get = arb_intr_mma_get,
57         .set = arb_intr_mma_set,
58 };
59
60 module_param_cb(arb_intr_mma_in_ms, &arb_intr_mma_ops,
61                 &arb_intr_info.arb_intr_mma, S_IRUGO | S_IWUSR);
62 module_param(arb_intr_count, int, S_IRUGO | S_IWUSR);
63 module_param(spurious_intrs, int, S_IRUGO | S_IWUSR);
64
65 static const char *const smmu_page_attrib[] = {
66         "nr-nw-s",
67         "nr-nw-ns",
68         "nr-wr-s",
69         "nr-wr-ns",
70         "rd-nw-s",
71         "rd-nw-ns",
72         "rd-wr-s",
73         "rd-wr-ns"
74 };
75
76 /*
77  * Table of known errors and their interrupt signatures.
78  */
79 static const struct mc_error mc_errors[] = {
80         MC_ERR(MC_INT_DECERR_EMEM,
81                "EMEM address decode error",
82                0, MC_ERR_STATUS, MC_ERR_ADR),
83         MC_ERR(MC_INT_DECERR_VPR,
84                "MC request violates VPR requirments",
85                0, MC_ERR_VPR_STATUS, MC_ERR_VPR_ADR),
86         MC_ERR(MC_INT_SECURITY_VIOLATION,
87                "non secure access to secure region",
88                0, MC_ERR_STATUS, MC_ERR_ADR),
89         MC_ERR(MC_INT_SECERR_SEC,
90                "MC request violated SEC carveout requirements",
91                0, MC_ERR_SEC_STATUS, MC_ERR_SEC_ADR),
92
93         /*
94          * SMMU related faults.
95          */
96         MC_ERR(MC_INT_INVALID_SMMU_PAGE,
97                "SMMU address translation fault",
98                E_SMMU, MC_ERR_STATUS, MC_ERR_ADR),
99         MC_ERR(MC_INT_INVALID_SMMU_PAGE | MC_INT_DECERR_EMEM,
100                "EMEM decode error on PDE or PTE entry",
101                E_SMMU, MC_ERR_STATUS, MC_ERR_ADR),
102         MC_ERR(MC_INT_INVALID_SMMU_PAGE | MC_INT_SECERR_SEC,
103                "secure SMMU address translation fault",
104                E_SMMU, MC_ERR_SEC_STATUS, MC_ERR_SEC_ADR),
105         MC_ERR(MC_INT_INVALID_SMMU_PAGE | MC_INT_DECERR_VPR,
106                "VPR SMMU address translation fault",
107                E_SMMU, MC_ERR_VPR_STATUS, MC_ERR_VPR_ADR),
108
109         /*
110          * Baseband controller related faults.
111          */
112         MC_ERR(MC_INT_BBC_PRIVATE_MEM_VIOLATION,
113                "client accessed BBC aperture",
114                0, MC_ERR_BBC_STATUS, MC_ERR_BBC_ADR),
115         MC_ERR(MC_INT_DECERR_BBC,
116                "BBC accessed memory outside of its aperture",
117                E_NO_STATUS, 0, 0),
118
119         /* NULL terminate. */
120         MC_ERR(0, NULL, 0, 0, 0),
121 };
122
123 static DEFINE_SPINLOCK(mc_lock);
124 static unsigned long error_count;
125
126 static DECLARE_DELAYED_WORK(unthrottle_prints_work, unthrottle_prints);
127
128 static struct dentry *mcerr_debugfs_dir;
129
130 /*
131  * Chip specific functions.
132  */
133 static struct mcerr_chip_specific chip_specific;
134
135 static int arb_intr_mma_set(const char *arg, const struct kernel_param *kp)
136 {
137         int ret;
138         unsigned long flags;
139
140         spin_lock_irqsave(&arb_intr_info.lock, flags);
141         ret = param_set_int(arg, kp);
142         spin_unlock_irqrestore(&arb_intr_info.lock, flags);
143         return ret;
144 }
145
146 static int arb_intr_mma_get(char *buff, const struct kernel_param *kp)
147 {
148         return param_get_int(buff, kp);
149 }
150
151 static void arb_intr(void)
152 {
153         u64 time;
154         u32 time_diff_ms;
155         unsigned long flags;
156
157         spin_lock_irqsave(&arb_intr_info.lock, flags);
158         arb_intr_count++;
159         time = sched_clock();
160         time_diff_ms = (time - arb_intr_info.time) >> 20;
161         arb_intr_info.time = time;
162         arb_intr_info.arb_intr_mma =
163                 ((MMA_HISTORY_SAMPLES - 1) * time_diff_ms +
164                  arb_intr_info.arb_intr_mma) / MMA_HISTORY_SAMPLES;
165         spin_unlock_irqrestore(&arb_intr_info.lock, flags);
166 }
167
168 static void unthrottle_prints(struct work_struct *work)
169 {
170         unsigned long flags;
171
172         spin_lock_irqsave(&mc_lock, flags);
173         error_count = 0;
174         spin_unlock_irqrestore(&mc_lock, flags);
175 }
176
177 /*
178  * Common MC error handling code.
179  */
180 static irqreturn_t tegra_mc_error_isr(int irq, void *data)
181 {
182         int err_mc = 0;
183         struct mc_client *client = NULL;
184         const struct mc_error *fault;
185         const char *smmu_info;
186         unsigned long count;
187         phys_addr_t addr;
188         u32 status, intr;
189         u32 write, secure;
190         u32 client_id;
191
192         intr = mc_readl(MC_INT_STATUS);
193
194         cancel_delayed_work(&unthrottle_prints_work);
195
196 #ifdef MC_DUAL_CHANNEL
197         /*
198          * Interrupts can come from either MC; handle the case in which the
199          * interrupt is generated by the second MC.
200          */
201         if (intr & MC_INT_EXT_INTR_IN) {
202                 err_mc = 1;
203                 intr = __mc_readl(err_mc, MC_INT_STATUS);
204         }
205 #endif
206
207         /*
208          * Sometimes the MC seems to generate spurious interrupts - that
209          * is interrupts with an interrupt status register equal to 0.
210          * Not much we can do other than keep a count of them.
211          */
212         if (!intr) {
213                 spurious_intrs++;
214                 goto out;
215         }
216
217         intr &= MC_INT_EN_MASK;
218         if (intr & MC_INT_ARBITRATION_EMEM) {
219                 arb_intr();
220                 if (intr == MC_INT_ARBITRATION_EMEM)
221                         goto out;
222                 intr &= ~MC_INT_ARBITRATION_EMEM;
223         }
224
225         spin_lock(&mc_lock);
226         count = ++error_count;
227         spin_unlock(&mc_lock);
228
229         fault = chip_specific.mcerr_info(intr & MC_INT_EN_MASK);
230         if (WARN(!fault, "[mcerr] Unknown error! intr sig: 0x%08x\n",
231                  intr & MC_INT_EN_MASK))
232                 goto out;
233
234         if (fault->flags & E_NO_STATUS) {
235                 pr_err("[mcerr] MC fault - no status: %s\n", fault->msg);
236                 goto out;
237         }
238
239         status = __mc_readl(err_mc, fault->stat_reg);
240         addr = __mc_readl(err_mc, fault->addr_reg);
241         secure = !!(status & MC_ERR_STATUS_SECURE);
242         write = !!(status & MC_ERR_STATUS_WRITE);
243         client_id = status & 0x7f;
244         client = &mc_clients[client_id <= mc_client_last
245                              ? client_id : mc_client_last];
246
247 #ifdef MC_ERR_34BIT_PHYS_ADDR
248         /*
249          * LPAE: make sure we get the extra 2 physical address bits available
250          * and pass them down to the printing function.
251          */
252         addr |= (((phys_addr_t)(status & MC_ERR_STATUS_ADR_HI)) << 12);
253 #endif
254
255         if (fault->flags & E_SMMU)
256                 smmu_info = smmu_page_attrib[MC_ERR_SMMU_BITS(status)];
257         else
258                 smmu_info = NULL;
259
260         chip_specific.mcerr_info_update(client, intr & MC_INT_EN_MASK);
261
262         if (mcerr_throttle_enabled && count >= MAX_PRINTS) {
263                 schedule_delayed_work(&unthrottle_prints_work, HZ/2);
264                 if (count == MAX_PRINTS)
265                         pr_err("Too many MC errors; throttling prints\n");
266                 goto out;
267         }
268
269         chip_specific.mcerr_print(fault, client, status, addr, secure, write,
270                                   smmu_info);
271 out:
272         __mc_writel(err_mc, intr, MC_INT_STATUS);
273         if (err_mc != 0) {
274                 __mc_readl(err_mc, MC_INT_STATUS);
275                 mc_writel(MC_INT_EXT_INTR_IN, MC_INT_STATUS);
276         }
277         return IRQ_HANDLED;
278 }
279
280 static const struct mc_error *mcerr_default_info(u32 intr)
281 {
282         const struct mc_error *err;
283
284         for (err = mc_errors; err->sig && err->msg; err++) {
285                 if (intr != err->sig)
286                         continue;
287                 return err;
288         }
289
290         return NULL;
291 }
292
293 static void mcerr_default_info_update(struct mc_client *c, u32 stat)
294 {
295         if (stat & MC_INT_DECERR_EMEM)
296                 c->intr_counts[0]++;
297         if (stat & MC_INT_SECURITY_VIOLATION)
298                 c->intr_counts[1]++;
299         if (stat & MC_INT_INVALID_SMMU_PAGE)
300                 c->intr_counts[2]++;
301
302         /* Unknown interrupts. */
303         if (stat & ~MC_INT_EN_MASK)
304                 c->intr_counts[3]++;
305 }
306
307 /*
308  * This will print at least 8 hex digits for address. If the address is bigger
309  * then more digits will be printed but the full 16 hex digits for a 64 bit
310  * address will not get printed by the current code.
311  */
312 static void mcerr_default_print(const struct mc_error *err,
313                                 const struct mc_client *client,
314                                 u32 status, phys_addr_t addr,
315                                 int secure, int rw, const char *smmu_info)
316 {
317         pr_err("[mcerr] (%s) %s: %s\n", client->swgid, client->name, err->msg);
318         pr_err("[mcerr]   status = 0x%08x; addr = 0x%08llx", status,
319                (long long unsigned int)addr);
320         pr_err("[mcerr]   secure: %s, access-type: %s, SMMU fault: %s\n",
321                secure ? "yes" : "no", rw ? "write" : "read",
322                smmu_info ? smmu_info : "none");
323 }
324
325 /*
326  * Print the MC err stats for each client.
327  */
328 static int mcerr_default_debugfs_show(struct seq_file *s, void *v)
329 {
330         int i, j;
331         int do_print;
332
333         seq_printf(s, "%-24s %-24s %-9s %-9s %-9s %-9s\n", "swgid", "client",
334                    "decerr", "secerr", "smmuerr", "unknown");
335         for (i = 0; i < chip_specific.nr_clients; i++) {
336                 do_print = 0;
337
338                 /* Only print clients who actually have errors. */
339                 for (j = 0; j < INTR_COUNT; j++) {
340                         if (mc_clients[i].intr_counts[j]) {
341                                 do_print = 1;
342                                 break;
343                         }
344                 }
345
346                 if (do_print)
347                         seq_printf(s, "%-24s %-24s %-9u %-9u %-9u %-9u\n",
348                                    mc_clients[i].name,
349                                    mc_clients[i].swgid,
350                                    mc_clients[i].intr_counts[0],
351                                    mc_clients[i].intr_counts[1],
352                                    mc_clients[i].intr_counts[2],
353                                    mc_clients[i].intr_counts[3]);
354         }
355         return 0;
356 }
357
358 static int mcerr_debugfs_open(struct inode *inode, struct file *file)
359 {
360         return single_open(file, chip_specific.mcerr_debugfs_show, NULL);
361 }
362
363 static const struct file_operations mcerr_debugfs_fops = {
364         .open           = mcerr_debugfs_open,
365         .read           = seq_read,
366         .llseek         = seq_lseek,
367         .release        = single_release,
368 };
369
370 static int __get_throttle(void *data, u64 *val)
371 {
372         *val = mcerr_throttle_enabled;
373         return 0;
374 }
375
376 static int __set_throttle(void *data, u64 val)
377 {
378         unsigned long flags;
379
380         spin_lock_irqsave(&mc_lock, flags);
381         error_count = 0;
382         spin_unlock_irqrestore(&mc_lock, flags);
383
384         mcerr_throttle_enabled = (bool) val;
385         return 0;
386 }
387 DEFINE_SIMPLE_ATTRIBUTE(mcerr_throttle_debugfs_fops, __get_throttle,
388                         __set_throttle, "%llu\n");
389
390 /*
391  * This will always e successful. However, if something goes wrong in the
392  * init a message will be printed to the kernel log. Since this is a
393  * non-essential piece of the kernel no reason to fail the entire MC init
394  * if this fails.
395  */
396 int __init tegra_mcerr_init(struct dentry *mc_parent)
397 {
398         u32 reg;
399
400         chip_specific.mcerr_info         = mcerr_default_info;
401         chip_specific.mcerr_info_update  = mcerr_default_info_update;
402         chip_specific.mcerr_print        = mcerr_default_print;
403         chip_specific.mcerr_debugfs_show = mcerr_default_debugfs_show;
404         chip_specific.nr_clients = 0;
405
406         /*
407          * mcerr_chip_specific_setup() can override any of the default
408          * functions as it wishes.
409          */
410         mcerr_chip_specific_setup(&chip_specific);
411
412         if (request_irq(INT_MC_GENERAL, tegra_mc_error_isr, 0,
413                         "mc_status", NULL)) {
414                 pr_err("%s: unable to register MC error interrupt\n", __func__);
415                 goto done;
416         } else {
417                 reg = MC_INT_EN_MASK;
418                 mc_writel(reg, MC_INT_MASK);
419         }
420
421         mcerr_debugfs_dir = debugfs_create_dir("err", mc_parent);
422         if (mcerr_debugfs_dir == NULL) {
423                 pr_err("Failed to make debugfs node: %ld\n",
424                        PTR_ERR(mcerr_debugfs_dir));
425                 goto done;
426         }
427         debugfs_create_file("mcerr", 0644, mcerr_debugfs_dir, NULL,
428                             &mcerr_debugfs_fops);
429         debugfs_create_file("mcerr_throttle", S_IRUGO | S_IWUSR,
430                             mcerr_debugfs_dir, NULL,
431                             &mcerr_throttle_debugfs_fops);
432
433         pr_info("Started MC error interface!\n");
434
435 done:
436         return 0;
437 }