12
13#include <machine/db_machdep.h>
14#include <machine/frame.h>
15#include <machine/trap.h>
16#ifdef PPC_IBM4XX
17#include <machine/tlb.h>
18#include <powerpc/spr.h>
19#include <uvm/uvm_extern.h>
20#endif
21
22#ifdef DDB
23#include <ddb/ddb.h>
24#include <ddb/db_sym.h>
25#include <ddb/db_command.h>
26#include <ddb/db_access.h>
27#include <ddb/db_output.h>
28#endif
29
30#ifdef KGDB
31#include <sys/kgdb.h>
32#endif
33
34#include <dev/ofw/openfirm.h>
35
36int db_active = 0;
37
38db_regs_t ddb_regs;
39
40void ddb_trap(void); /* Call into trap_subr.S */
41int ddb_trap_glue(struct trapframe *); /* Called from trap_subr.S */
42#ifdef PPC_IBM4XX
43static void db_ppc4xx_ctx(db_expr_t, int, db_expr_t, char *);
44static void db_ppc4xx_pv(db_expr_t, int, db_expr_t, char *);
45static void db_ppc4xx_reset(db_expr_t, int, db_expr_t, char *);
46static void db_ppc4xx_tf(db_expr_t, int, db_expr_t, char *);
47static void db_ppc4xx_dumptlb(db_expr_t, int, db_expr_t, char *);
48#ifdef USERACC
49static void db_ppc4xx_useracc(db_expr_t, int, db_expr_t, char *);
50#endif
51#endif /* PPC_IBM4XX */
52
53#ifdef DDB
54void
55Debugger(const char *msg)
56{
57 db_printf("Welcome to Debugger, %s\n", msg);
58 ddb_trap();
59}
60#endif
61
62int
63ddb_trap_glue(frame)
64 struct trapframe *frame;
65{
66 if (!(frame->srr1 & PSL_PR)
67 && (frame->exc == EXC_TRC || frame->exc == EXC_RUNMODETRC
68 || (frame->exc == EXC_PGM
69 && (frame->srr1 & 0x20000))
70 || frame->exc == EXC_BPT)) {
71 int type = frame->exc;
72 if (type == EXC_PGM && (frame->srr1 & 0x20000)) {
73 type = T_BREAKPOINT;
74 }
75 return kdb_trap(type, frame);
76 }
77 return 0;
78}
79
80int
81kdb_trap(type, v)
82 int type;
83 void *v;
84{
85 struct trapframe *frame = v;
86
87#if 0
88 switch (type) {
89 case T_BREAKPOINT:
90 case -1:
91 break;
92 default:
93 if (!db_onpanic && db_recover == 0)
94 return 0;
95 if (db_recover != 0) {
96 db_error("Faulted in DDB; continuing...\n");
97 /*NOTREACHED*/
98 }
99 }
100#endif
101
102 /* XXX Should switch to kdb's own stack here. */
103
104 memcpy(DDB_REGS->r, frame->fixreg, 32 * sizeof(u_int32_t));
105 DDB_REGS->iar = frame->srr0;
106 DDB_REGS->msr = frame->srr1;
107 DDB_REGS->lr = frame->lr;
108 DDB_REGS->ctr = frame->ctr;
109 DDB_REGS->cr = frame->cr;
110 DDB_REGS->xer = frame->xer;
111#ifdef PPC_IBM4XX
112 DDB_REGS->dear = frame->dear;
113 DDB_REGS->esr = frame->esr;
114 DDB_REGS->pid = frame->pid;
115#endif
116
117#ifdef DDB
118 db_active++;
119 cndbctl(1);
120 db_trap(type, 0);
121 cndbctl(0);
122 db_active--;
123#elif defined(KGDB)
124 if (!kgdb_trap(type, DDB_REGS))
125 return 0;
126#endif
127
128 /* KGDB isn't smart about advancing PC if we
129 * take a breakpoint trap after kgdb_active is set.
130 * Therefore, we help out here.
131 */
132 if (IS_BREAKPOINT_TRAP(type, 0)) {
133 int bkpt;
134 db_read_bytes(PC_REGS(DDB_REGS),BKPT_SIZE,(void *)&bkpt);
135 if (bkpt== BKPT_INST) {
136 PC_REGS(DDB_REGS) += BKPT_SIZE;
137 }
138 }
139
140 memcpy(frame->fixreg, DDB_REGS->r, 32 * sizeof(u_int32_t));
141 frame->srr0 = DDB_REGS->iar;
142 frame->srr1 = DDB_REGS->msr;
143 frame->lr = DDB_REGS->lr;
144 frame->ctr = DDB_REGS->ctr;
145 frame->cr = DDB_REGS->cr;
146 frame->xer = DDB_REGS->xer;
147#ifdef PPC_IBM4XX
148 frame->dear = DDB_REGS->dear;
149 frame->esr = DDB_REGS->esr;
150 frame->pid = DDB_REGS->pid;
151#endif
152
153 return 1;
154}
155
156#ifdef PPC_IBM4XX
157const struct db_command db_machine_command_table[] = {
158 { "ctx", db_ppc4xx_ctx, 0, 0 },
159 { "pv", db_ppc4xx_pv, 0, 0 },
160 { "reset", db_ppc4xx_reset, 0, 0 },
161 { "tf", db_ppc4xx_tf, 0, 0 },
162 { "tlb", db_ppc4xx_dumptlb, 0, 0 },
163#ifdef USERACC
164 { "user", db_ppc4xx_useracc, 0, 0 },
165#endif
166 { NULL, }
167};
168
169static void
170db_ppc4xx_ctx(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
171{
172 struct proc *p;
173
174 /* XXX LOCKING XXX */
175 for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
176 if (p->p_stat) {
177 db_printf("process %p:", p);
178 db_printf("pid:%d pmap:%p ctx:%d %s\n",
179 p->p_pid, p->p_vmspace->vm_map.pmap,
180 p->p_vmspace->vm_map.pmap->pm_ctx,
181 p->p_comm);
182 }
183 }
184 return;
185}
186
187static void
188db_ppc4xx_pv(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
189{
190 struct pv_entry {
191 struct pv_entry *pv_next; /* Linked list of mappings */
192 vaddr_t pv_va; /* virtual address of mapping */
193 struct pmap *pv_pm;
194 };
195 struct pv_entry *pa_to_pv(paddr_t);
196 struct pv_entry *pv;
197
198 if (!have_addr) {
199 db_printf("pv: <pa>\n");
200 return;
201 }
202 pv = pa_to_pv(addr);
203 db_printf("pv at %p\n", pv);
204 while (pv && pv->pv_pm) {
205 db_printf("next %p va %p pmap %p\n", pv->pv_next,
206 (void *)pv->pv_va, pv->pv_pm);
207 pv = pv->pv_next;
208 }
209}
210
211static void
212db_ppc4xx_reset(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
213{
214 printf("Reseting...\n");
215 ppc4xx_reset();
216}
217
218static void
219db_ppc4xx_tf(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
220{
221 struct trapframe *f;
222
223
224 if (have_addr) {
225 f = (struct trapframe *)addr;
226
227 db_printf("r0-r3: \t%8.8x %8.8x %8.8x %8.8x\n",
228 f->fixreg[0], f->fixreg[1],
229 f->fixreg[2], f->fixreg[3]);
230 db_printf("r4-r7: \t%8.8x %8.8x %8.8x %8.8x\n",
231 f->fixreg[4], f->fixreg[5],
232 f->fixreg[6], f->fixreg[7]);
233 db_printf("r8-r11: \t%8.8x %8.8x %8.8x %8.8x\n",
234 f->fixreg[8], f->fixreg[9],
235 f->fixreg[10], f->fixreg[11]);
236 db_printf("r12-r15:\t%8.8x %8.8x %8.8x %8.8x\n",
237 f->fixreg[12], f->fixreg[13],
238 f->fixreg[14], f->fixreg[15]);
239 db_printf("r16-r19:\t%8.8x %8.8x %8.8x %8.8x\n",
240 f->fixreg[16], f->fixreg[17],
241 f->fixreg[18], f->fixreg[19]);
242 db_printf("r20-r23:\t%8.8x %8.8x %8.8x %8.8x\n",
243 f->fixreg[20], f->fixreg[21],
244 f->fixreg[22], f->fixreg[23]);
245 db_printf("r24-r27:\t%8.8x %8.8x %8.8x %8.8x\n",
246 f->fixreg[24], f->fixreg[25],
247 f->fixreg[26], f->fixreg[27]);
248 db_printf("r28-r31:\t%8.8x %8.8x %8.8x %8.8x\n",
249 f->fixreg[28], f->fixreg[29],
250 f->fixreg[30], f->fixreg[31]);
251
252 db_printf("lr: %8.8x cr: %8.8x xer: %8.8x ctr: %8.8x\n",
253 f->lr, f->cr, f->xer, f->ctr);
254 db_printf("srr0(pc): %8.8x srr1(msr): %8.8x "
255 "dear: %8.8x esr: %8.8x\n",
256 f->srr0, f->srr1, f->dear, f->esr);
257 db_printf("exc: %8.8x pid: %8.8x\n",
258 f->exc, f->pid);
259 }
260 return;
261}
262
263static const char *const tlbsizes[] = {
264 "1kB",
265 "4kB",
266 "16kB",
267 "64kB",
268 "256kB",
269 "1MB",
270 "4MB",
271 "16MB"
272};
273
274static void
275db_ppc4xx_dumptlb(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
276{
277 int i, zone, tlbsize;
278 u_int zpr, pid, opid, msr;
279 u_long tlblo, tlbhi, tlbmask;
280
281 zpr = mfspr(SPR_ZPR);
282 for (i = 0; i < NTLB; i++) {
283 asm volatile("mfmsr %3;"
284 "mfpid %4;"
285 "li %0,0;"
286 "mtmsr %0;"
287 "sync; isync;"
288 "tlbre %0,%5,1;"
289 "tlbre %1,%5,0;"
290 "mfpid %2;"
291 "mtpid %4;"
292 "mtmsr %3;"
293 "sync; isync"
294 : "=&r" (tlblo), "=&r" (tlbhi), "=r" (pid),
295 "=&r" (msr), "=&r" (opid) : "r" (i));
296
297 if (strchr(modif, 'v') && !(tlbhi & TLB_VALID))
298 continue;
299
300 tlbsize = (tlbhi & TLB_SIZE_MASK) >> TLB_SIZE_SHFT;
301 /* map tlbsize 0 .. 7 to masks for 1kB .. 16MB */
302 tlbmask = ~(1 << (tlbsize * 2 + 10)) + 1;
303
304 if (have_addr && ((tlbhi & tlbmask) != (addr & tlbmask)))
305 continue;
306
307 zone = (tlblo & TLB_ZSEL_MASK) >> TLB_ZSEL_SHFT;
308 db_printf("tlb%c%2d", tlbhi & TLB_VALID ? ' ' : '*', i);
309 db_printf(" PID %3d EPN 0x%08lx %-5s",
310 pid,
311 tlbhi & tlbmask,
312 tlbsizes[tlbsize]);
313 db_printf(" RPN 0x%08lx ZONE %2d%c %s %s %c%c%c%c%c %s",
314 tlblo & tlbmask,
315 zone,
316 "NTTA"[(zpr >> ((15 - zone) * 2)) & 3],
317 tlblo & TLB_EX ? "EX" : " ",
318 tlblo & TLB_WR ? "WR" : " ",
319 tlblo & TLB_W ? 'W' : ' ',
320 tlblo & TLB_I ? 'I' : ' ',
321 tlblo & TLB_M ? 'M' : ' ',
322 tlblo & TLB_G ? 'G' : ' ',
323 tlbhi & TLB_ENDIAN ? 'E' : ' ',
324 tlbhi & TLB_U0 ? "U0" : " ");
325 db_printf("\n");
326 }
327}
328
329#ifdef USERACC
330static void
331db_ppc4xx_useracc(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
332{
333 static paddr_t oldaddr = -1;
334 int instr = 0;
335 int data;
336 extern vaddr_t opc_disasm(vaddr_t loc, int);
337
338
339 if (!have_addr) {
340 addr = oldaddr;
341 }
342 if (addr == -1) {
343 db_printf("no address\n");
344 return;
345 }
346 addr &= ~0x3; /* align */
347 {
348 register char c, *cp = modif;
349 while ((c = *cp++) != 0)
350 if (c == 'i')
351 instr = 1;
352 }
353 while (count--) {
354 if (db_print_position() == 0) {
355 /* Always print the address. */
356 db_printf("%8.4lx:\t", addr);
357 }
358 oldaddr=addr;
359 copyin((void *)addr, &data, sizeof(data));
360 if (instr) {
361 opc_disasm(addr, data);
362 } else {
363 db_printf("%4.4x\n", data);
364 }
365 addr += 4;
366 db_end_line();
367 }
368
369}
370#endif
371
372#endif /* PPC_IBM4XX */
373
374void
375db_show_mdpcpu(struct pcpu *pc)
376{
377}
| 13
14#include <machine/db_machdep.h>
15#include <machine/frame.h>
16#include <machine/trap.h>
17#ifdef PPC_IBM4XX
18#include <machine/tlb.h>
19#include <powerpc/spr.h>
20#include <uvm/uvm_extern.h>
21#endif
22
23#ifdef DDB
24#include <ddb/ddb.h>
25#include <ddb/db_sym.h>
26#include <ddb/db_command.h>
27#include <ddb/db_access.h>
28#include <ddb/db_output.h>
29#endif
30
31#ifdef KGDB
32#include <sys/kgdb.h>
33#endif
34
35#include <dev/ofw/openfirm.h>
36
37int db_active = 0;
38
39db_regs_t ddb_regs;
40
41void ddb_trap(void); /* Call into trap_subr.S */
42int ddb_trap_glue(struct trapframe *); /* Called from trap_subr.S */
43#ifdef PPC_IBM4XX
44static void db_ppc4xx_ctx(db_expr_t, int, db_expr_t, char *);
45static void db_ppc4xx_pv(db_expr_t, int, db_expr_t, char *);
46static void db_ppc4xx_reset(db_expr_t, int, db_expr_t, char *);
47static void db_ppc4xx_tf(db_expr_t, int, db_expr_t, char *);
48static void db_ppc4xx_dumptlb(db_expr_t, int, db_expr_t, char *);
49#ifdef USERACC
50static void db_ppc4xx_useracc(db_expr_t, int, db_expr_t, char *);
51#endif
52#endif /* PPC_IBM4XX */
53
54#ifdef DDB
55void
56Debugger(const char *msg)
57{
58 db_printf("Welcome to Debugger, %s\n", msg);
59 ddb_trap();
60}
61#endif
62
63int
64ddb_trap_glue(frame)
65 struct trapframe *frame;
66{
67 if (!(frame->srr1 & PSL_PR)
68 && (frame->exc == EXC_TRC || frame->exc == EXC_RUNMODETRC
69 || (frame->exc == EXC_PGM
70 && (frame->srr1 & 0x20000))
71 || frame->exc == EXC_BPT)) {
72 int type = frame->exc;
73 if (type == EXC_PGM && (frame->srr1 & 0x20000)) {
74 type = T_BREAKPOINT;
75 }
76 return kdb_trap(type, frame);
77 }
78 return 0;
79}
80
81int
82kdb_trap(type, v)
83 int type;
84 void *v;
85{
86 struct trapframe *frame = v;
87
88#if 0
89 switch (type) {
90 case T_BREAKPOINT:
91 case -1:
92 break;
93 default:
94 if (!db_onpanic && db_recover == 0)
95 return 0;
96 if (db_recover != 0) {
97 db_error("Faulted in DDB; continuing...\n");
98 /*NOTREACHED*/
99 }
100 }
101#endif
102
103 /* XXX Should switch to kdb's own stack here. */
104
105 memcpy(DDB_REGS->r, frame->fixreg, 32 * sizeof(u_int32_t));
106 DDB_REGS->iar = frame->srr0;
107 DDB_REGS->msr = frame->srr1;
108 DDB_REGS->lr = frame->lr;
109 DDB_REGS->ctr = frame->ctr;
110 DDB_REGS->cr = frame->cr;
111 DDB_REGS->xer = frame->xer;
112#ifdef PPC_IBM4XX
113 DDB_REGS->dear = frame->dear;
114 DDB_REGS->esr = frame->esr;
115 DDB_REGS->pid = frame->pid;
116#endif
117
118#ifdef DDB
119 db_active++;
120 cndbctl(1);
121 db_trap(type, 0);
122 cndbctl(0);
123 db_active--;
124#elif defined(KGDB)
125 if (!kgdb_trap(type, DDB_REGS))
126 return 0;
127#endif
128
129 /* KGDB isn't smart about advancing PC if we
130 * take a breakpoint trap after kgdb_active is set.
131 * Therefore, we help out here.
132 */
133 if (IS_BREAKPOINT_TRAP(type, 0)) {
134 int bkpt;
135 db_read_bytes(PC_REGS(DDB_REGS),BKPT_SIZE,(void *)&bkpt);
136 if (bkpt== BKPT_INST) {
137 PC_REGS(DDB_REGS) += BKPT_SIZE;
138 }
139 }
140
141 memcpy(frame->fixreg, DDB_REGS->r, 32 * sizeof(u_int32_t));
142 frame->srr0 = DDB_REGS->iar;
143 frame->srr1 = DDB_REGS->msr;
144 frame->lr = DDB_REGS->lr;
145 frame->ctr = DDB_REGS->ctr;
146 frame->cr = DDB_REGS->cr;
147 frame->xer = DDB_REGS->xer;
148#ifdef PPC_IBM4XX
149 frame->dear = DDB_REGS->dear;
150 frame->esr = DDB_REGS->esr;
151 frame->pid = DDB_REGS->pid;
152#endif
153
154 return 1;
155}
156
157#ifdef PPC_IBM4XX
158const struct db_command db_machine_command_table[] = {
159 { "ctx", db_ppc4xx_ctx, 0, 0 },
160 { "pv", db_ppc4xx_pv, 0, 0 },
161 { "reset", db_ppc4xx_reset, 0, 0 },
162 { "tf", db_ppc4xx_tf, 0, 0 },
163 { "tlb", db_ppc4xx_dumptlb, 0, 0 },
164#ifdef USERACC
165 { "user", db_ppc4xx_useracc, 0, 0 },
166#endif
167 { NULL, }
168};
169
170static void
171db_ppc4xx_ctx(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
172{
173 struct proc *p;
174
175 /* XXX LOCKING XXX */
176 for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
177 if (p->p_stat) {
178 db_printf("process %p:", p);
179 db_printf("pid:%d pmap:%p ctx:%d %s\n",
180 p->p_pid, p->p_vmspace->vm_map.pmap,
181 p->p_vmspace->vm_map.pmap->pm_ctx,
182 p->p_comm);
183 }
184 }
185 return;
186}
187
188static void
189db_ppc4xx_pv(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
190{
191 struct pv_entry {
192 struct pv_entry *pv_next; /* Linked list of mappings */
193 vaddr_t pv_va; /* virtual address of mapping */
194 struct pmap *pv_pm;
195 };
196 struct pv_entry *pa_to_pv(paddr_t);
197 struct pv_entry *pv;
198
199 if (!have_addr) {
200 db_printf("pv: <pa>\n");
201 return;
202 }
203 pv = pa_to_pv(addr);
204 db_printf("pv at %p\n", pv);
205 while (pv && pv->pv_pm) {
206 db_printf("next %p va %p pmap %p\n", pv->pv_next,
207 (void *)pv->pv_va, pv->pv_pm);
208 pv = pv->pv_next;
209 }
210}
211
212static void
213db_ppc4xx_reset(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
214{
215 printf("Reseting...\n");
216 ppc4xx_reset();
217}
218
219static void
220db_ppc4xx_tf(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
221{
222 struct trapframe *f;
223
224
225 if (have_addr) {
226 f = (struct trapframe *)addr;
227
228 db_printf("r0-r3: \t%8.8x %8.8x %8.8x %8.8x\n",
229 f->fixreg[0], f->fixreg[1],
230 f->fixreg[2], f->fixreg[3]);
231 db_printf("r4-r7: \t%8.8x %8.8x %8.8x %8.8x\n",
232 f->fixreg[4], f->fixreg[5],
233 f->fixreg[6], f->fixreg[7]);
234 db_printf("r8-r11: \t%8.8x %8.8x %8.8x %8.8x\n",
235 f->fixreg[8], f->fixreg[9],
236 f->fixreg[10], f->fixreg[11]);
237 db_printf("r12-r15:\t%8.8x %8.8x %8.8x %8.8x\n",
238 f->fixreg[12], f->fixreg[13],
239 f->fixreg[14], f->fixreg[15]);
240 db_printf("r16-r19:\t%8.8x %8.8x %8.8x %8.8x\n",
241 f->fixreg[16], f->fixreg[17],
242 f->fixreg[18], f->fixreg[19]);
243 db_printf("r20-r23:\t%8.8x %8.8x %8.8x %8.8x\n",
244 f->fixreg[20], f->fixreg[21],
245 f->fixreg[22], f->fixreg[23]);
246 db_printf("r24-r27:\t%8.8x %8.8x %8.8x %8.8x\n",
247 f->fixreg[24], f->fixreg[25],
248 f->fixreg[26], f->fixreg[27]);
249 db_printf("r28-r31:\t%8.8x %8.8x %8.8x %8.8x\n",
250 f->fixreg[28], f->fixreg[29],
251 f->fixreg[30], f->fixreg[31]);
252
253 db_printf("lr: %8.8x cr: %8.8x xer: %8.8x ctr: %8.8x\n",
254 f->lr, f->cr, f->xer, f->ctr);
255 db_printf("srr0(pc): %8.8x srr1(msr): %8.8x "
256 "dear: %8.8x esr: %8.8x\n",
257 f->srr0, f->srr1, f->dear, f->esr);
258 db_printf("exc: %8.8x pid: %8.8x\n",
259 f->exc, f->pid);
260 }
261 return;
262}
263
264static const char *const tlbsizes[] = {
265 "1kB",
266 "4kB",
267 "16kB",
268 "64kB",
269 "256kB",
270 "1MB",
271 "4MB",
272 "16MB"
273};
274
275static void
276db_ppc4xx_dumptlb(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
277{
278 int i, zone, tlbsize;
279 u_int zpr, pid, opid, msr;
280 u_long tlblo, tlbhi, tlbmask;
281
282 zpr = mfspr(SPR_ZPR);
283 for (i = 0; i < NTLB; i++) {
284 asm volatile("mfmsr %3;"
285 "mfpid %4;"
286 "li %0,0;"
287 "mtmsr %0;"
288 "sync; isync;"
289 "tlbre %0,%5,1;"
290 "tlbre %1,%5,0;"
291 "mfpid %2;"
292 "mtpid %4;"
293 "mtmsr %3;"
294 "sync; isync"
295 : "=&r" (tlblo), "=&r" (tlbhi), "=r" (pid),
296 "=&r" (msr), "=&r" (opid) : "r" (i));
297
298 if (strchr(modif, 'v') && !(tlbhi & TLB_VALID))
299 continue;
300
301 tlbsize = (tlbhi & TLB_SIZE_MASK) >> TLB_SIZE_SHFT;
302 /* map tlbsize 0 .. 7 to masks for 1kB .. 16MB */
303 tlbmask = ~(1 << (tlbsize * 2 + 10)) + 1;
304
305 if (have_addr && ((tlbhi & tlbmask) != (addr & tlbmask)))
306 continue;
307
308 zone = (tlblo & TLB_ZSEL_MASK) >> TLB_ZSEL_SHFT;
309 db_printf("tlb%c%2d", tlbhi & TLB_VALID ? ' ' : '*', i);
310 db_printf(" PID %3d EPN 0x%08lx %-5s",
311 pid,
312 tlbhi & tlbmask,
313 tlbsizes[tlbsize]);
314 db_printf(" RPN 0x%08lx ZONE %2d%c %s %s %c%c%c%c%c %s",
315 tlblo & tlbmask,
316 zone,
317 "NTTA"[(zpr >> ((15 - zone) * 2)) & 3],
318 tlblo & TLB_EX ? "EX" : " ",
319 tlblo & TLB_WR ? "WR" : " ",
320 tlblo & TLB_W ? 'W' : ' ',
321 tlblo & TLB_I ? 'I' : ' ',
322 tlblo & TLB_M ? 'M' : ' ',
323 tlblo & TLB_G ? 'G' : ' ',
324 tlbhi & TLB_ENDIAN ? 'E' : ' ',
325 tlbhi & TLB_U0 ? "U0" : " ");
326 db_printf("\n");
327 }
328}
329
330#ifdef USERACC
331static void
332db_ppc4xx_useracc(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
333{
334 static paddr_t oldaddr = -1;
335 int instr = 0;
336 int data;
337 extern vaddr_t opc_disasm(vaddr_t loc, int);
338
339
340 if (!have_addr) {
341 addr = oldaddr;
342 }
343 if (addr == -1) {
344 db_printf("no address\n");
345 return;
346 }
347 addr &= ~0x3; /* align */
348 {
349 register char c, *cp = modif;
350 while ((c = *cp++) != 0)
351 if (c == 'i')
352 instr = 1;
353 }
354 while (count--) {
355 if (db_print_position() == 0) {
356 /* Always print the address. */
357 db_printf("%8.4lx:\t", addr);
358 }
359 oldaddr=addr;
360 copyin((void *)addr, &data, sizeof(data));
361 if (instr) {
362 opc_disasm(addr, data);
363 } else {
364 db_printf("%4.4x\n", data);
365 }
366 addr += 4;
367 db_end_line();
368 }
369
370}
371#endif
372
373#endif /* PPC_IBM4XX */
374
375void
376db_show_mdpcpu(struct pcpu *pc)
377{
378}
|