/* ppc.c - core analysis suite

 *

 * Copyright (C) 1999, 2000, 2001, 2002 Mission Critical Linux, Inc.

 * Copyright (C) 2002-2007, 2010-2014 David Anderson

 * Copyright (C) 2002-2007, 2010-2014 Red Hat, Inc. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */ 

#ifdef PPC

#include "defs.h"

#include <elf.h>

#define MAX_PLATFORM_LEN	32	/* length for platform string */

/* 

 *  This structure was copied from kernel source

 *  in include/asm-ppc/ptrace.h

 */

struct ppc_pt_regs {

        long gpr[32];

        long nip;

        long msr;

        long orig_gpr3;      /* Used for restarting system calls */

        long ctr;

        long link;

        long xer;

        long ccr;

        long mq;             /* 601 only (not used at present) */

                                /* Used on APUS to hold IPL value. */

        long trap;           /* Reason for being here */

        long dar;            /* Fault registers */

        long dsisr;

        long result;         /* Result of a system call */

};

static int ppc_kvtop(struct task_context *, ulong, physaddr_t *, int);

static int ppc_uvtop(struct task_context *, ulong, physaddr_t *, int);

static ulong ppc_vmalloc_start(void);

static int ppc_is_task_addr(ulong);

static int ppc_verify_symbol(const char *, ulong, char);

static ulong ppc_get_task_pgd(ulong);

static int ppc_translate_pte(ulong, void *, ulonglong);

static ulong ppc_processor_speed(void);

static int ppc_eframe_search(struct bt_info *);

static ulong ppc_in_irqstack(ulong);

static void ppc_back_trace_cmd(struct bt_info *);

static void ppc_back_trace(struct gnu_request *, struct bt_info *);

static void get_ppc_frame(struct bt_info *, ulong *, ulong *);

static void ppc_print_stack_entry(int,struct gnu_request *,

	ulong, ulong, struct bt_info *);

static char *ppc_check_eframe(struct ppc_pt_regs *);

static void ppc_print_eframe(char *, struct ppc_pt_regs *, struct bt_info *);

static void ppc_print_regs(struct ppc_pt_regs *);

static void ppc_display_full_frame(struct bt_info *, ulong, FILE *);

static void ppc_dump_irq(int);

static void ppc_get_stack_frame(struct bt_info *, ulong *, ulong *);

static int ppc_dis_filter(ulong, char *, unsigned int);

static void ppc_cmd_mach(void);

static int ppc_get_smp_cpus(void);

static void ppc_display_machine_stats(void);

static void ppc_dump_line_number(ulong);

static struct line_number_hook ppc_line_number_hooks[];

static struct machine_specific ppc_machine_specific = { 0 };

static int probe_default_platform(char *);

static int probe_ppc44x_platform(char *);

static int probe_ppce500_platform(char *);

static void ppc_probe_base_platform(void);

typedef int (*probe_func_t) (char *);

probe_func_t probe_platforms[] = {

	probe_ppc44x_platform,	/* 44x chipsets */

	probe_ppce500_platform, /* E500 chipsets */

	probe_default_platform, /* This should be at the end */

	NULL

};

/* Don't forget page flags definitions for each platform */

#define PLATFORM_PAGE_FLAGS_SETUP(PLT)		\

do {						\

	_PAGE_PRESENT = PLT##_PAGE_PRESENT;	\

	_PAGE_USER = PLT##_PAGE_USER;		\

	_PAGE_RW = PLT##_PAGE_RW;		\

	_PAGE_GUARDED = PLT##_PAGE_GUARDED;	\

	_PAGE_COHERENT = PLT##_PAGE_COHERENT;	\

	_PAGE_NO_CACHE = PLT##_PAGE_NO_CACHE;	\

	_PAGE_WRITETHRU = PLT##_PAGE_WRITETHRU;	\

	_PAGE_DIRTY = PLT##_PAGE_DIRTY;		\

	_PAGE_ACCESSED = PLT##_PAGE_ACCESSED;	\

	_PAGE_HWWRITE = PLT##_PAGE_HWWRITE;	\

	_PAGE_SHARED = PLT##_PAGE_SHARED;	\

} while (0)

static int

probe_ppc44x_platform(char *name)

{

	/* 44x include ppc440* and ppc470 */

	if (STRNEQ(name, "ppc440") || STREQ(name, "ppc470")) {

		PPC_PLATFORM = strdup(name);

		PLATFORM_PAGE_FLAGS_SETUP(PPC44x);

		return TRUE;

	}

	return FALSE;

}

