[mirror_ubuntu-artful-kernel.git] / arch / parisc / kernel / processor.c

/*    $Id: processor.c,v 1.1 2002/07/20 16:27:06 rhirst Exp $
 *
 *    Initial setup-routines for HP 9000 based hardware.
 *
 *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
 *    Modifications for PA-RISC (C) 1999 Helge Deller <deller@gmx.de>
 *    Modifications copyright 1999 SuSE GmbH (Philipp Rumpf)
 *    Modifications copyright 2000 Martin K. Petersen <mkp@mkp.net>
 *    Modifications copyright 2000 Philipp Rumpf <prumpf@tux.org>
 *    Modifications copyright 2001 Ryan Bradetich <rbradetich@uswest.net>
 *
 *    Initial PA-RISC Version: 04-23-1999 by Helge Deller
 *
 *    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, 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.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */
#include <linux/config.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/cpu.h>

#include <asm/cache.h>
#include <asm/hardware.h>	/* for register_parisc_driver() stuff */
#include <asm/processor.h>
#include <asm/page.h>
#include <asm/pdc.h>
#include <asm/pdcpat.h>
#include <asm/irq.h>		/* for struct irq_region */
#include <asm/parisc-device.h>

struct system_cpuinfo_parisc boot_cpu_data __read_mostly;
EXPORT_SYMBOL(boot_cpu_data);

struct cpuinfo_parisc cpu_data[NR_CPUS] __read_mostly;

/*
**  	PARISC CPU driver - claim "device" and initialize CPU data structures.
**
** Consolidate per CPU initialization into (mostly) one module.
** Monarch CPU will initialize boot_cpu_data which shouldn't
** change once the system has booted.
**
** The callback *should* do per-instance initialization of
** everything including the monarch. "Per CPU" init code in
** setup.c:start_parisc() has migrated here and start_parisc()
** will call register_parisc_driver(&cpu_driver) before calling do_inventory().
**
** The goal of consolidating CPU initialization into one place is
** to make sure all CPU's get initialized the same way.
** The code path not shared is how PDC hands control of the CPU to the OS.
** The initialization of OS data structures is the same (done below).
*/

/**
 * processor_probe - Determine if processor driver should claim this device.
 * @dev: The device which has been found.
 *
 * Determine if processor driver should claim this chip (return 0) or not 
 * (return 1).  If so, initialize the chip and tell other partners in crime 
 * they have work to do.
 */
