Linux-2.6.12-rc2
[linux-2.6.git] / arch / sh64 / lib / dbg.c
1 /*--------------------------------------------------------------------------
2 --
3 -- Identity : Linux50 Debug Funcions
4 --
5 -- File     : arch/sh64/lib/dbg.C
6 --
7 -- Copyright 2000, 2001 STMicroelectronics Limited.
8 -- Copyright 2004 Richard Curnow (evt_debug etc)
9 --
10 --------------------------------------------------------------------------*/
11 #include <linux/config.h>
12 #include <linux/types.h>
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
15 #include <linux/mm.h>
16 #include <asm/mmu_context.h>
17
18 typedef u64 regType_t;
19
20 static regType_t getConfigReg(u64 id)
21 {
22         register u64 reg __asm__("r2");
23         asm volatile ("getcfg   %1, 0, %0":"=r" (reg):"r"(id));
24         return (reg);
25 }
26
27 /* ======================================================================= */
28
29 static char *szTab[] = { "4k", "64k", "1M", "512M" };
30 static char *protTab[] = { "----",
31         "---R",
32         "--X-",
33         "--XR",
34         "-W--",
35         "-W-R",
36         "-WX-",
37         "-WXR",
38         "U---",
39         "U--R",
40         "U-X-",
41         "U-XR",
42         "UW--",
43         "UW-R",
44         "UWX-",
45         "UWXR"
46 };
47 #define  ITLB_BASE      0x00000000
48 #define  DTLB_BASE      0x00800000
49 #define  MAX_TLBs               64
50 /* PTE High */
51 #define  GET_VALID(pte)        ((pte) & 0x1)
52 #define  GET_SHARED(pte)       ((pte) & 0x2)
53 #define  GET_ASID(pte)         ((pte >> 2) & 0x0ff)
54 #define  GET_EPN(pte)          ((pte) & 0xfffff000)
55
56 /* PTE Low */
57 #define  GET_CBEHAVIOR(pte)    ((pte) & 0x3)
58 #define  GET_PAGE_SIZE(pte)    szTab[((pte >> 3) & 0x3)]
59 #define  GET_PROTECTION(pte)   protTab[((pte >> 6) & 0xf)]
60 #define  GET_PPN(pte)          ((pte) & 0xfffff000)
61
62 #define PAGE_1K_MASK           0x00000000
63 #define PAGE_4K_MASK           0x00000010
64 #define PAGE_64K_MASK          0x00000080
65 #define MMU_PAGESIZE_MASK      (PAGE_64K_MASK | PAGE_4K_MASK)
66 #define PAGE_1MB_MASK          MMU_PAGESIZE_MASK
67 #define PAGE_1K                (1024)
68 #define PAGE_4K                (1024 * 4)
69 #define PAGE_64K               (1024 * 64)
70 #define PAGE_1MB               (1024 * 1024)
71
72 #define HOW_TO_READ_TLB_CONTENT  \
73        "[ ID]  PPN         EPN        ASID  Share  CB  P.Size   PROT.\n"
74
75 void print_single_tlb(unsigned long tlb, int single_print)
76 {
77         regType_t pteH;
78         regType_t pteL;
79         unsigned int valid, shared, asid, epn, cb, ppn;
80         char *pSize;
81         char *pProt;
82
83         /*
84            ** in case of single print <single_print> is true, this implies:
85            **   1) print the TLB in any case also if NOT VALID
86            **   2) print out the header
87          */
88
89         pteH = getConfigReg(tlb);
90         valid = GET_VALID(pteH);
91         if (single_print)
92                 printk(HOW_TO_READ_TLB_CONTENT);
93         else if (!valid)
94                 return;
95
96         pteL = getConfigReg(tlb + 1);
97
98         shared = GET_SHARED(pteH);
99         asid = GET_ASID(pteH);
100         epn = GET_EPN(pteH);
101         cb = GET_CBEHAVIOR(pteL);
102         pSize = GET_PAGE_SIZE(pteL);
103         pProt = GET_PROTECTION(pteL);
104         ppn = GET_PPN(pteL);
105         printk("[%c%2ld]  0x%08x  0x%08x  %03d   %02x    %02x   %4s    %s\n",
106                ((valid) ? ' ' : 'u'), ((tlb & 0x0ffff) / TLB_STEP),
107                ppn, epn, asid, shared, cb, pSize, pProt);
108 }
109
110 void print_dtlb(void)
111 {
112         int count;
113         unsigned long tlb;
114
115         printk(" ================= SH-5 D-TLBs Status ===================\n");
116         printk(HOW_TO_READ_TLB_CONTENT);
117         tlb = DTLB_BASE;
118         for (count = 0; count < MAX_TLBs; count++, tlb += TLB_STEP)
119                 print_single_tlb(tlb, 0);
120         printk
121             (" =============================================================\n");
122 }
123
124 void print_itlb(void)
125 {
126         int count;
127         unsigned long tlb;
128
129         printk(" ================= SH-5 I-TLBs Status ===================\n");
130         printk(HOW_TO_READ_TLB_CONTENT);
131         tlb = ITLB_BASE;
132         for (count = 0; count < MAX_TLBs; count++, tlb += TLB_STEP)
133                 print_single_tlb(tlb, 0);
134         printk
135             (" =============================================================\n");
136 }
137
138 /* ======================================================================= */
139
140 #ifdef CONFIG_POOR_MANS_STRACE
141
142 #include "syscalltab.h"
143
144 struct ring_node {
145         int evt;
146         int ret_addr;
147         int event;
148         int tra;
149         int pid;
150         unsigned long sp;
151         unsigned long pc;
152 };
153
154 static struct ring_node event_ring[16];
155 static int event_ptr = 0;
156
157 struct stored_syscall_data {
158         int pid;
159         int syscall_number;
160 };
161
162 #define N_STORED_SYSCALLS 16
163
164 static struct stored_syscall_data stored_syscalls[N_STORED_SYSCALLS];
165 static int syscall_next=0;
166 static int syscall_next_print=0;
167
168 void evt_debug(int evt, int ret_addr, int event, int tra, struct pt_regs *regs)
169 {
170         int syscallno = tra & 0xff;
171         unsigned long sp;
172         unsigned long stack_bottom;
173         int pid;
174         struct ring_node *rr;
175
176         pid = current->pid;
177         stack_bottom = (unsigned long) current->thread_info;
178         asm volatile("ori r15, 0, %0" : "=r" (sp));
179         rr = event_ring + event_ptr;
180         rr->evt = evt;
181         rr->ret_addr = ret_addr;
182         rr->event = event;
183         rr->tra = tra;
184         rr->pid = pid;
185         rr->sp = sp;
186         rr->pc = regs->pc;
187
188         if (sp < stack_bottom + 3092) {
189                 printk("evt_debug : stack underflow report\n");
190                 int i, j;
191                 for (j=0, i = event_ptr; j<16; j++) {
192                         rr = event_ring + i;
193                         printk("evt=%08x event=%08x tra=%08x pid=%5d sp=%08lx pc=%08lx\n",
194                                 rr->evt, rr->event, rr->tra, rr->pid, rr->sp, rr->pc);
195                         i--;
196                         i &= 15;
197                 }
198                 panic("STACK UNDERFLOW\n");
199         }
200
201         event_ptr = (event_ptr + 1) & 15;
202
203         if ((event == 2) && (evt == 0x160)) {
204                 if (syscallno < NUM_SYSCALL_INFO_ENTRIES) {
205                         /* Store the syscall information to print later.  We
206                          * can't print this now - currently we're running with
207                          * SR.BL=1, so we can't take a tlbmiss (which could occur
208                          * in the console drivers under printk).
209                          *
210                          * Just overwrite old entries on ring overflow - this
211                          * is only for last-hope debugging. */
212                         stored_syscalls[syscall_next].pid = current->pid;
213                         stored_syscalls[syscall_next].syscall_number = syscallno;
214                         syscall_next++;
215                         syscall_next &= (N_STORED_SYSCALLS - 1);
216                 }
217         }
218 }
219
220 static void drain_syscalls(void) {
221         while (syscall_next_print != syscall_next) {
222                 printk("Task %d: %s()\n",
223                         stored_syscalls[syscall_next_print].pid,
224                         syscall_info_table[stored_syscalls[syscall_next_print].syscall_number].name);
225                         syscall_next_print++;
226                         syscall_next_print &= (N_STORED_SYSCALLS - 1);
227         }
228 }
229
230 void evt_debug2(unsigned int ret)
231 {
232         drain_syscalls();
233         printk("Task %d: syscall returns %08x\n", current->pid, ret);
234 }
235
236 void evt_debug_ret_from_irq(struct pt_regs *regs)
237 {
238         int pid;
239         struct ring_node *rr;
240
241         pid = current->pid;
242         rr = event_ring + event_ptr;
243         rr->evt = 0xffff;
244         rr->ret_addr = 0;
245         rr->event = 0;
246         rr->tra = 0;
247         rr->pid = pid;
248         rr->pc = regs->pc;
249         event_ptr = (event_ptr + 1) & 15;
250 }
251
252 void evt_debug_ret_from_exc(struct pt_regs *regs)
253 {
254         int pid;
255         struct ring_node *rr;
256
257         pid = current->pid;
258         rr = event_ring + event_ptr;
259         rr->evt = 0xfffe;
260         rr->ret_addr = 0;
261         rr->event = 0;
262         rr->tra = 0;
263         rr->pid = pid;
264         rr->pc = regs->pc;
265         event_ptr = (event_ptr + 1) & 15;
266 }
267
268 #endif /* CONFIG_POOR_MANS_STRACE */
269
270 /* ======================================================================= */
271
272 void show_excp_regs(char *from, int trapnr, int signr, struct pt_regs *regs)
273 {
274
275         unsigned long long ah, al, bh, bl, ch, cl;
276
277         printk("\n");
278         printk("EXCEPTION - %s: task %d; Linux trap # %d; signal = %d\n",
279                ((from) ? from : "???"), current->pid, trapnr, signr);
280
281         asm volatile ("getcon   " __EXPEVT ", %0":"=r"(ah));
282         asm volatile ("getcon   " __EXPEVT ", %0":"=r"(al));
283         ah = (ah) >> 32;
284         al = (al) & 0xffffffff;
285         asm volatile ("getcon   " __KCR1 ", %0":"=r"(bh));
286         asm volatile ("getcon   " __KCR1 ", %0":"=r"(bl));
287         bh = (bh) >> 32;
288         bl = (bl) & 0xffffffff;
289         asm volatile ("getcon   " __INTEVT ", %0":"=r"(ch));
290         asm volatile ("getcon   " __INTEVT ", %0":"=r"(cl));
291         ch = (ch) >> 32;
292         cl = (cl) & 0xffffffff;
293         printk("EXPE: %08Lx%08Lx KCR1: %08Lx%08Lx INTE: %08Lx%08Lx\n",
294                ah, al, bh, bl, ch, cl);
295
296         asm volatile ("getcon   " __PEXPEVT ", %0":"=r"(ah));
297         asm volatile ("getcon   " __PEXPEVT ", %0":"=r"(al));
298         ah = (ah) >> 32;
299         al = (al) & 0xffffffff;
300         asm volatile ("getcon   " __PSPC ", %0":"=r"(bh));
301         asm volatile ("getcon   " __PSPC ", %0":"=r"(bl));
302         bh = (bh) >> 32;
303         bl = (bl) & 0xffffffff;
304         asm volatile ("getcon   " __PSSR ", %0":"=r"(ch));
305         asm volatile ("getcon   " __PSSR ", %0":"=r"(cl));
306         ch = (ch) >> 32;
307         cl = (cl) & 0xffffffff;
308         printk("PEXP: %08Lx%08Lx PSPC: %08Lx%08Lx PSSR: %08Lx%08Lx\n",
309                ah, al, bh, bl, ch, cl);
310
311         ah = (regs->pc) >> 32;
312         al = (regs->pc) & 0xffffffff;
313         bh = (regs->regs[18]) >> 32;
314         bl = (regs->regs[18]) & 0xffffffff;
315         ch = (regs->regs[15]) >> 32;
316         cl = (regs->regs[15]) & 0xffffffff;
317         printk("PC  : %08Lx%08Lx LINK: %08Lx%08Lx SP  : %08Lx%08Lx\n",
318                ah, al, bh, bl, ch, cl);
319
320         ah = (regs->sr) >> 32;
321         al = (regs->sr) & 0xffffffff;
322         asm volatile ("getcon   " __TEA ", %0":"=r"(bh));
323         asm volatile ("getcon   " __TEA ", %0":"=r"(bl));
324         bh = (bh) >> 32;
325         bl = (bl) & 0xffffffff;
326         asm volatile ("getcon   " __KCR0 ", %0":"=r"(ch));
327         asm volatile ("getcon   " __KCR0 ", %0":"=r"(cl));
328         ch = (ch) >> 32;
329         cl = (cl) & 0xffffffff;
330         printk("SR  : %08Lx%08Lx TEA : %08Lx%08Lx KCR0: %08Lx%08Lx\n",
331                ah, al, bh, bl, ch, cl);
332
333         ah = (regs->regs[0]) >> 32;
334         al = (regs->regs[0]) & 0xffffffff;
335         bh = (regs->regs[1]) >> 32;
336         bl = (regs->regs[1]) & 0xffffffff;
337         ch = (regs->regs[2]) >> 32;
338         cl = (regs->regs[2]) & 0xffffffff;
339         printk("R0  : %08Lx%08Lx R1  : %08Lx%08Lx R2  : %08Lx%08Lx\n",
340                ah, al, bh, bl, ch, cl);
341
342         ah = (regs->regs[3]) >> 32;
343         al = (regs->regs[3]) & 0xffffffff;
344         bh = (regs->regs[4]) >> 32;
345         bl = (regs->regs[4]) & 0xffffffff;
346         ch = (regs->regs[5]) >> 32;
347         cl = (regs->regs[5]) & 0xffffffff;
348         printk("R3  : %08Lx%08Lx R4  : %08Lx%08Lx R5  : %08Lx%08Lx\n",
349                ah, al, bh, bl, ch, cl);
350
351         ah = (regs->regs[6]) >> 32;
352         al = (regs->regs[6]) & 0xffffffff;
353         bh = (regs->regs[7]) >> 32;
354         bl = (regs->regs[7]) & 0xffffffff;
355         ch = (regs->regs[8]) >> 32;
356         cl = (regs->regs[8]) & 0xffffffff;
357         printk("R6  : %08Lx%08Lx R7  : %08Lx%08Lx R8  : %08Lx%08Lx\n",
358                ah, al, bh, bl, ch, cl);
359
360         ah = (regs->regs[9]) >> 32;
361         al = (regs->regs[9]) & 0xffffffff;
362         bh = (regs->regs[10]) >> 32;
363         bl = (regs->regs[10]) & 0xffffffff;
364         ch = (regs->regs[11]) >> 32;
365         cl = (regs->regs[11]) & 0xffffffff;
366         printk("R9  : %08Lx%08Lx R10 : %08Lx%08Lx R11 : %08Lx%08Lx\n",
367                ah, al, bh, bl, ch, cl);
368         printk("....\n");
369
370         ah = (regs->tregs[0]) >> 32;
371         al = (regs->tregs[0]) & 0xffffffff;
372         bh = (regs->tregs[1]) >> 32;
373         bl = (regs->tregs[1]) & 0xffffffff;
374         ch = (regs->tregs[2]) >> 32;
375         cl = (regs->tregs[2]) & 0xffffffff;
376         printk("T0  : %08Lx%08Lx T1  : %08Lx%08Lx T2  : %08Lx%08Lx\n",
377                ah, al, bh, bl, ch, cl);
378         printk("....\n");
379
380         print_dtlb();
381         print_itlb();
382 }
383
384 /* ======================================================================= */
385
386 /*
387 ** Depending on <base> scan the MMU, Data or Instrction side
388 ** looking for a valid mapping matching Eaddr & asid.
389 ** Return -1 if not found or the TLB id entry otherwise.
390 ** Note: it works only for 4k pages!
391 */
392 static unsigned long
393 lookup_mmu_side(unsigned long base, unsigned long Eaddr, unsigned long asid)
394 {
395         regType_t pteH;
396         unsigned long epn;
397         int count;
398
399         epn = Eaddr & 0xfffff000;
400
401         for (count = 0; count < MAX_TLBs; count++, base += TLB_STEP) {
402                 pteH = getConfigReg(base);
403                 if (GET_VALID(pteH))
404                         if ((unsigned long) GET_EPN(pteH) == epn)
405                                 if ((unsigned long) GET_ASID(pteH) == asid)
406                                         break;
407         }
408         return ((unsigned long) ((count < MAX_TLBs) ? base : -1));
409 }
410
411 unsigned long lookup_dtlb(unsigned long Eaddr)
412 {
413         unsigned long asid = get_asid();
414         return (lookup_mmu_side((u64) DTLB_BASE, Eaddr, asid));
415 }
416
417 unsigned long lookup_itlb(unsigned long Eaddr)
418 {
419         unsigned long asid = get_asid();
420         return (lookup_mmu_side((u64) ITLB_BASE, Eaddr, asid));
421 }
422
423 void print_page(struct page *page)
424 {
425         printk("  page[%p] -> index 0x%lx,  count 0x%x,  flags 0x%lx\n",
426                page, page->index, page_count(page), page->flags);
427         printk("       address_space = %p, pages =%ld\n", page->mapping,
428                page->mapping->nrpages);
429
430 }