struct fsl_booke_tlbcam {

#define NUM_TLBCAMS	(64)

#define LAST_TLBCAM	(0x40)

	uint index;

	struct {

		ulong start;

		ulong limit;

		physaddr_t phys;

	} tlbcamrange;

	struct {

		uint MAS0;

		uint MAS1;

		ulong MAS2;

		uint MAS3;

		uint MAS7;

	} tlbcam;

};

static int

fsl_booke_vtop(ulong vaddr, physaddr_t *paddr, int verbose)

{

	struct fsl_booke_tlbcam *fsl_mmu;

	int i, found;

	if (CRASHDEBUG(1))

		fprintf(fp, "[Searching tlbcam address mapping]\n");

	fsl_mmu = MMU_SPECIAL;

	for (i = 0, found = FALSE;;i++, fsl_mmu++) {

		if (vaddr >= fsl_mmu->tlbcamrange.start &&

		    vaddr < fsl_mmu->tlbcamrange.limit) {

			*paddr = fsl_mmu->tlbcamrange.phys +

				 (vaddr - fsl_mmu->tlbcamrange.start);

			found = TRUE;

			break;

		}

		if (fsl_mmu->index & LAST_TLBCAM)

			break;

	}

	if (found && verbose) {

		/* TLBCAM segment attributes */

		fprintf(fp, "\n  TLBCAM[%u]: MAS0     MAS1     MAS2     "

			"MAS3     MAS7\n",

			(fsl_mmu->index & ~LAST_TLBCAM));

		fprintf(fp, "             %-8x %-8x %-8lx %-8x %-8x\n",

			fsl_mmu->tlbcam.MAS0, fsl_mmu->tlbcam.MAS1,

			fsl_mmu->tlbcam.MAS2, fsl_mmu->tlbcam.MAS3,

			fsl_mmu->tlbcam.MAS7);

		/* TLBCAM range */

		fprintf(fp, "             VIRTUAL RANGE : %lx - %lx\n",

			fsl_mmu->tlbcamrange.start, fsl_mmu->tlbcamrange.limit);

		fprintf(fp, "             PHYSICAL RANGE: %llx - %llx\n",

			fsl_mmu->tlbcamrange.phys,

			fsl_mmu->tlbcamrange.phys + (fsl_mmu->tlbcamrange.limit

				- fsl_mmu->tlbcamrange.start));

		/* translated addr and its tlbcam's offset. */

		fprintf(fp, "  => VIRTUAL  PHYSICAL TLBCAM-OFFSET\n");

		fprintf(fp, "     %-8lx %-8llx %lu\n", vaddr, *paddr,

			vaddr - fsl_mmu->tlbcamrange.start);

	}

	if (CRASHDEBUG(1))

		fprintf(fp, "[tlbcam search end]\n");

	return found;

}

static void

fsl_booke_mmu_setup(void)

{

	struct fsl_booke_tlbcam *fsl_mmu;

	uint i, tlbcam_index;

	ulong tlbcam_addrs, TLBCAM;

	readmem(symbol_value("tlbcam_index"), KVADDR, &tlbcam_index,

		sizeof(uint), "tlbcam_index", FAULT_ON_ERROR);

	if (tlbcam_index != 0 && tlbcam_index < NUM_TLBCAMS) {

		fsl_mmu = calloc(tlbcam_index, sizeof(*fsl_mmu));

		if (!fsl_mmu) {

			error(FATAL, "fsl_mmu calloc() failed\n");

			return;

		}

		tlbcam_addrs = symbol_value("tlbcam_addrs");

		TLBCAM = symbol_value("TLBCAM");

		for (i = 0; i < tlbcam_index; i++) {

			fsl_mmu[i].index = i;

			readmem(tlbcam_addrs +

					i * sizeof(fsl_mmu[i].tlbcamrange),

				KVADDR, &fsl_mmu[i].tlbcamrange,

				sizeof(fsl_mmu[i].tlbcamrange), "tlbcam_addrs",

				FAULT_ON_ERROR);

			readmem(TLBCAM + i * sizeof(fsl_mmu[i].tlbcam), KVADDR,

				&fsl_mmu[i].tlbcam, sizeof(fsl_mmu[i].tlbcam),

				"TLBCAM", FAULT_ON_ERROR);

		}

		fsl_mmu[i - 1].index |= LAST_TLBCAM;

		MMU_SPECIAL = fsl_mmu;

		VTOP_SPECIAL = fsl_booke_vtop;

	} else

		error(INFO, "[%s]: can't setup tlbcam: tlbcam_index=%u\n",

			PPC_PLATFORM, tlbcam_index);

}