static int __init processor_probe(struct parisc_device *dev)
{
	unsigned long txn_addr;
	unsigned long cpuid;
	struct cpuinfo_parisc *p;

#ifndef CONFIG_SMP
	if (boot_cpu_data.cpu_count > 0) {
		printk(KERN_INFO "CONFIG_SMP=n  ignoring additional CPUs\n");
		return 1;
	}
#endif

	/* logical CPU ID and update global counter
	 * May get overwritten by PAT code.
	 */
	cpuid = boot_cpu_data.cpu_count;
	txn_addr = dev->hpa.start;	/* for legacy PDC */

#ifdef __LP64__
	if (is_pdc_pat()) {
		ulong status;
		unsigned long bytecnt;
	        pdc_pat_cell_mod_maddr_block_t pa_pdc_cell;
#undef USE_PAT_CPUID
#ifdef USE_PAT_CPUID
		struct pdc_pat_cpu_num cpu_info;
#endif

		status = pdc_pat_cell_module(&bytecnt, dev->pcell_loc,
			dev->mod_index, PA_VIEW, &pa_pdc_cell);

		BUG_ON(PDC_OK != status);

		/* verify it's the same as what do_pat_inventory() found */
		BUG_ON(dev->mod_info != pa_pdc_cell.mod_info);
		BUG_ON(dev->pmod_loc != pa_pdc_cell.mod_location);

		txn_addr = pa_pdc_cell.mod[0];   /* id_eid for IO sapic */

#ifdef USE_PAT_CPUID
/* We need contiguous numbers for cpuid. Firmware's notion
 * of cpuid is for physical CPUs and we just don't care yet.
 * We'll care when we need to query PAT PDC about a CPU *after*
 * boot time (ie shutdown a CPU from an OS perspective).
 */
		/* get the cpu number */
		status = pdc_pat_cpu_get_number(&cpu_info, dev->hpa.start);

		BUG_ON(PDC_OK != status);

		if (cpu_info.cpu_num >= NR_CPUS) {
			printk(KERN_WARNING "IGNORING CPU at 0x%x,"
				" cpu_slot_id > NR_CPUS"
				" (%ld > %d)\n",
				dev->hpa.start, cpu_info.cpu_num, NR_CPUS);
			/* Ignore CPU since it will only crash */
			boot_cpu_data.cpu_count--;
			return 1;
		} else {
			cpuid = cpu_info.cpu_num;
		}
#endif
	}
#endif

	p = &cpu_data[cpuid];
	boot_cpu_data.cpu_count++;

	/* initialize counters */
	memset(p, 0, sizeof(struct cpuinfo_parisc));

	p->loops_per_jiffy = loops_per_jiffy;
	p->dev = dev;		/* Save IODC data in case we need it */
	p->hpa = dev->hpa.start;	/* save CPU hpa */
	p->cpuid = cpuid;	/* save CPU id */
	p->txn_addr = txn_addr;	/* save CPU IRQ address */
#ifdef CONFIG_SMP
	spin_lock_init(&p->lock);

	/*
	** FIXME: review if any other initialization is clobbered
	**	for boot_cpu by the above memset().
	*/

	/* stolen from init_percpu_prof() */
	cpu_data[cpuid].prof_counter = 1;
	cpu_data[cpuid].prof_multiplier = 1;
#endif

	/*
	** CONFIG_SMP: init_smp_config() will attempt to get CPU's into
	** OS control. RENDEZVOUS is the default state - see mem_set above.
	**	p->state = STATE_RENDEZVOUS;
	*/

#if 0
	/* CPU 0 IRQ table is statically allocated/initialized */
	if (cpuid) {
		struct irqaction actions[];

		/*
		** itimer and ipi IRQ handlers are statically initialized in
		** arch/parisc/kernel/irq.c. ie Don't need to register them.
		*/
		actions = kmalloc(sizeof(struct irqaction)*MAX_CPU_IRQ, GFP_ATOMIC);
		if (!actions) {
			/* not getting it's own table, share with monarch */
			actions = cpu_irq_actions[0];
		}

		cpu_irq_actions[cpuid] = actions;
	}
#endif

	/* 
	 * Bring this CPU up now! (ignore bootstrap cpuid == 0)
	 */
#ifdef CONFIG_SMP
	if (cpuid) {
		cpu_set(cpuid, cpu_present_map);
		cpu_up(cpuid);
	}
#endif

	return 0;
}

/**
 * collect_boot_cpu_data - Fill the boot_cpu_data structure.
 *
 * This function collects and stores the generic processor information
 * in the boot_cpu_data structure.
 */
void __init collect_boot_cpu_data(void)
{
	memset(&boot_cpu_data, 0, sizeof(boot_cpu_data));

	boot_cpu_data.cpu_hz = 100 * PAGE0->mem_10msec; /* Hz of this PARISC */

	/* get CPU-Model Information... */
#define p ((unsigned long *)&boot_cpu_data.pdc.model)
	if (pdc_model_info(&boot_cpu_data.pdc.model) == PDC_OK)
		printk(KERN_INFO 
			"model %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
			p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8]);
#undef p

	if (pdc_model_versions(&boot_cpu_data.pdc.versions, 0) == PDC_OK)
		printk(KERN_INFO "vers  %08lx\n", 
			boot_cpu_data.pdc.versions);

	if (pdc_model_cpuid(&boot_cpu_data.pdc.cpuid) == PDC_OK)
		printk(KERN_INFO "CPUID vers %ld rev %ld (0x%08lx)\n",
			(boot_cpu_data.pdc.cpuid >> 5) & 127,
			boot_cpu_data.pdc.cpuid & 31,
			boot_cpu_data.pdc.cpuid);

	if (pdc_model_capabilities(&boot_cpu_data.pdc.capabilities) == PDC_OK)
		printk(KERN_INFO "capabilities 0x%lx\n",
			boot_cpu_data.pdc.capabilities);

	if (pdc_model_sysmodel(boot_cpu_data.pdc.sys_model_name) == PDC_OK)
		printk(KERN_INFO "model %s\n",
			boot_cpu_data.pdc.sys_model_name);

	boot_cpu_data.hversion =  boot_cpu_data.pdc.model.hversion;
	boot_cpu_data.sversion =  boot_cpu_data.pdc.model.sversion;

	boot_cpu_data.cpu_type = parisc_get_cpu_type(boot_cpu_data.hversion);
	boot_cpu_data.cpu_name = cpu_name_version[boot_cpu_data.cpu_type][0];
	boot_cpu_data.family_name = cpu_name_version[boot_cpu_data.cpu_type][1];
}