static int

probe_ppce500_platform(char *name)

{

	if (STRNEQ(name, "ppce500mc")) {

		PPC_PLATFORM = strdup(name);

		if (IS_PAE()) {

			PTE_RPN_SHIFT = BOOKE3E_PTE_RPN_SHIFT;

			PLATFORM_PAGE_FLAGS_SETUP(BOOK3E);

			/* Set special flag for book3e */

			_PAGE_K_RW = BOOK3E_PAGE_KERNEL_RW;

		} else

			PLATFORM_PAGE_FLAGS_SETUP(FSL_BOOKE);

		fsl_booke_mmu_setup();

		return TRUE;

	}

	return FALSE;

}

static int

probe_default_platform(char *name)

{

	if (IS_PAE()) {

		error(INFO, "platform \"%s\" 64bit PTE fall through\n", name);

		error(INFO, "vmalloc translation could not work!\n");

	}

	/* Use the default definitions */

	PPC_PLATFORM = strdup(name);

	PLATFORM_PAGE_FLAGS_SETUP(DEFAULT);

	return TRUE;

}

#undef PLATFORM_PAGE_FLAGS_SETUP

/*

 * Find the platform of the crashing system and set the

 * base_platform accordingly.

 */

void

ppc_probe_base_platform(void)

{

	probe_func_t probe;

	char platform_name[MAX_PLATFORM_LEN];

	ulong ptr;

	int i;

	if(!try_get_symbol_data("powerpc_base_platform", sizeof(ulong), &ptr) ||

		read_string(ptr, platform_name, MAX_PLATFORM_LEN - 1) == 0)

		/* Let us fallback to default definitions */

		strcpy(platform_name, "(unknown)");

	for (i = 0; probe_platforms[i] != NULL; i++) {

		probe = probe_platforms[i];

		if (probe(platform_name))

			break;

	}

}

/*

 *  Do all necessary machine-specific setup here.  This is called twice,

 *  before and after GDB has been initialized.

 */

void

ppc_init(int when)

{

	uint cpu_features;

	ulong cur_cpu_spec;

	struct datatype_member pte = {

		.name = "pte_t",

	};

	switch (when)

	{

	case SETUP_ENV:

		machdep->machspec = &ppc_machine_specific;

		machdep->process_elf_notes = process_elf32_notes;

		break;

	case PRE_SYMTAB:

		machdep->verify_symbol = ppc_verify_symbol;

                if (pc->flags & KERNEL_DEBUG_QUERY)

                        return;

                machdep->pagesize = memory_page_size();

                machdep->pageshift = ffs(machdep->pagesize) - 1;

                machdep->pageoffset = machdep->pagesize - 1;

                machdep->pagemask = ~((ulonglong)machdep->pageoffset);

		machdep->stacksize = PPC_STACK_SIZE;

                if ((machdep->pgd = (char *)malloc(PAGESIZE())) == NULL)

                        error(FATAL, "cannot malloc pgd space.");

                machdep->pmd = machdep->pgd;

                if ((machdep->ptbl = (char *)malloc(PAGESIZE())) == NULL)

                        error(FATAL, "cannot malloc ptbl space.");

                machdep->last_pgd_read = 0;

                machdep->last_pmd_read = 0;

                machdep->last_ptbl_read = 0;

		machdep->verify_paddr = generic_verify_paddr;

		break;

	case PRE_GDB:

	        machdep->kvbase = symbol_value("_stext");

		machdep->identity_map_base = machdep->kvbase;

                machdep->is_kvaddr = generic_is_kvaddr;

                machdep->is_uvaddr = generic_is_uvaddr;

	        machdep->eframe_search = ppc_eframe_search;

	        machdep->back_trace = ppc_back_trace_cmd;

	        machdep->processor_speed = ppc_processor_speed;

	        machdep->uvtop = ppc_uvtop;

	        machdep->kvtop = ppc_kvtop;

	        machdep->get_task_pgd = ppc_get_task_pgd;

		machdep->get_stack_frame = ppc_get_stack_frame;

		machdep->get_stackbase = generic_get_stackbase;

		machdep->get_stacktop = generic_get_stacktop;

		machdep->translate_pte = ppc_translate_pte;

		machdep->memory_size = generic_memory_size;

		machdep->is_task_addr = ppc_is_task_addr;

		machdep->dis_filter = ppc_dis_filter;

		machdep->cmd_mach = ppc_cmd_mach;

		machdep->get_smp_cpus = ppc_get_smp_cpus;

		machdep->line_number_hooks = ppc_line_number_hooks;

		machdep->value_to_symbol = generic_machdep_value_to_symbol;

                machdep->init_kernel_pgd = NULL;

		break;

	case POST_GDB:

		/* gdb interface got available, resolve PTE right now. */

		PTE_SIZE = DATATYPE_SIZE(&pte);

		if (PTE_SIZE < 0)

			error(FATAL,

			      "gdb could not handle \"pte_t\" size request\n");

		/* Check if we have 64bit PTE on 32bit system */

		if (PTE_SIZE == sizeof(ulonglong))

			machdep->flags |= PAE;

		/* Find the platform where we crashed */

		ppc_probe_base_platform();

		if (!PTE_RPN_SHIFT)

			PTE_RPN_SHIFT = PAGE_SHIFT;

		machdep->vmalloc_start = ppc_vmalloc_start;

		MEMBER_OFFSET_INIT(thread_struct_pg_tables, 

 			"thread_struct", "pg_tables");

		if (VALID_SIZE(irq_desc_t)) {

			/*

			 * Use generic irq handlers for recent kernels whose

			 * irq_desc_t have been initialized in kernel_init().

			 */

			machdep->dump_irq = generic_dump_irq;

			machdep->show_interrupts = generic_show_interrupts;

			machdep->get_irq_affinity = generic_get_irq_affinity;

		} else {

			machdep->dump_irq = ppc_dump_irq;

			STRUCT_SIZE_INIT(irqdesc, "irqdesc");

			STRUCT_SIZE_INIT(irq_desc_t, "irq_desc_t");

			MEMBER_OFFSET_INIT(irqdesc_action, "irqdesc", "action");

			MEMBER_OFFSET_INIT(irqdesc_ctl, "irqdesc", "ctl");

			MEMBER_OFFSET_INIT(irqdesc_level, "irqdesc", "level");

		}

                MEMBER_OFFSET_INIT(device_node_type, "device_node", "type");

                MEMBER_OFFSET_INIT(device_node_allnext,  

			"device_node", "allnext");

                MEMBER_OFFSET_INIT(device_node_properties,  

			"device_node", "properties");

		MEMBER_OFFSET_INIT(property_name, "property", "name");

		MEMBER_OFFSET_INIT(property_value, "property", "value");

		MEMBER_OFFSET_INIT(property_next, "property", "next");

		MEMBER_OFFSET_INIT(machdep_calls_setup_residual, 

                        "machdep_calls", "setup_residual");

		MEMBER_OFFSET_INIT(RESIDUAL_VitalProductData, 

                        "RESIDUAL", "VitalProductData");

		MEMBER_OFFSET_INIT(VPD_ProcessorHz, "VPD", "ProcessorHz");

		MEMBER_OFFSET_INIT(bd_info_bi_intfreq, "bd_info", "bi_intfreq");

		if (symbol_exists("irq_desc"))

			ARRAY_LENGTH_INIT(machdep->nr_irqs, irq_desc,

				"irq_desc", NULL, 0);

		else if (symbol_exists("nr_irqs"))

			get_symbol_data("nr_irqs", sizeof(int),

					&machdep->nr_irqs);

		else

			machdep->nr_irqs = 512; /* NR_IRQS (at least) */

		if (!machdep->hz) {

			machdep->hz = HZ;

			if (THIS_KERNEL_VERSION >= LINUX(2,6,0))

				machdep->hz = 1000;

		}

		if (symbol_exists("cur_cpu_spec")) {

			get_symbol_data("cur_cpu_spec", sizeof(void *), &cur_cpu_spec);

			readmem(cur_cpu_spec + MEMBER_OFFSET("cpu_spec", "cpu_user_features"), 

				KVADDR, &cpu_features, sizeof(uint), "cpu user features",

				FAULT_ON_ERROR);

			if (cpu_features & CPU_BOOKE)

				machdep->flags |= CPU_BOOKE;

		}

		else

			machdep->flags |= CPU_BOOKE;

		machdep->section_size_bits = _SECTION_SIZE_BITS;

		machdep->max_physmem_bits = _MAX_PHYSMEM_BITS;

		/*

		 * IRQ stacks are introduced in 2.6 and also configurable.

		 */

		if ((THIS_KERNEL_VERSION >= LINUX(2,6,0)) &&

			symbol_exists("hardirq_ctx"))

			STRUCT_SIZE_INIT(irq_ctx, "hardirq_ctx");

		STRUCT_SIZE_INIT(note_buf, "note_buf_t");

		STRUCT_SIZE_INIT(elf_prstatus, "elf_prstatus");

		break;

	case POST_INIT:

		break;

	case LOG_ONLY:

		machdep->kvbase = kt->vmcoreinfo._stext_SYMBOL;

		break;

	}

}