/**
 * init_cpu_profiler - enable/setup per cpu profiling hooks.
 * @cpunum: The processor instance.
 *
 * FIXME: doesn't do much yet...
 */
static inline void __init
init_percpu_prof(int cpunum)
{
	cpu_data[cpunum].prof_counter = 1;
	cpu_data[cpunum].prof_multiplier = 1;
}


/**
 * init_per_cpu - Handle individual processor initializations.
 * @cpunum: logical processor number.
 *
 * This function handles initialization for *every* CPU
 * in the system:
 *
 * o Set "default" CPU width for trap handlers
 *
 * o Enable FP coprocessor
 *   REVISIT: this could be done in the "code 22" trap handler.
 *	(frowands idea - that way we know which processes need FP
 *	registers saved on the interrupt stack.)
 *   NEWS FLASH: wide kernels need FP coprocessor enabled to handle
 *	formatted printing of %lx for example (double divides I think)
 *
 * o Enable CPU profiling hooks.
 */
int __init init_per_cpu(int cpunum)
{
	int ret;
	struct pdc_coproc_cfg coproc_cfg;

	set_firmware_width();
	ret = pdc_coproc_cfg(&coproc_cfg);

	if(ret >= 0 && coproc_cfg.ccr_functional) {
		mtctl(coproc_cfg.ccr_functional, 10);  /* 10 == Coprocessor Control Reg */

		/* FWIW, FP rev/model is a more accurate way to determine
		** CPU type. CPU rev/model has some ambiguous cases.
		*/
		cpu_data[cpunum].fp_rev = coproc_cfg.revision;
		cpu_data[cpunum].fp_model = coproc_cfg.model;

		printk(KERN_INFO  "FP[%d] enabled: Rev %ld Model %ld\n",
			cpunum, coproc_cfg.revision, coproc_cfg.model);

		/*
		** store status register to stack (hopefully aligned)
		** and clear the T-bit.
		*/
		asm volatile ("fstd    %fr0,8(%sp)");

	} else {
		printk(KERN_WARNING  "WARNING: No FP CoProcessor?!"
			" (coproc_cfg.ccr_functional == 0x%lx, expected 0xc0)\n"
#ifdef __LP64__
			"Halting Machine - FP required\n"
#endif
			, coproc_cfg.ccr_functional);
#ifdef __LP64__
		mdelay(100);	/* previous chars get pushed to console */
		panic("FP CoProc not reported");
#endif
	}

	/* FUTURE: Enable Performance Monitor : ccr bit 0x20 */
	init_percpu_prof(cpunum);

	return ret;
}

/*
 * Display cpu info for all cpu's.
 */
int
show_cpuinfo (struct seq_file *m, void *v)
{
	int	n;

	for(n=0; n<boot_cpu_data.cpu_count; n++) {
#ifdef CONFIG_SMP
		if (0 == cpu_data[n].hpa)
			continue;
#ifdef ENTRY_SYS_CPUS
#error iCOD support wants to show CPU state here
#endif
#endif
		seq_printf(m, "processor\t: %d\n"
				"cpu family\t: PA-RISC %s\n",
				 n, boot_cpu_data.family_name);

		seq_printf(m, "cpu\t\t: %s\n",  boot_cpu_data.cpu_name );

		/* cpu MHz */
		seq_printf(m, "cpu MHz\t\t: %d.%06d\n",
				 boot_cpu_data.cpu_hz / 1000000,
				 boot_cpu_data.cpu_hz % 1000000  );

		seq_printf(m, "model\t\t: %s\n"
				"model name\t: %s\n",
				 boot_cpu_data.pdc.sys_model_name,
				 cpu_data[n].dev ? 
				 cpu_data[n].dev->name : "Unknown" );

		seq_printf(m, "hversion\t: 0x%08x\n"
			        "sversion\t: 0x%08x\n",
				 boot_cpu_data.hversion,
				 boot_cpu_data.sversion );

		/* print cachesize info */
		show_cache_info(m);

		seq_printf(m, "bogomips\t: %lu.%02lu\n",
			     cpu_data[n].loops_per_jiffy / (500000 / HZ),
			     (cpu_data[n].loops_per_jiffy / (5000 / HZ)) % 100);

		seq_printf(m, "software id\t: %ld\n\n",
				boot_cpu_data.pdc.model.sw_id);
	}
	return 0;
}