void

ppc_dump_machdep_table(ulong arg)

{

        int others; 

        others = 0;

	fprintf(fp, "           platform: %s\n", PPC_PLATFORM);

        fprintf(fp, "              flags: %lx (", machdep->flags);

	if (machdep->flags & KSYMS_START)

		fprintf(fp, "%sKSYMS_START", others++ ? "|" : "");

	if (machdep->flags & PAE)

		fprintf(fp, "%sPAE", others++ ? "|" : "");

	if (machdep->flags & CPU_BOOKE)

		fprintf(fp, "%sCPU_BOOKE", others++ ? "|" : "");

        fprintf(fp, ")\n");

	fprintf(fp, "             kvbase: %lx\n", machdep->kvbase);

	fprintf(fp, "  identity_map_base: %lx\n", machdep->identity_map_base);

        fprintf(fp, "           pagesize: %d\n", machdep->pagesize);

        fprintf(fp, "          pageshift: %d\n", machdep->pageshift);

        fprintf(fp, "           pagemask: %llx\n", machdep->pagemask);

        fprintf(fp, "         pageoffset: %lx\n", machdep->pageoffset);

	fprintf(fp, "        pgdir_shift: %d\n", PGDIR_SHIFT);

	fprintf(fp, "       ptrs_per_pgd: %d\n", PTRS_PER_PGD);

	fprintf(fp, "       ptrs_per_pte: %d\n", PTRS_PER_PTE);

	fprintf(fp, "           pte_size: %d\n", PTE_SIZE);

	fprintf(fp, "      pte_rpn_shift: %d\n", PTE_RPN_SHIFT);

	fprintf(fp, "          stacksize: %ld\n", machdep->stacksize);

        fprintf(fp, "                 hz: %d\n", machdep->hz);

        fprintf(fp, "                mhz: %ld\n", machdep->mhz);

        fprintf(fp, "            memsize: %lld (0x%llx)\n", 

		machdep->memsize, machdep->memsize);

	fprintf(fp, "               bits: %d\n", machdep->bits);

	fprintf(fp, "            nr_irqs: %d\n", machdep->nr_irqs);

        fprintf(fp, "      eframe_search: ppc_eframe_search()   [TBD]\n");

        fprintf(fp, "         back_trace: ppc_back_trace_cmd()\n");

        fprintf(fp, "    processor_speed: ppc_processor_speed()\n");

        fprintf(fp, "              uvtop: ppc_uvtop()\n");

        fprintf(fp, "              kvtop: ppc_kvtop()\n");

        fprintf(fp, "       get_task_pgd: ppc_get_task_pgd()\n");

	if (machdep->dump_irq == generic_dump_irq)

		fprintf(fp, "           dump_irq: generic_dump_irq()\n");

	else

		fprintf(fp, "           dump_irq: ppc_dump_irq()\n");

	fprintf(fp, "    show_interrupts: generic_show_interrupts()\n");

	fprintf(fp, "   get_irq_affinity: generic_get_irq_affinity()\n");

        fprintf(fp, "    get_stack_frame: ppc_get_stack_frame()\n");

        fprintf(fp, "      get_stackbase: generic_get_stackbase()\n");

        fprintf(fp, "       get_stacktop: generic_get_stacktop()\n");

        fprintf(fp, "      translate_pte: ppc_translate_pte()\n");

	fprintf(fp, "        memory_size: generic_memory_size()\n");

	fprintf(fp, "      vmalloc_start: ppc_vmalloc_start()\n");

	fprintf(fp, "       is_task_addr: ppc_is_task_addr()\n");

	fprintf(fp, "      verify_symbol: ppc_verify_symbol()\n");

	fprintf(fp, "         dis_filter: ppc_dis_filter()\n");

	fprintf(fp, "           cmd_mach: ppc_cmd_mach()\n");

	fprintf(fp, "       get_smp_cpus: ppc_get_smp_cpus()\n");

        fprintf(fp, "          is_kvaddr: generic_is_kvaddr()\n");

        fprintf(fp, "          is_uvaddr: generic_is_uvaddr()\n");

        fprintf(fp, "       verify_paddr: generic_verify_paddr()\n");

	fprintf(fp, "    init_kernel_pgd: NULL\n");

	fprintf(fp, "    value_to_symbol: generic_machdep_value_to_symbol()\n");

        fprintf(fp, "  line_number_hooks: ppc_line_number_hooks\n");

        fprintf(fp, "      last_pgd_read: %lx\n", machdep->last_pgd_read);

        fprintf(fp, "      last_pmd_read: %lx\n", machdep->last_pmd_read);

        fprintf(fp, "     last_ptbl_read: %lx\n", machdep->last_ptbl_read);

        fprintf(fp, "                pgd: %lx\n", (ulong)machdep->pgd);

        fprintf(fp, "                pmd: %lx\n", (ulong)machdep->pmd);

        fprintf(fp, "               ptbl: %lx\n", (ulong)machdep->ptbl);

        fprintf(fp, "  section_size_bits: %ld\n", machdep->section_size_bits);

        fprintf(fp, "   max_physmem_bits: %ld\n", machdep->max_physmem_bits);

        fprintf(fp, "  sections_per_root: %ld\n", machdep->sections_per_root);

	fprintf(fp, "           machspec: %lx\n", (ulong)machdep->machspec);

}