static struct parisc_device_id processor_tbl[] __read_mostly = {
	{ HPHW_NPROC, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, SVERSION_ANY_ID },
	{ 0, }
};

static struct parisc_driver cpu_driver __read_mostly = {
	.name		= "CPU",
	.id_table	= processor_tbl,
	.probe		= processor_probe
};

/**
 * processor_init - Processor initalization procedure.
 *
 * Register this driver.
 */
void __init processor_init(void)
{
	register_parisc_driver(&cpu_driver);
}
Commit	Line	Data
1da177e4 LT	1	/* $Id: processor.c,v 1.1 2002/07/20 16:27:06 rhirst Exp $
	2	*
	3	* Initial setup-routines for HP 9000 based hardware.
	4	*
	5	* Copyright (C) 1991, 1992, 1995 Linus Torvalds
	6	* Modifications for PA-RISC (C) 1999 Helge Deller <deller@gmx.de>
	7	* Modifications copyright 1999 SuSE GmbH (Philipp Rumpf)
	8	* Modifications copyright 2000 Martin K. Petersen <mkp@mkp.net>
	9	* Modifications copyright 2000 Philipp Rumpf <prumpf@tux.org>
	10	* Modifications copyright 2001 Ryan Bradetich <rbradetich@uswest.net>
	11	*
	12	* Initial PA-RISC Version: 04-23-1999 by Helge Deller
	13	*
	14	* This program is free software; you can redistribute it and/or modify
	15	* it under the terms of the GNU General Public License as published by
	16	* the Free Software Foundation; either version 2, or (at your option)
	17	* any later version.
	18	*
	19	* This program is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU General Public License for more details.
	23	*
	24	* You should have received a copy of the GNU General Public License
	25	* along with this program; if not, write to the Free Software
	26	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	27	*
	28	*/
	29	#include <linux/config.h>
	30	#include <linux/delay.h>
	31	#include <linux/init.h>
	32	#include <linux/mm.h>
	33	#include <linux/module.h>
	34	#include <linux/seq_file.h>
	35	#include <linux/slab.h>
	36	#include <linux/cpu.h>
	37
	38	#include <asm/cache.h>
	39	#include <asm/hardware.h> /* for register_parisc_driver() stuff */
	40	#include <asm/processor.h>
	41	#include <asm/page.h>
	42	#include <asm/pdc.h>
	43	#include <asm/pdcpat.h>
	44	#include <asm/irq.h> /* for struct irq_region */
	45	#include <asm/parisc-device.h>
	46