static ulonglong

ppc_pte_physaddr(ulonglong pte)

{

	pte = pte >> PTE_RPN_SHIFT;	/* pfn */

	pte = pte << PAGE_SHIFT;	/* physaddr */

	return pte;

}

static int

ppc_pgd_vtop(ulong *pgd, ulong vaddr, physaddr_t *paddr, int verbose)

{

	ulong *page_dir;

	ulong pgd_pte, page_table, pte_index;

	ulonglong pte;

	if (verbose)

		fprintf(fp, "PAGE DIRECTORY: %lx\n", (ulong)pgd);

	page_dir = pgd + (vaddr >> PGDIR_SHIFT);

	/*

 	 * Size of a pgd could be more than a PAGE.

 	 * So use PAGEBASE(page_dir), instead of 

 	 * PAGEBASE(pgd) for FILL_PGD()

 	 */

        FILL_PGD(PAGEBASE((ulong)page_dir), KVADDR, PAGESIZE());

        pgd_pte = ULONG(machdep->pgd + PAGEOFFSET((ulong)page_dir));

	if (verbose)

		fprintf(fp, "  PGD: %lx => %lx\n", (ulong)page_dir, pgd_pte);

	if (!pgd_pte) {

		if (VTOP_SPECIAL)

			/*

			 * This ppc platform have special address mapping

			 * between vaddr and paddr which can not search from

			 * standard page table.

			 */

			return VTOP_SPECIAL(vaddr, paddr, verbose);

		goto no_page;

	}

	page_table = pgd_pte;

	if (IS_BOOKE())

		page_table = VTOP(page_table);

        FILL_PTBL(PAGEBASE((ulong)page_table), PHYSADDR, PAGESIZE());

	pte_index = (vaddr >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);

	if (IS_PAE())

		pte = ULONGLONG(machdep->ptbl + PTE_SIZE * pte_index);

	else

	        pte = ULONG(machdep->ptbl + PTE_SIZE * pte_index);

	if (verbose) 

		fprintf(fp, "  PTE: %lx => %llx\n", pgd_pte, pte);

	if (!(pte & _PAGE_PRESENT)) { 

		if (pte && verbose) {

			fprintf(fp, "\n");

			ppc_translate_pte((ulong)pte, 0, pte);

		}

		goto no_page;

	}

	if (verbose) {

		fprintf(fp, " PAGE: %llx\n\n", PAGEBASE(ppc_pte_physaddr(pte)));

		ppc_translate_pte((ulong)pte, 0, pte);

	}

	*paddr = PAGEBASE(ppc_pte_physaddr(pte)) + PAGEOFFSET(vaddr);

	return TRUE;

no_page:

	return FALSE;

}

/*

 *  Translates a user virtual address to its physical address.  cmd_vtop()

 *  sets the verbose flag so that the pte translation gets displayed; all

 *  other callers quietly accept the translation.

 *

 *  This routine can also take mapped kernel virtual addresses if the -u flag

 *  was passed to cmd_vtop().  If so, it makes the translation using the

 *  kernel-memory PGD entry instead of swapper_pg_dir.

 */

static int

ppc_uvtop(struct task_context *tc, ulong vaddr, physaddr_t *paddr, int verbose)

{

	ulong mm, active_mm;

	ulong *pgd;

	if (!tc)

		error(FATAL, "current context invalid\n");

	*paddr = 0;

        if (is_kernel_thread(tc->task) && IS_KVADDR(vaddr)) { 

	    	if (VALID_MEMBER(thread_struct_pg_tables)) 

                	pgd = (ulong *)machdep->get_task_pgd(tc->task);

		else {

			if (INVALID_MEMBER(task_struct_active_mm))

				error(FATAL, "no pg_tables or active_mm?\n");

                	readmem(tc->task + OFFSET(task_struct_active_mm), 

				KVADDR, &active_mm, sizeof(void *),

                        	"task active_mm contents", FAULT_ON_ERROR);

			if (!active_mm)

				error(FATAL, 

				     "no active_mm for this kernel thread\n");

			readmem(active_mm + OFFSET(mm_struct_pgd), 

				KVADDR, &pgd, sizeof(long), 

				"mm_struct pgd", FAULT_ON_ERROR);

		}

        } else {

                if ((mm = task_mm(tc->task, TRUE)))

                        pgd = ULONG_PTR(tt->mm_struct +

                                OFFSET(mm_struct_pgd));

                else

			readmem(tc->mm_struct + OFFSET(mm_struct_pgd), 

				KVADDR, &pgd, sizeof(long), "mm_struct pgd", 

				FAULT_ON_ERROR);

	}

	return ppc_pgd_vtop(pgd, vaddr, paddr, verbose);

}

/*

 * Translates a kernel virtual address to its physical address.  cmd_vtop()

 * sets the verbose flag so that the pte translation gets displayed; all

 * other callers quietly accept the translation.

 */

static int

ppc_kvtop(struct task_context *tc, ulong kvaddr, physaddr_t *paddr, int verbose)

{

	ulong *pgd;

	if (!IS_KVADDR(kvaddr))

		return FALSE;

	if (!vt->vmalloc_start) {

		*paddr = VTOP(kvaddr);

		return TRUE;

	}

	if (!IS_VMALLOC_ADDR(kvaddr)) { 

		*paddr = VTOP(kvaddr);

		if (!verbose)

			return TRUE;

	}

	pgd = (ulong *)vt->kernel_pgd[0];

	return ppc_pgd_vtop(pgd, kvaddr, paddr, verbose);

}

/*

 *  Determine where vmalloc'd memory starts by looking at the first

 *  entry on the vmlist.

 */

static ulong

ppc_vmalloc_start(void)

{

	return (first_vmalloc_address());

}

/*

 *  PPC tasks are all stacksize-aligned, except when split from the stack.

 *  PPC also allows the idle_task to be non-page aligned, so we have to make

 *  an additional check through the idle_threads array.

 */

static int

ppc_is_task_addr(ulong task)

{

	int i;

	if (tt->flags & THREAD_INFO)

		return IS_KVADDR(task);

	else if (IS_KVADDR(task) && (ALIGNED_STACK_OFFSET(task) == 0))

		return TRUE;

	for (i = 0; i < kt->cpus; i++)

		if (task == tt->idle_threads[i])

			return TRUE;

	return FALSE;

}

/*

 *  According to kernel source, this should cover all the PPC variants out

 *  There, but since we can't test them all, YMMV.

 */

static ulong

ppc_processor_speed(void)