8039de10	47	struct system_cpuinfo_parisc boot_cpu_data __read_mostly;
1da177e4 LT	48	EXPORT_SYMBOL(boot_cpu_data);
1da177e4 LT	49
8039de10	50	struct cpuinfo_parisc cpu_data[NR_CPUS] __read_mostly;
1da177e4 LT	51
	52	/*
	53	** PARISC CPU driver - claim "device" and initialize CPU data structures.
	54	**
	55	** Consolidate per CPU initialization into (mostly) one module.
	56	** Monarch CPU will initialize boot_cpu_data which shouldn't
	57	** change once the system has booted.
	58	**
	59	** The callback should do per-instance initialization of
	60	** everything including the monarch. "Per CPU" init code in
	61	** setup.c:start_parisc() has migrated here and start_parisc()
	62	** will call register_parisc_driver(&cpu_driver) before calling do_inventory().
	63	**
	64	** The goal of consolidating CPU initialization into one place is
	65	** to make sure all CPU's get initialized the same way.
	66	** The code path not shared is how PDC hands control of the CPU to the OS.
	67	** The initialization of OS data structures is the same (done below).
	68	*/
	69
	70	/**
	71	* processor_probe - Determine if processor driver should claim this device.
	72	* @dev: The device which has been found.
	73	*
	74	* Determine if processor driver should claim this chip (return 0) or not
	75	* (return 1). If so, initialize the chip and tell other partners in crime
	76	* they have work to do.
	77	*/
	78	static int __init processor_probe(struct parisc_device *dev)
	79	{
	80	unsigned long txn_addr;
	81	unsigned long cpuid;
	82	struct cpuinfo_parisc *p;
	83
	84	#ifndef CONFIG_SMP
	85	if (boot_cpu_data.cpu_count > 0) {
	86	printk(KERN_INFO "CONFIG_SMP=n ignoring additional CPUs\n");
	87	return 1;
	88	}
	89	#endif
	90
	91	/* logical CPU ID and update global counter
	92	* May get overwritten by PAT code.
	93	*/
	94	cpuid = boot_cpu_data.cpu_count;
53f01bba	95	txn_addr = dev->hpa.start; /* for legacy PDC */
1da177e4 LT	96
	97	#ifdef __LP64__
	98	if (is_pdc_pat()) {
	99	ulong status;
	100	unsigned long bytecnt;
	101	pdc_pat_cell_mod_maddr_block_t pa_pdc_cell;
	102	#undef USE_PAT_CPUID
	103	#ifdef USE_PAT_CPUID
	104	struct pdc_pat_cpu_num cpu_info;
	105	#endif
	106
	107	status = pdc_pat_cell_module(&bytecnt, dev->pcell_loc,
	108	dev->mod_index, PA_VIEW, &pa_pdc_cell);
	109
	110	BUG_ON(PDC_OK != status);
	111
	112	/* verify it's the same as what do_pat_inventory() found */
	113	BUG_ON(dev->mod_info != pa_pdc_cell.mod_info);
	114	BUG_ON(dev->pmod_loc != pa_pdc_cell.mod_location);
	115
	116	txn_addr = pa_pdc_cell.mod[0]; /* id_eid for IO sapic */
	117
	118	#ifdef USE_PAT_CPUID
	119	/* We need contiguous numbers for cpuid. Firmware's notion
	120	* of cpuid is for physical CPUs and we just don't care yet.
	121	* We'll care when we need to query PAT PDC about a CPU after
	122	* boot time (ie shutdown a CPU from an OS perspective).
	123	*/
	124	/* get the cpu number */
53f01bba	125	status = pdc_pat_cpu_get_number(&cpu_info, dev->hpa.start);
1da177e4 LT	126
	127	BUG_ON(PDC_OK != status);
	128
	129	if (cpu_info.cpu_num >= NR_CPUS) {
	130	printk(KERN_WARNING "IGNORING CPU at 0x%x,"
	131	" cpu_slot_id > NR_CPUS"
	132	" (%ld > %d)\n",
53f01bba	133	dev->hpa.start, cpu_info.cpu_num, NR_CPUS);
1da177e4 LT	134	/* Ignore CPU since it will only crash */
	135	boot_cpu_data.cpu_count--;
	136	return 1;
	137	} else {
	138	cpuid = cpu_info.cpu_num;
	139	}
	140	#endif
	141	}
	142	#endif
	143
	144	p = &cpu_data[cpuid];
	145	boot_cpu_data.cpu_count++;
	146
	147	/* initialize counters */
	148	memset(p, 0, sizeof(struct cpuinfo_parisc));
	149
	150	p->loops_per_jiffy = loops_per_jiffy;
	151	p->dev = dev; /* Save IODC data in case we need it */
53f01bba	152	p->hpa = dev->hpa.start; /* save CPU hpa */
1da177e4 LT	153	p->cpuid = cpuid; /* save CPU id */
	154	p->txn_addr = txn_addr; /* save CPU IRQ address */
	155	#ifdef CONFIG_SMP
	156	spin_lock_init(&p->lock);
	157
	158	/*
	159	** FIXME: review if any other initialization is clobbered
	160	** for boot_cpu by the above memset().
	161	*/
	162
	163	/* stolen from init_percpu_prof() */
	164	cpu_data[cpuid].prof_counter = 1;
	165	cpu_data[cpuid].prof_multiplier = 1;
	166	#endif
	167
	168	/*
	169	** CONFIG_SMP: init_smp_config() will attempt to get CPU's into
	170	** OS control. RENDEZVOUS is the default state - see mem_set above.
	171	** p->state = STATE_RENDEZVOUS;
	172	*/
	173
	174	#if 0
	175	/* CPU 0 IRQ table is statically allocated/initialized */
	176	if (cpuid) {
	177	struct irqaction actions[];
	178
	179	/*
	180	** itimer and ipi IRQ handlers are statically initialized in
	181	** arch/parisc/kernel/irq.c. ie Don't need to register them.
	182	*/
	183	actions = kmalloc(sizeof(struct irqaction)*MAX_CPU_IRQ, GFP_ATOMIC);
	184	if (!actions) {
	185	/* not getting it's own table, share with monarch */
	186	actions = cpu_irq_actions[0];
	187	}
	188
	189	cpu_irq_actions[cpuid] = actions;
	190	}
	191	#endif
	192
	193	/*
	194	* Bring this CPU up now! (ignore bootstrap cpuid == 0)
	195	*/
	196	#ifdef CONFIG_SMP
	197	if (cpuid) {
	198	cpu_set(cpuid, cpu_present_map);
	199	cpu_up(cpuid);
	200	}
	201	#endif
	202
	203	return 0;
	204	}
	205
	206	/**
	207	* collect_boot_cpu_data - Fill the boot_cpu_data structure.
	208	*
	209	* This function collects and stores the generic processor information
	210	* in the boot_cpu_data structure.
	211	*/
	212	void __init collect_boot_cpu_data(void)
	213	{
	214	memset(&boot_cpu_data, 0, sizeof(boot_cpu_data));
	215
	216	boot_cpu_data.cpu_hz = 100 * PAGE0->mem_10msec; /* Hz of this PARISC */
217
218	/* get CPU-Model Information... */
219	#define p ((unsigned long *)&boot_cpu_data.pdc.model)
220	if (pdc_model_info(&boot_cpu_data.pdc.model) == PDC_OK)
221	printk(KERN_INFO
222	"model %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
223	p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8]);
224	#undef p
225
226	if (pdc_model_versions(&boot_cpu_data.pdc.versions, 0) == PDC_OK)
227	printk(KERN_INFO "vers %08lx\n",
228	boot_cpu_data.pdc.versions);
229
230	if (pdc_model_cpuid(&boot_cpu_data.pdc.cpuid) == PDC_OK)
231	printk(KERN_INFO "CPUID vers %ld rev %ld (0x%08lx)\n",
232	(boot_cpu_data.pdc.cpuid >> 5) & 127,
233	boot_cpu_data.pdc.cpuid & 31,
234	boot_cpu_data.pdc.cpuid);
235
236	if (pdc_model_capabilities(&boot_cpu_data.pdc.capabilities) == PDC_OK)
237	printk(KERN_INFO "capabilities 0x%lx\n",
238	boot_cpu_data.pdc.capabilities);
239
240	if (pdc_model_sysmodel(boot_cpu_data.pdc.sys_model_name) == PDC_OK)
241	printk(KERN_INFO "model %s\n",
242	boot_cpu_data.pdc.sys_model_name);
243
244	boot_cpu_data.hversion = boot_cpu_data.pdc.model.hversion;
245	boot_cpu_data.sversion = boot_cpu_data.pdc.model.sversion;
246
247	boot_cpu_data.cpu_type = parisc_get_cpu_type(boot_cpu_data.hversion);
248	boot_cpu_data.cpu_name = cpu_name_version[boot_cpu_data.cpu_type][0];
249	boot_cpu_data.family_name = cpu_name_version[boot_cpu_data.cpu_type][1];
250	}
251
252
253	/**
254	* init_cpu_profiler - enable/setup per cpu profiling hooks.
255	* @cpunum: The processor instance.
256	*
257	* FIXME: doesn't do much yet...
258	*/
259	static inline void __init
260	init_percpu_prof(int cpunum)
261	{
262	cpu_data[cpunum].prof_counter = 1;
263	cpu_data[cpunum].prof_multiplier = 1;
264	}
265
266
267	/**
268	* init_per_cpu - Handle individual processor initializations.
269	* @cpunum: logical processor number.
270	*
271	* This function handles initialization for every CPU
272	* in the system:
273	*
274	* o Set "default" CPU width for trap handlers
275	*
276	* o Enable FP coprocessor
277	* REVISIT: this could be done in the "code 22" trap handler.
278	* (frowands idea - that way we know which processes need FP
279	* registers saved on the interrupt stack.)
280	* NEWS FLASH: wide kernels need FP coprocessor enabled to handle
281	* formatted printing of %lx for example (double divides I think)
282	*
283	* o Enable CPU profiling hooks.
284	*/
285	int __init init_per_cpu(int cpunum)
286	{
287	int ret;
288	struct pdc_coproc_cfg coproc_cfg;
289
290	set_firmware_width();
291	ret = pdc_coproc_cfg(&coproc_cfg);
292
293	if(ret >= 0 && coproc_cfg.ccr_functional) {
294	mtctl(coproc_cfg.ccr_functional, 10); /* 10 == Coprocessor Control Reg */
295
296	/* FWIW, FP rev/model is a more accurate way to determine
297	** CPU type. CPU rev/model has some ambiguous cases.
298	*/
299	cpu_data[cpunum].fp_rev = coproc_cfg.revision;
300	cpu_data[cpunum].fp_model = coproc_cfg.model;
301
302	printk(KERN_INFO "FP[%d] enabled: Rev %ld Model %ld\n",
303	cpunum, coproc_cfg.revision, coproc_cfg.model);
304
305	/*
306	** store status register to stack (hopefully aligned)
307	** and clear the T-bit.
308	*/
309	asm volatile ("fstd %fr0,8(%sp)");
310
311	} else {
312	printk(KERN_WARNING "WARNING: No FP CoProcessor?!"
313	" (coproc_cfg.ccr_functional == 0x%lx, expected 0xc0)\n"
314	#ifdef __LP64__
315	"Halting Machine - FP required\n"
316	#endif
317	, coproc_cfg.ccr_functional);
318	#ifdef __LP64__
319	mdelay(100); /* previous chars get pushed to console */
320	panic("FP CoProc not reported");
321	#endif
322	}
323
324	/* FUTURE: Enable Performance Monitor : ccr bit 0x20 */
325	init_percpu_prof(cpunum);
326
327	return ret;
328	}
329
330	/*
331	* Display cpu info for all cpu's.
332	*/
333	int
334	show_cpuinfo (struct seq_file m, void v)
335	{
336	int n;
337
338	for(n=0; n<boot_cpu_data.cpu_count; n++) {
339	#ifdef CONFIG_SMP
340	if (0 == cpu_data[n].hpa)
341	continue;
342	#ifdef ENTRY_SYS_CPUS
343	#error iCOD support wants to show CPU state here
344	#endif
345	#endif
346	seq_printf(m, "processor\t: %d\n"
347	"cpu family\t: PA-RISC %s\n",
348	n, boot_cpu_data.family_name);
349
350	seq_printf(m, "cpu\t\t: %s\n", boot_cpu_data.cpu_name );
351
352	/* cpu MHz */
353	seq_printf(m, "cpu MHz\t\t: %d.%06d\n",
354	boot_cpu_data.cpu_hz / 1000000,
355	boot_cpu_data.cpu_hz % 1000000 );
356
357	seq_printf(m, "model\t\t: %s\n"
358	"model name\t: %s\n",
359	boot_cpu_data.pdc.sys_model_name,
360	cpu_data[n].dev ?
361	cpu_data[n].dev->name : "Unknown" );
362
363	seq_printf(m, "hversion\t: 0x%08x\n"
364	"sversion\t: 0x%08x\n",
365	boot_cpu_data.hversion,
366	boot_cpu_data.sversion );
367
368	/* print cachesize info */
369	show_cache_info(m);
370
371	seq_printf(m, "bogomips\t: %lu.%02lu\n",
372	cpu_data[n].loops_per_jiffy / (500000 / HZ),
373	(cpu_data[n].loops_per_jiffy / (5000 / HZ)) % 100);
374
375	seq_printf(m, "software id\t: %ld\n\n",
376	boot_cpu_data.pdc.model.sw_id);
377	}
378	return 0;
379	}
380
8039de10	381	static struct parisc_device_id processor_tbl[] __read_mostly = {
1da177e4 LT	382	{ HPHW_NPROC, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, SVERSION_ANY_ID },
	383	{ 0, }
	384	};
	385
8039de10	386	static struct parisc_driver cpu_driver __read_mostly = {
1da177e4 LT	387	.name = "CPU",
	388	.id_table = processor_tbl,
	389	.probe = processor_probe
	390	};
	391
	392	/**
	393	* processor_init - Processor initalization procedure.
	394	*
	395	* Register this driver.
	396	*/
	397	void __init processor_init(void)
	398	{
	399	register_parisc_driver(&cpu_driver);
	400	}