{

	ulong res, value, ppc_md, md_setup_res;

	ulong prep_setup_res;

	ulong node, type, name, properties;

	char str_buf[32];

	ulong len, mhz = 0;

	if (machdep->mhz)

		return(machdep->mhz);

	if(symbol_exists("allnodes")) {

		get_symbol_data("allnodes", sizeof(void *), &node);

		while(node) {

			readmem(node+OFFSET(device_node_type),

				KVADDR, &type, sizeof(ulong), "node type",

				FAULT_ON_ERROR);

			if(type != 0) {

				len = read_string(type, str_buf, 

					sizeof(str_buf));

				if(len && (strcasecmp(str_buf, "cpu") == 0))

					break;

			}

			readmem(node+OFFSET(device_node_allnext),

				KVADDR, &node, sizeof(ulong), "node allnext",

				FAULT_ON_ERROR);

		}

		/* now, if we found a CPU node, get the speed property */

		if(node) {

			readmem(node+OFFSET(device_node_properties),

				KVADDR, &properties, sizeof(ulong), 

				"node properties", FAULT_ON_ERROR);

			while(properties) {

				readmem(properties+OFFSET(property_name), 

					KVADDR, &name, 

					sizeof(ulong), "property name",

					FAULT_ON_ERROR);

				len = read_string(name, str_buf, 

					sizeof(str_buf));

				if (len && (strcasecmp(str_buf, 

			            "clock-frequency") == 0)) {

					/* found the right cpu property */

					readmem(properties+

					    OFFSET(property_value),

					    KVADDR, &value, sizeof(ulong), 

					    "clock freqency pointer",

					    FAULT_ON_ERROR);

					readmem(value, KVADDR, &mhz, 

					    sizeof(ulong), 

					    "clock frequency value",

                                            FAULT_ON_ERROR);

					mhz /= 1000000;

					break;

				} else if(len && (strcasecmp(str_buf,

					"ibm,extended-clock-frequency") == 0)){

					/* found the right cpu property */

					readmem(properties+

						OFFSET(property_value),

						KVADDR, &value, sizeof(ulong),

						"clock freqency pointer",

						FAULT_ON_ERROR);

					readmem(value, KVADDR, &mhz,

						sizeof(ulong),

						"clock frequency value",

						FAULT_ON_ERROR);

					mhz /= 1000000;

					break;

				}

				/* keep looking */

				readmem(properties+

					OFFSET(property_next),

					KVADDR, &properties, sizeof(ulong), 

					"property next", FAULT_ON_ERROR);

			}

			if(!properties) {

				/* didn't find the cpu speed for some reason */

				return (machdep->mhz = 0);

			}

		}

	}

	/* for machines w/o OF */

	/* untested, but in theory this should work on prep machines */

	if (symbol_exists("res") && !mhz) {

		get_symbol_data("res", sizeof(void *), &res;;

		if (symbol_exists("prep_setup_residual")) {

			get_symbol_data("prep_setup_residual", 

				sizeof(void *), &prep_setup_res);

			get_symbol_data("ppc_md", sizeof(void *), 

				&ppc_md);

			readmem(ppc_md + 

		 		OFFSET(machdep_calls_setup_residual), 

				KVADDR, &md_setup_res, 

				sizeof(ulong), "ppc_md setup_residual",

				FAULT_ON_ERROR);

			if(prep_setup_res == md_setup_res) {

				/* PREP machine */

				readmem(res+

					OFFSET(RESIDUAL_VitalProductData)+

					OFFSET(VPD_ProcessorHz),

					KVADDR, &mhz, sizeof(ulong), 

					"res VitalProductData", 

					FAULT_ON_ERROR);

				mhz = (mhz > 1024) ? mhz >> 20 : mhz;

			}

		}

		if(!mhz) {

			/* everything else seems to do this the same way... */

			readmem(res + 

				OFFSET(bd_info_bi_intfreq),

				KVADDR, &mhz, sizeof(ulong), 

				"bd_info bi_intfreq", FAULT_ON_ERROR);

			mhz /= 1000000;

		}

	}

	/* else...well, we don't have OF, or a residual structure, so

	 * just print unknown MHz

	 */

	return (machdep->mhz = mhz);

}

/*

 *  Accept or reject a symbol from the kernel namelist.

 */

static int

ppc_verify_symbol(const char *name, ulong value, char type)

{

	if (CRASHDEBUG(8) && name && strlen(name))

		fprintf(fp, "%08lx %s\n", value, name);

	if (STREQ(name, "_start"))

		machdep->flags |= KSYMS_START;

	return (name && strlen(name) && (machdep->flags & KSYMS_START) &&

	        !STREQ(name, "Letext") && !STRNEQ(name, "__func__."));

}

/*

 *  Get the relevant page directory pointer from a task structure.

 */

static ulong

ppc_get_task_pgd(ulong task)

{

	long offset;

	ulong pg_tables;

        offset = VALID_MEMBER(task_struct_thread) ?

                OFFSET(task_struct_thread) : OFFSET(task_struct_tss);

	if (INVALID_MEMBER(thread_struct_pg_tables))