2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Processor capabilities determination functions.
|
|
|
|
*
|
|
|
|
* Copyright (C) xxxx the Anonymous
|
2006-01-30 01:42:08 +07:00
|
|
|
* Copyright (C) 1994 - 2006 Ralf Baechle
|
2005-05-05 23:45:59 +07:00
|
|
|
* Copyright (C) 2003, 2004 Maciej W. Rozycki
|
2013-01-22 18:59:30 +07:00
|
|
|
* Copyright (C) 2001, 2004, 2011, 2012 MIPS Technologies, Inc.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/ptrace.h>
|
2009-06-19 20:05:26 +07:00
|
|
|
#include <linux/smp.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/stddef.h>
|
2011-07-24 03:30:40 +07:00
|
|
|
#include <linux/export.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-02-19 02:07:31 +07:00
|
|
|
#include <asm/bugs.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/cpu.h>
|
2013-09-17 15:25:47 +07:00
|
|
|
#include <asm/cpu-type.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/fpu.h>
|
|
|
|
#include <asm/mipsregs.h>
|
2014-03-27 17:57:30 +07:00
|
|
|
#include <asm/mipsmtregs.h>
|
2014-01-27 22:23:10 +07:00
|
|
|
#include <asm/msa.h>
|
2008-09-23 14:07:16 +07:00
|
|
|
#include <asm/watch.h>
|
2011-07-24 03:26:41 +07:00
|
|
|
#include <asm/elf.h>
|
2014-07-18 16:51:32 +07:00
|
|
|
#include <asm/pgtable-bits.h>
|
2009-07-10 15:51:27 +07:00
|
|
|
#include <asm/spram.h>
|
2010-10-15 01:32:33 +07:00
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
MIPS: Delete __cpuinit/__CPUINIT usage from MIPS code
commit 3747069b25e419f6b51395f48127e9812abc3596 upstream.
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
and are flagged as __cpuinit -- so if we remove the __cpuinit from
the arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
related content into no-ops as early as possible, since that will get
rid of these warnings. In any case, they are temporary and harmless.
Here, we remove all the MIPS __cpuinit from C code and __CPUINIT
from asm files. MIPS is interesting in this respect, because there
are also uasm users hiding behind their own renamed versions of the
__cpuinit macros.
[1] https://lkml.org/lkml/2013/5/20/589
[ralf@linux-mips.org: Folded in Paul's followup fix.]
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/5494/
Patchwork: https://patchwork.linux-mips.org/patch/5495/
Patchwork: https://patchwork.linux-mips.org/patch/5509/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2013-06-18 20:38:59 +07:00
|
|
|
static int mips_fpu_disabled;
|
2010-05-03 04:43:52 +07:00
|
|
|
|
|
|
|
static int __init fpu_disable(char *s)
|
|
|
|
{
|
|
|
|
cpu_data[0].options &= ~MIPS_CPU_FPU;
|
|
|
|
mips_fpu_disabled = 1;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("nofpu", fpu_disable);
|
|
|
|
|
MIPS: Delete __cpuinit/__CPUINIT usage from MIPS code
commit 3747069b25e419f6b51395f48127e9812abc3596 upstream.
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
and are flagged as __cpuinit -- so if we remove the __cpuinit from
the arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
related content into no-ops as early as possible, since that will get
rid of these warnings. In any case, they are temporary and harmless.
Here, we remove all the MIPS __cpuinit from C code and __CPUINIT
from asm files. MIPS is interesting in this respect, because there
are also uasm users hiding behind their own renamed versions of the
__cpuinit macros.
[1] https://lkml.org/lkml/2013/5/20/589
[ralf@linux-mips.org: Folded in Paul's followup fix.]
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/5494/
Patchwork: https://patchwork.linux-mips.org/patch/5495/
Patchwork: https://patchwork.linux-mips.org/patch/5509/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2013-06-18 20:38:59 +07:00
|
|
|
int mips_dsp_disabled;
|
2010-05-03 04:43:52 +07:00
|
|
|
|
|
|
|
static int __init dsp_disable(char *s)
|
|
|
|
{
|
2012-08-03 22:26:04 +07:00
|
|
|
cpu_data[0].ases &= ~(MIPS_ASE_DSP | MIPS_ASE_DSP2P);
|
2010-05-03 04:43:52 +07:00
|
|
|
mips_dsp_disabled = 1;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("nodsp", dsp_disable);
|
|
|
|
|
2014-07-14 18:46:13 +07:00
|
|
|
static int mips_htw_disabled;
|
|
|
|
|
|
|
|
static int __init htw_disable(char *s)
|
|
|
|
{
|
|
|
|
mips_htw_disabled = 1;
|
|
|
|
cpu_data[0].options &= ~MIPS_CPU_HTW;
|
|
|
|
write_c0_pwctl(read_c0_pwctl() &
|
|
|
|
~(1 << MIPS_PWCTL_PWEN_SHIFT));
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("nohtw", htw_disable);
|
|
|
|
|
2014-08-29 15:37:26 +07:00
|
|
|
static int mips_ftlb_disabled;
|
|
|
|
static int mips_has_ftlb_configured;
|
|
|
|
|
|
|
|
static void set_ftlb_enable(struct cpuinfo_mips *c, int enable);
|
|
|
|
|
|
|
|
static int __init ftlb_disable(char *s)
|
|
|
|
{
|
|
|
|
unsigned int config4, mmuextdef;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the core hasn't done any FTLB configuration, there is nothing
|
|
|
|
* for us to do here.
|
|
|
|
*/
|
|
|
|
if (!mips_has_ftlb_configured)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* Disable it in the boot cpu */
|
|
|
|
set_ftlb_enable(&cpu_data[0], 0);
|
|
|
|
|
|
|
|
back_to_back_c0_hazard();
|
|
|
|
|
|
|
|
config4 = read_c0_config4();
|
|
|
|
|
|
|
|
/* Check that FTLB has been disabled */
|
|
|
|
mmuextdef = config4 & MIPS_CONF4_MMUEXTDEF;
|
|
|
|
/* MMUSIZEEXT == VTLB ON, FTLB OFF */
|
|
|
|
if (mmuextdef == MIPS_CONF4_MMUEXTDEF_FTLBSIZEEXT) {
|
|
|
|
/* This should never happen */
|
|
|
|
pr_warn("FTLB could not be disabled!\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
mips_ftlb_disabled = 1;
|
|
|
|
mips_has_ftlb_configured = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* noftlb is mainly used for debug purposes so print
|
|
|
|
* an informative message instead of using pr_debug()
|
|
|
|
*/
|
|
|
|
pr_info("FTLB has been disabled\n");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some of these bits are duplicated in the decode_config4.
|
|
|
|
* MIPS_CONF4_MMUEXTDEF_MMUSIZEEXT is the only possible case
|
|
|
|
* once FTLB has been disabled so undo what decode_config4 did.
|
|
|
|
*/
|
|
|
|
cpu_data[0].tlbsize -= cpu_data[0].tlbsizeftlbways *
|
|
|
|
cpu_data[0].tlbsizeftlbsets;
|
|
|
|
cpu_data[0].tlbsizeftlbsets = 0;
|
|
|
|
cpu_data[0].tlbsizeftlbways = 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("noftlb", ftlb_disable);
|
|
|
|
|
|
|
|
|
2007-06-15 04:55:31 +07:00
|
|
|
static inline void check_errata(void)
|
|
|
|
{
|
|
|
|
struct cpuinfo_mips *c = ¤t_cpu_data;
|
|
|
|
|
2013-09-17 15:25:47 +07:00
|
|
|
switch (current_cpu_type()) {
|
2007-06-15 04:55:31 +07:00
|
|
|
case CPU_34K:
|
|
|
|
/*
|
|
|
|
* Erratum "RPS May Cause Incorrect Instruction Execution"
|
2014-05-23 21:29:44 +07:00
|
|
|
* This code only handles VPE0, any SMP/RTOS code
|
2007-06-15 04:55:31 +07:00
|
|
|
* making use of VPE1 will be responsable for that VPE.
|
|
|
|
*/
|
|
|
|
if ((c->processor_id & PRID_REV_MASK) <= PRID_REV_34K_V1_0_2)
|
|
|
|
write_c0_config7(read_c0_config7() | MIPS_CONF7_RPS);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
void __init check_bugs32(void)
|
|
|
|
{
|
2007-06-15 04:55:31 +07:00
|
|
|
check_errata();
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Probe whether cpu has config register by trying to play with
|
|
|
|
* alternate cache bit and see whether it matters.
|
|
|
|
* It's used by cpu_probe to distinguish between R3000A and R3081.
|
|
|
|
*/
|
|
|
|
static inline int cpu_has_confreg(void)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_CPU_R3000
|
|
|
|
extern unsigned long r3k_cache_size(unsigned long);
|
|
|
|
unsigned long size1, size2;
|
|
|
|
unsigned long cfg = read_c0_conf();
|
|
|
|
|
|
|
|
size1 = r3k_cache_size(ST0_ISC);
|
|
|
|
write_c0_conf(cfg ^ R30XX_CONF_AC);
|
|
|
|
size2 = r3k_cache_size(ST0_ISC);
|
|
|
|
write_c0_conf(cfg);
|
|
|
|
return size1 != size2;
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2011-04-19 01:37:55 +07:00
|
|
|
static inline void set_elf_platform(int cpu, const char *plat)
|
|
|
|
{
|
|
|
|
if (cpu == 0)
|
|
|
|
__elf_platform = plat;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Get the FPU Implementation/Revision.
|
|
|
|
*/
|
|
|
|
static inline unsigned long cpu_get_fpu_id(void)
|
|
|
|
{
|
|
|
|
unsigned long tmp, fpu_id;
|
|
|
|
|
|
|
|
tmp = read_c0_status();
|
2013-11-22 20:12:07 +07:00
|
|
|
__enable_fpu(FPU_AS_IS);
|
2005-04-17 05:20:36 +07:00
|
|
|
fpu_id = read_32bit_cp1_register(CP1_REVISION);
|
|
|
|
write_c0_status(tmp);
|
|
|
|
return fpu_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check the CPU has an FPU the official way.
|
|
|
|
*/
|
|
|
|
static inline int __cpu_has_fpu(void)
|
|
|
|
{
|
2014-10-21 19:12:49 +07:00
|
|
|
return (cpu_get_fpu_id() & FPIR_IMP_MASK) != FPIR_IMP_NONE;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2014-01-27 22:23:10 +07:00
|
|
|
static inline unsigned long cpu_get_msa_id(void)
|
|
|
|
{
|
2014-07-11 22:44:34 +07:00
|
|
|
unsigned long status, msa_id;
|
2014-01-27 22:23:10 +07:00
|
|
|
|
|
|
|
status = read_c0_status();
|
|
|
|
__enable_fpu(FPU_64BIT);
|
|
|
|
enable_msa();
|
|
|
|
msa_id = read_msa_ir();
|
2014-07-11 22:44:34 +07:00
|
|
|
disable_msa();
|
2014-01-27 22:23:10 +07:00
|
|
|
write_c0_status(status);
|
|
|
|
return msa_id;
|
|
|
|
}
|
|
|
|
|
2010-02-02 23:52:20 +07:00
|
|
|
static inline void cpu_probe_vmbits(struct cpuinfo_mips *c)
|
|
|
|
{
|
|
|
|
#ifdef __NEED_VMBITS_PROBE
|
2010-02-09 03:27:00 +07:00
|
|
|
write_c0_entryhi(0x3fffffffffffe000ULL);
|
2010-02-02 23:52:20 +07:00
|
|
|
back_to_back_c0_hazard();
|
2010-02-09 03:27:00 +07:00
|
|
|
c->vmbits = fls64(read_c0_entryhi() & 0x3fffffffffffe000ULL);
|
2010-02-02 23:52:20 +07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
MIPS: Delete __cpuinit/__CPUINIT usage from MIPS code
commit 3747069b25e419f6b51395f48127e9812abc3596 upstream.
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
and are flagged as __cpuinit -- so if we remove the __cpuinit from
the arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
related content into no-ops as early as possible, since that will get
rid of these warnings. In any case, they are temporary and harmless.
Here, we remove all the MIPS __cpuinit from C code and __CPUINIT
from asm files. MIPS is interesting in this respect, because there
are also uasm users hiding behind their own renamed versions of the
__cpuinit macros.
[1] https://lkml.org/lkml/2013/5/20/589
[ralf@linux-mips.org: Folded in Paul's followup fix.]
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/5494/
Patchwork: https://patchwork.linux-mips.org/patch/5495/
Patchwork: https://patchwork.linux-mips.org/patch/5509/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2013-06-18 20:38:59 +07:00
|
|
|
static void set_isa(struct cpuinfo_mips *c, unsigned int isa)
|
2012-12-07 11:31:36 +07:00
|
|
|
{
|
|
|
|
switch (isa) {
|
|
|
|
case MIPS_CPU_ISA_M64R2:
|
|
|
|
c->isa_level |= MIPS_CPU_ISA_M32R2 | MIPS_CPU_ISA_M64R2;
|
|
|
|
case MIPS_CPU_ISA_M64R1:
|
|
|
|
c->isa_level |= MIPS_CPU_ISA_M32R1 | MIPS_CPU_ISA_M64R1;
|
|
|
|
case MIPS_CPU_ISA_V:
|
|
|
|
c->isa_level |= MIPS_CPU_ISA_V;
|
|
|
|
case MIPS_CPU_ISA_IV:
|
|
|
|
c->isa_level |= MIPS_CPU_ISA_IV;
|
|
|
|
case MIPS_CPU_ISA_III:
|
2013-06-26 22:06:34 +07:00
|
|
|
c->isa_level |= MIPS_CPU_ISA_II | MIPS_CPU_ISA_III;
|
2012-12-07 11:31:36 +07:00
|
|
|
break;
|
|
|
|
|
2014-11-13 20:51:51 +07:00
|
|
|
/* R6 incompatible with everything else */
|
|
|
|
case MIPS_CPU_ISA_M64R6:
|
|
|
|
c->isa_level |= MIPS_CPU_ISA_M32R6 | MIPS_CPU_ISA_M64R6;
|
|
|
|
case MIPS_CPU_ISA_M32R6:
|
|
|
|
c->isa_level |= MIPS_CPU_ISA_M32R6;
|
|
|
|
/* Break here so we don't add incompatible ISAs */
|
|
|
|
break;
|
2012-12-07 11:31:36 +07:00
|
|
|
case MIPS_CPU_ISA_M32R2:
|
|
|
|
c->isa_level |= MIPS_CPU_ISA_M32R2;
|
|
|
|
case MIPS_CPU_ISA_M32R1:
|
|
|
|
c->isa_level |= MIPS_CPU_ISA_M32R1;
|
|
|
|
case MIPS_CPU_ISA_II:
|
|
|
|
c->isa_level |= MIPS_CPU_ISA_II;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
MIPS: Delete __cpuinit/__CPUINIT usage from MIPS code
commit 3747069b25e419f6b51395f48127e9812abc3596 upstream.
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
and are flagged as __cpuinit -- so if we remove the __cpuinit from
the arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
related content into no-ops as early as possible, since that will get
rid of these warnings. In any case, they are temporary and harmless.
Here, we remove all the MIPS __cpuinit from C code and __CPUINIT
from asm files. MIPS is interesting in this respect, because there
are also uasm users hiding behind their own renamed versions of the
__cpuinit macros.
[1] https://lkml.org/lkml/2013/5/20/589
[ralf@linux-mips.org: Folded in Paul's followup fix.]
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/5494/
Patchwork: https://patchwork.linux-mips.org/patch/5495/
Patchwork: https://patchwork.linux-mips.org/patch/5509/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2013-06-18 20:38:59 +07:00
|
|
|
static char unknown_isa[] = KERN_ERR \
|
2012-06-21 02:05:32 +07:00
|
|
|
"Unsupported ISA type, c0.config0: %d.";
|
|
|
|
|
2014-11-10 19:25:34 +07:00
|
|
|
static unsigned int calculate_ftlb_probability(struct cpuinfo_mips *c)
|
|
|
|
{
|
|
|
|
|
|
|
|
unsigned int probability = c->tlbsize / c->tlbsizevtlb;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 0 = All TLBWR instructions go to FTLB
|
|
|
|
* 1 = 15:1: For every 16 TBLWR instructions, 15 go to the
|
|
|
|
* FTLB and 1 goes to the VTLB.
|
|
|
|
* 2 = 7:1: As above with 7:1 ratio.
|
|
|
|
* 3 = 3:1: As above with 3:1 ratio.
|
|
|
|
*
|
|
|
|
* Use the linear midpoint as the probability threshold.
|
|
|
|
*/
|
|
|
|
if (probability >= 12)
|
|
|
|
return 1;
|
|
|
|
else if (probability >= 6)
|
|
|
|
return 2;
|
|
|
|
else
|
|
|
|
/*
|
|
|
|
* So FTLB is less than 4 times bigger than VTLB.
|
|
|
|
* A 3:1 ratio can still be useful though.
|
|
|
|
*/
|
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
|
2013-11-14 23:12:31 +07:00
|
|
|
static void set_ftlb_enable(struct cpuinfo_mips *c, int enable)
|
|
|
|
{
|
|
|
|
unsigned int config6;
|
2014-01-22 23:19:40 +07:00
|
|
|
|
|
|
|
/* It's implementation dependent how the FTLB can be enabled */
|
|
|
|
switch (c->cputype) {
|
|
|
|
case CPU_PROAPTIV:
|
|
|
|
case CPU_P5600:
|
|
|
|
/* proAptiv & related cores use Config6 to enable the FTLB */
|
2013-11-14 23:12:31 +07:00
|
|
|
config6 = read_c0_config6();
|
2014-11-10 19:25:34 +07:00
|
|
|
/* Clear the old probability value */
|
|
|
|
config6 &= ~(3 << MIPS_CONF6_FTLBP_SHIFT);
|
2013-11-14 23:12:31 +07:00
|
|
|
if (enable)
|
|
|
|
/* Enable FTLB */
|
2014-11-10 19:25:34 +07:00
|
|
|
write_c0_config6(config6 |
|
|
|
|
(calculate_ftlb_probability(c)
|
|
|
|
<< MIPS_CONF6_FTLBP_SHIFT)
|
|
|
|
| MIPS_CONF6_FTLBEN);
|
2013-11-14 23:12:31 +07:00
|
|
|
else
|
|
|
|
/* Disable FTLB */
|
|
|
|
write_c0_config6(config6 & ~MIPS_CONF6_FTLBEN);
|
|
|
|
back_to_back_c0_hazard();
|
2014-01-22 23:19:40 +07:00
|
|
|
break;
|
2013-11-14 23:12:31 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-21 02:05:32 +07:00
|
|
|
static inline unsigned int decode_config0(struct cpuinfo_mips *c)
|
|
|
|
{
|
|
|
|
unsigned int config0;
|
|
|
|
int isa;
|
|
|
|
|
|
|
|
config0 = read_c0_config();
|
|
|
|
|
2013-11-14 23:12:31 +07:00
|
|
|
/*
|
|
|
|
* Look for Standard TLB or Dual VTLB and FTLB
|
|
|
|
*/
|
|
|
|
if ((((config0 & MIPS_CONF_MT) >> 7) == 1) ||
|
|
|
|
(((config0 & MIPS_CONF_MT) >> 7) == 4))
|
2012-06-21 02:05:32 +07:00
|
|
|
c->options |= MIPS_CPU_TLB;
|
2013-11-14 23:12:31 +07:00
|
|
|
|
2012-06-21 02:05:32 +07:00
|
|
|
isa = (config0 & MIPS_CONF_AT) >> 13;
|
|
|
|
switch (isa) {
|
|
|
|
case 0:
|
|
|
|
switch ((config0 & MIPS_CONF_AR) >> 10) {
|
|
|
|
case 0:
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_M32R1);
|
2012-06-21 02:05:32 +07:00
|
|
|
break;
|
|
|
|
case 1:
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_M32R2);
|
2012-06-21 02:05:32 +07:00
|
|
|
break;
|
2014-11-13 20:51:51 +07:00
|
|
|
case 2:
|
|
|
|
set_isa(c, MIPS_CPU_ISA_M32R6);
|
|
|
|
break;
|
2012-06-21 02:05:32 +07:00
|
|
|
default:
|
|
|
|
goto unknown;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
switch ((config0 & MIPS_CONF_AR) >> 10) {
|
|
|
|
case 0:
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_M64R1);
|
2012-06-21 02:05:32 +07:00
|
|
|
break;
|
|
|
|
case 1:
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_M64R2);
|
2012-06-21 02:05:32 +07:00
|
|
|
break;
|
2014-11-13 20:51:51 +07:00
|
|
|
case 2:
|
|
|
|
set_isa(c, MIPS_CPU_ISA_M64R6);
|
|
|
|
break;
|
2012-06-21 02:05:32 +07:00
|
|
|
default:
|
|
|
|
goto unknown;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto unknown;
|
|
|
|
}
|
|
|
|
|
|
|
|
return config0 & MIPS_CONF_M;
|
|
|
|
|
|
|
|
unknown:
|
|
|
|
panic(unknown_isa, config0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int decode_config1(struct cpuinfo_mips *c)
|
|
|
|
{
|
|
|
|
unsigned int config1;
|
|
|
|
|
|
|
|
config1 = read_c0_config1();
|
|
|
|
|
|
|
|
if (config1 & MIPS_CONF1_MD)
|
|
|
|
c->ases |= MIPS_ASE_MDMX;
|
|
|
|
if (config1 & MIPS_CONF1_WR)
|
|
|
|
c->options |= MIPS_CPU_WATCH;
|
|
|
|
if (config1 & MIPS_CONF1_CA)
|
|
|
|
c->ases |= MIPS_ASE_MIPS16;
|
|
|
|
if (config1 & MIPS_CONF1_EP)
|
|
|
|
c->options |= MIPS_CPU_EJTAG;
|
|
|
|
if (config1 & MIPS_CONF1_FP) {
|
|
|
|
c->options |= MIPS_CPU_FPU;
|
|
|
|
c->options |= MIPS_CPU_32FPR;
|
|
|
|
}
|
2013-11-14 23:12:31 +07:00
|
|
|
if (cpu_has_tlb) {
|
2012-06-21 02:05:32 +07:00
|
|
|
c->tlbsize = ((config1 & MIPS_CONF1_TLBS) >> 25) + 1;
|
2013-11-14 23:12:31 +07:00
|
|
|
c->tlbsizevtlb = c->tlbsize;
|
|
|
|
c->tlbsizeftlbsets = 0;
|
|
|
|
}
|
2012-06-21 02:05:32 +07:00
|
|
|
|
|
|
|
return config1 & MIPS_CONF_M;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int decode_config2(struct cpuinfo_mips *c)
|
|
|
|
{
|
|
|
|
unsigned int config2;
|
|
|
|
|
|
|
|
config2 = read_c0_config2();
|
|
|
|
|
|
|
|
if (config2 & MIPS_CONF2_SL)
|
|
|
|
c->scache.flags &= ~MIPS_CACHE_NOT_PRESENT;
|
|
|
|
|
|
|
|
return config2 & MIPS_CONF_M;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int decode_config3(struct cpuinfo_mips *c)
|
|
|
|
{
|
|
|
|
unsigned int config3;
|
|
|
|
|
|
|
|
config3 = read_c0_config3();
|
|
|
|
|
2012-09-14 04:47:58 +07:00
|
|
|
if (config3 & MIPS_CONF3_SM) {
|
2012-06-21 02:05:32 +07:00
|
|
|
c->ases |= MIPS_ASE_SMARTMIPS;
|
2012-09-14 04:47:58 +07:00
|
|
|
c->options |= MIPS_CPU_RIXI;
|
|
|
|
}
|
|
|
|
if (config3 & MIPS_CONF3_RXI)
|
|
|
|
c->options |= MIPS_CPU_RIXI;
|
2012-06-21 02:05:32 +07:00
|
|
|
if (config3 & MIPS_CONF3_DSP)
|
|
|
|
c->ases |= MIPS_ASE_DSP;
|
2012-08-03 22:26:04 +07:00
|
|
|
if (config3 & MIPS_CONF3_DSP2P)
|
|
|
|
c->ases |= MIPS_ASE_DSP2P;
|
2012-06-21 02:05:32 +07:00
|
|
|
if (config3 & MIPS_CONF3_VINT)
|
|
|
|
c->options |= MIPS_CPU_VINT;
|
|
|
|
if (config3 & MIPS_CONF3_VEIC)
|
|
|
|
c->options |= MIPS_CPU_VEIC;
|
|
|
|
if (config3 & MIPS_CONF3_MT)
|
|
|
|
c->ases |= MIPS_ASE_MIPSMT;
|
|
|
|
if (config3 & MIPS_CONF3_ULRI)
|
|
|
|
c->options |= MIPS_CPU_ULRI;
|
2012-12-07 10:51:35 +07:00
|
|
|
if (config3 & MIPS_CONF3_ISA)
|
|
|
|
c->options |= MIPS_CPU_MICROMIPS;
|
2013-02-17 05:42:43 +07:00
|
|
|
if (config3 & MIPS_CONF3_VZ)
|
|
|
|
c->ases |= MIPS_ASE_VZ;
|
2013-11-14 23:12:24 +07:00
|
|
|
if (config3 & MIPS_CONF3_SC)
|
|
|
|
c->options |= MIPS_CPU_SEGMENTS;
|
2014-01-27 22:23:10 +07:00
|
|
|
if (config3 & MIPS_CONF3_MSA)
|
|
|
|
c->ases |= MIPS_ASE_MSA;
|
2014-07-14 18:46:13 +07:00
|
|
|
/* Only tested on 32-bit cores */
|
2015-01-26 20:04:33 +07:00
|
|
|
if ((config3 & MIPS_CONF3_PW) && config_enabled(CONFIG_32BIT)) {
|
|
|
|
c->htw_seq = 0;
|
2014-07-14 18:46:13 +07:00
|
|
|
c->options |= MIPS_CPU_HTW;
|
2015-01-26 20:04:33 +07:00
|
|
|
}
|
2012-06-21 02:05:32 +07:00
|
|
|
|
|
|
|
return config3 & MIPS_CONF_M;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int decode_config4(struct cpuinfo_mips *c)
|
|
|
|
{
|
|
|
|
unsigned int config4;
|
2013-11-14 23:12:31 +07:00
|
|
|
unsigned int newcf4;
|
|
|
|
unsigned int mmuextdef;
|
|
|
|
unsigned int ftlb_page = MIPS_CONF4_FTLBPAGESIZE;
|
2012-06-21 02:05:32 +07:00
|
|
|
|
|
|
|
config4 = read_c0_config4();
|
|
|
|
|
2013-11-14 23:12:23 +07:00
|
|
|
if (cpu_has_tlb) {
|
|
|
|
if (((config4 & MIPS_CONF4_IE) >> 29) == 2)
|
|
|
|
c->options |= MIPS_CPU_TLBINV;
|
2013-11-14 23:12:31 +07:00
|
|
|
mmuextdef = config4 & MIPS_CONF4_MMUEXTDEF;
|
|
|
|
switch (mmuextdef) {
|
|
|
|
case MIPS_CONF4_MMUEXTDEF_MMUSIZEEXT:
|
|
|
|
c->tlbsize += (config4 & MIPS_CONF4_MMUSIZEEXT) * 0x40;
|
|
|
|
c->tlbsizevtlb = c->tlbsize;
|
|
|
|
break;
|
|
|
|
case MIPS_CONF4_MMUEXTDEF_VTLBSIZEEXT:
|
|
|
|
c->tlbsizevtlb +=
|
|
|
|
((config4 & MIPS_CONF4_VTLBSIZEEXT) >>
|
|
|
|
MIPS_CONF4_VTLBSIZEEXT_SHIFT) * 0x40;
|
|
|
|
c->tlbsize = c->tlbsizevtlb;
|
|
|
|
ftlb_page = MIPS_CONF4_VFTLBPAGESIZE;
|
|
|
|
/* fall through */
|
|
|
|
case MIPS_CONF4_MMUEXTDEF_FTLBSIZEEXT:
|
2014-08-29 15:37:26 +07:00
|
|
|
if (mips_ftlb_disabled)
|
|
|
|
break;
|
2013-11-14 23:12:31 +07:00
|
|
|
newcf4 = (config4 & ~ftlb_page) |
|
|
|
|
(page_size_ftlb(mmuextdef) <<
|
|
|
|
MIPS_CONF4_FTLBPAGESIZE_SHIFT);
|
|
|
|
write_c0_config4(newcf4);
|
|
|
|
back_to_back_c0_hazard();
|
|
|
|
config4 = read_c0_config4();
|
|
|
|
if (config4 != newcf4) {
|
|
|
|
pr_err("PAGE_SIZE 0x%lx is not supported by FTLB (config4=0x%x)\n",
|
|
|
|
PAGE_SIZE, config4);
|
|
|
|
/* Switch FTLB off */
|
|
|
|
set_ftlb_enable(c, 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
c->tlbsizeftlbsets = 1 <<
|
|
|
|
((config4 & MIPS_CONF4_FTLBSETS) >>
|
|
|
|
MIPS_CONF4_FTLBSETS_SHIFT);
|
|
|
|
c->tlbsizeftlbways = ((config4 & MIPS_CONF4_FTLBWAYS) >>
|
|
|
|
MIPS_CONF4_FTLBWAYS_SHIFT) + 2;
|
|
|
|
c->tlbsize += c->tlbsizeftlbways * c->tlbsizeftlbsets;
|
2014-08-29 15:37:26 +07:00
|
|
|
mips_has_ftlb_configured = 1;
|
2013-11-14 23:12:31 +07:00
|
|
|
break;
|
|
|
|
}
|
2013-11-14 23:12:23 +07:00
|
|
|
}
|
|
|
|
|
2012-06-21 02:05:32 +07:00
|
|
|
c->kscratch_mask = (config4 >> 16) & 0xff;
|
|
|
|
|
|
|
|
return config4 & MIPS_CONF_M;
|
|
|
|
}
|
|
|
|
|
2013-09-19 16:15:49 +07:00
|
|
|
static inline unsigned int decode_config5(struct cpuinfo_mips *c)
|
|
|
|
{
|
|
|
|
unsigned int config5;
|
|
|
|
|
|
|
|
config5 = read_c0_config5();
|
2014-09-11 14:30:19 +07:00
|
|
|
config5 &= ~(MIPS_CONF5_UFR | MIPS_CONF5_UFE);
|
2013-09-19 16:15:49 +07:00
|
|
|
write_c0_config5(config5);
|
|
|
|
|
2014-01-09 23:04:51 +07:00
|
|
|
if (config5 & MIPS_CONF5_EVA)
|
|
|
|
c->options |= MIPS_CPU_EVA;
|
2014-07-14 16:32:14 +07:00
|
|
|
if (config5 & MIPS_CONF5_MRP)
|
|
|
|
c->options |= MIPS_CPU_MAAR;
|
2014-12-02 16:46:19 +07:00
|
|
|
if (config5 & MIPS_CONF5_LLB)
|
|
|
|
c->options |= MIPS_CPU_RW_LLB;
|
2014-01-09 23:04:51 +07:00
|
|
|
|
2013-09-19 16:15:49 +07:00
|
|
|
return config5 & MIPS_CONF_M;
|
|
|
|
}
|
|
|
|
|
MIPS: Delete __cpuinit/__CPUINIT usage from MIPS code
commit 3747069b25e419f6b51395f48127e9812abc3596 upstream.
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
and are flagged as __cpuinit -- so if we remove the __cpuinit from
the arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
related content into no-ops as early as possible, since that will get
rid of these warnings. In any case, they are temporary and harmless.
Here, we remove all the MIPS __cpuinit from C code and __CPUINIT
from asm files. MIPS is interesting in this respect, because there
are also uasm users hiding behind their own renamed versions of the
__cpuinit macros.
[1] https://lkml.org/lkml/2013/5/20/589
[ralf@linux-mips.org: Folded in Paul's followup fix.]
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/5494/
Patchwork: https://patchwork.linux-mips.org/patch/5495/
Patchwork: https://patchwork.linux-mips.org/patch/5509/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2013-06-18 20:38:59 +07:00
|
|
|
static void decode_configs(struct cpuinfo_mips *c)
|
2012-06-21 02:05:32 +07:00
|
|
|
{
|
|
|
|
int ok;
|
|
|
|
|
|
|
|
/* MIPS32 or MIPS64 compliant CPU. */
|
|
|
|
c->options = MIPS_CPU_4KEX | MIPS_CPU_4K_CACHE | MIPS_CPU_COUNTER |
|
|
|
|
MIPS_CPU_DIVEC | MIPS_CPU_LLSC | MIPS_CPU_MCHECK;
|
|
|
|
|
|
|
|
c->scache.flags = MIPS_CACHE_NOT_PRESENT;
|
|
|
|
|
2014-08-29 15:37:26 +07:00
|
|
|
/* Enable FTLB if present and not disabled */
|
|
|
|
set_ftlb_enable(c, !mips_ftlb_disabled);
|
2013-11-14 23:12:31 +07:00
|
|
|
|
2012-06-21 02:05:32 +07:00
|
|
|
ok = decode_config0(c); /* Read Config registers. */
|
2013-01-22 18:59:30 +07:00
|
|
|
BUG_ON(!ok); /* Arch spec violation! */
|
2012-06-21 02:05:32 +07:00
|
|
|
if (ok)
|
|
|
|
ok = decode_config1(c);
|
|
|
|
if (ok)
|
|
|
|
ok = decode_config2(c);
|
|
|
|
if (ok)
|
|
|
|
ok = decode_config3(c);
|
|
|
|
if (ok)
|
|
|
|
ok = decode_config4(c);
|
2013-09-19 16:15:49 +07:00
|
|
|
if (ok)
|
|
|
|
ok = decode_config5(c);
|
2012-06-21 02:05:32 +07:00
|
|
|
|
|
|
|
mips_probe_watch_registers(c);
|
|
|
|
|
2014-07-15 20:09:57 +07:00
|
|
|
if (cpu_has_rixi) {
|
|
|
|
/* Enable the RIXI exceptions */
|
2015-02-19 23:18:52 +07:00
|
|
|
set_c0_pagegrain(PG_IEC);
|
2014-07-15 20:09:57 +07:00
|
|
|
back_to_back_c0_hazard();
|
|
|
|
/* Verify the IEC bit is set */
|
|
|
|
if (read_c0_pagegrain() & PG_IEC)
|
|
|
|
c->options |= MIPS_CPU_RIXIEX;
|
|
|
|
}
|
|
|
|
|
2014-01-15 17:31:53 +07:00
|
|
|
#ifndef CONFIG_MIPS_CPS
|
2014-11-13 20:51:51 +07:00
|
|
|
if (cpu_has_mips_r2_r6) {
|
2014-05-29 04:52:10 +07:00
|
|
|
c->core = get_ebase_cpunum();
|
2014-03-27 17:57:30 +07:00
|
|
|
if (cpu_has_mipsmt)
|
|
|
|
c->core >>= fls(core_nvpes()) - 1;
|
|
|
|
}
|
2014-01-15 17:31:53 +07:00
|
|
|
#endif
|
2012-06-21 02:05:32 +07:00
|
|
|
}
|
|
|
|
|
2005-10-01 19:06:32 +07:00
|
|
|
#define R4K_OPTS (MIPS_CPU_TLB | MIPS_CPU_4KEX | MIPS_CPU_4K_CACHE \
|
2005-04-17 05:20:36 +07:00
|
|
|
| MIPS_CPU_COUNTER)
|
|
|
|
|
2008-10-30 20:38:45 +07:00
|
|
|
static inline void cpu_probe_legacy(struct cpuinfo_mips *c, unsigned int cpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2013-09-17 22:58:10 +07:00
|
|
|
switch (c->processor_id & PRID_IMP_MASK) {
|
2005-04-17 05:20:36 +07:00
|
|
|
case PRID_IMP_R2000:
|
|
|
|
c->cputype = CPU_R2000;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R2000";
|
2005-10-01 19:06:32 +07:00
|
|
|
c->options = MIPS_CPU_TLB | MIPS_CPU_3K_CACHE |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_NOFPUEX;
|
2005-04-17 05:20:36 +07:00
|
|
|
if (__cpu_has_fpu())
|
|
|
|
c->options |= MIPS_CPU_FPU;
|
|
|
|
c->tlbsize = 64;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_R3000:
|
2013-09-17 22:58:10 +07:00
|
|
|
if ((c->processor_id & PRID_REV_MASK) == PRID_REV_R3000A) {
|
2008-10-30 20:38:45 +07:00
|
|
|
if (cpu_has_confreg()) {
|
2005-04-17 05:20:36 +07:00
|
|
|
c->cputype = CPU_R3081E;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R3081";
|
|
|
|
} else {
|
2005-04-17 05:20:36 +07:00
|
|
|
c->cputype = CPU_R3000A;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R3000A";
|
|
|
|
}
|
|
|
|
} else {
|
2005-04-17 05:20:36 +07:00
|
|
|
c->cputype = CPU_R3000;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R3000";
|
|
|
|
}
|
2005-10-01 19:06:32 +07:00
|
|
|
c->options = MIPS_CPU_TLB | MIPS_CPU_3K_CACHE |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_NOFPUEX;
|
2005-04-17 05:20:36 +07:00
|
|
|
if (__cpu_has_fpu())
|
|
|
|
c->options |= MIPS_CPU_FPU;
|
|
|
|
c->tlbsize = 64;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_R4000:
|
|
|
|
if (read_c0_config() & CONF_SC) {
|
2013-09-17 22:58:10 +07:00
|
|
|
if ((c->processor_id & PRID_REV_MASK) >=
|
|
|
|
PRID_REV_R4400) {
|
2005-04-17 05:20:36 +07:00
|
|
|
c->cputype = CPU_R4400PC;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R4400PC";
|
|
|
|
} else {
|
2005-04-17 05:20:36 +07:00
|
|
|
c->cputype = CPU_R4000PC;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R4000PC";
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
2013-09-23 20:01:53 +07:00
|
|
|
int cca = read_c0_config() & CONF_CM_CMASK;
|
|
|
|
int mc;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SC and MC versions can't be reliably told apart,
|
|
|
|
* but only the latter support coherent caching
|
|
|
|
* modes so assume the firmware has set the KSEG0
|
|
|
|
* coherency attribute reasonably (if uncached, we
|
|
|
|
* assume SC).
|
|
|
|
*/
|
|
|
|
switch (cca) {
|
|
|
|
case CONF_CM_CACHABLE_CE:
|
|
|
|
case CONF_CM_CACHABLE_COW:
|
|
|
|
case CONF_CM_CACHABLE_CUW:
|
|
|
|
mc = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
mc = 0;
|
|
|
|
break;
|
|
|
|
}
|
2013-09-17 22:58:10 +07:00
|
|
|
if ((c->processor_id & PRID_REV_MASK) >=
|
|
|
|
PRID_REV_R4400) {
|
2013-09-23 20:01:53 +07:00
|
|
|
c->cputype = mc ? CPU_R4400MC : CPU_R4400SC;
|
|
|
|
__cpu_name[cpu] = mc ? "R4400MC" : "R4400SC";
|
2008-10-30 20:38:45 +07:00
|
|
|
} else {
|
2013-09-23 20:01:53 +07:00
|
|
|
c->cputype = mc ? CPU_R4000MC : CPU_R4000SC;
|
|
|
|
__cpu_name[cpu] = mc ? "R4000MC" : "R4000SC";
|
2008-10-30 20:38:45 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_III);
|
2005-04-17 05:20:36 +07:00
|
|
|
c->options = R4K_OPTS | MIPS_CPU_FPU | MIPS_CPU_32FPR |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_WATCH | MIPS_CPU_VCE |
|
|
|
|
MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 48;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_VR41XX:
|
2013-02-21 13:38:19 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_III);
|
|
|
|
c->options = R4K_OPTS;
|
|
|
|
c->tlbsize = 32;
|
2005-04-17 05:20:36 +07:00
|
|
|
switch (c->processor_id & 0xf0) {
|
|
|
|
case PRID_REV_VR4111:
|
|
|
|
c->cputype = CPU_VR4111;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "NEC VR4111";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case PRID_REV_VR4121:
|
|
|
|
c->cputype = CPU_VR4121;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "NEC VR4121";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case PRID_REV_VR4122:
|
2008-10-30 20:38:45 +07:00
|
|
|
if ((c->processor_id & 0xf) < 0x3) {
|
2005-04-17 05:20:36 +07:00
|
|
|
c->cputype = CPU_VR4122;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "NEC VR4122";
|
|
|
|
} else {
|
2005-04-17 05:20:36 +07:00
|
|
|
c->cputype = CPU_VR4181A;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "NEC VR4181A";
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case PRID_REV_VR4130:
|
2008-10-30 20:38:45 +07:00
|
|
|
if ((c->processor_id & 0xf) < 0x4) {
|
2005-04-17 05:20:36 +07:00
|
|
|
c->cputype = CPU_VR4131;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "NEC VR4131";
|
|
|
|
} else {
|
2005-04-17 05:20:36 +07:00
|
|
|
c->cputype = CPU_VR4133;
|
2013-02-21 13:38:19 +07:00
|
|
|
c->options |= MIPS_CPU_LLSC;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "NEC VR4133";
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk(KERN_INFO "Unexpected CPU of NEC VR4100 series\n");
|
|
|
|
c->cputype = CPU_VR41XX;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "NEC Vr41xx";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PRID_IMP_R4300:
|
|
|
|
c->cputype = CPU_R4300;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R4300";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_III);
|
2005-04-17 05:20:36 +07:00
|
|
|
c->options = R4K_OPTS | MIPS_CPU_FPU | MIPS_CPU_32FPR |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 32;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_R4600:
|
|
|
|
c->cputype = CPU_R4600;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R4600";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_III);
|
2005-07-28 04:48:12 +07:00
|
|
|
c->options = R4K_OPTS | MIPS_CPU_FPU | MIPS_CPU_32FPR |
|
|
|
|
MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 48;
|
|
|
|
break;
|
|
|
|
#if 0
|
2012-05-11 11:21:18 +07:00
|
|
|
case PRID_IMP_R4650:
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* This processor doesn't have an MMU, so it's not
|
|
|
|
* "real easy" to run Linux on it. It is left purely
|
|
|
|
* for documentation. Commented out because it shares
|
|
|
|
* it's c0_prid id number with the TX3900.
|
|
|
|
*/
|
2006-03-11 15:18:41 +07:00
|
|
|
c->cputype = CPU_R4650;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R4650";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_III);
|
2005-04-17 05:20:36 +07:00
|
|
|
c->options = R4K_OPTS | MIPS_CPU_FPU | MIPS_CPU_LLSC;
|
2012-05-11 11:21:18 +07:00
|
|
|
c->tlbsize = 48;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case PRID_IMP_TX39:
|
2005-10-01 19:06:32 +07:00
|
|
|
c->options = MIPS_CPU_TLB | MIPS_CPU_TX39_CACHE;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if ((c->processor_id & 0xf0) == (PRID_REV_TX3927 & 0xf0)) {
|
|
|
|
c->cputype = CPU_TX3927;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "TX3927";
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 64;
|
|
|
|
} else {
|
2013-09-17 22:58:10 +07:00
|
|
|
switch (c->processor_id & PRID_REV_MASK) {
|
2005-04-17 05:20:36 +07:00
|
|
|
case PRID_REV_TX3912:
|
|
|
|
c->cputype = CPU_TX3912;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "TX3912";
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 32;
|
|
|
|
break;
|
|
|
|
case PRID_REV_TX3922:
|
|
|
|
c->cputype = CPU_TX3922;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "TX3922";
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 64;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PRID_IMP_R4700:
|
|
|
|
c->cputype = CPU_R4700;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R4700";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_III);
|
2005-04-17 05:20:36 +07:00
|
|
|
c->options = R4K_OPTS | MIPS_CPU_FPU | MIPS_CPU_32FPR |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 48;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_TX49:
|
|
|
|
c->cputype = CPU_TX49XX;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R49XX";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_III);
|
2005-04-17 05:20:36 +07:00
|
|
|
c->options = R4K_OPTS | MIPS_CPU_LLSC;
|
|
|
|
if (!(c->processor_id & 0x08))
|
|
|
|
c->options |= MIPS_CPU_FPU | MIPS_CPU_32FPR;
|
|
|
|
c->tlbsize = 48;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_R5000:
|
|
|
|
c->cputype = CPU_R5000;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R5000";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_IV);
|
2005-04-17 05:20:36 +07:00
|
|
|
c->options = R4K_OPTS | MIPS_CPU_FPU | MIPS_CPU_32FPR |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 48;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_R5432:
|
|
|
|
c->cputype = CPU_R5432;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R5432";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_IV);
|
2005-04-17 05:20:36 +07:00
|
|
|
c->options = R4K_OPTS | MIPS_CPU_FPU | MIPS_CPU_32FPR |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_WATCH | MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 48;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_R5500:
|
|
|
|
c->cputype = CPU_R5500;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R5500";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_IV);
|
2005-04-17 05:20:36 +07:00
|
|
|
c->options = R4K_OPTS | MIPS_CPU_FPU | MIPS_CPU_32FPR |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_WATCH | MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 48;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_NEVADA:
|
|
|
|
c->cputype = CPU_NEVADA;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "Nevada";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_IV);
|
2005-04-17 05:20:36 +07:00
|
|
|
c->options = R4K_OPTS | MIPS_CPU_FPU | MIPS_CPU_32FPR |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_DIVEC | MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 48;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_R6000:
|
|
|
|
c->cputype = CPU_R6000;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R6000";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_II);
|
2005-04-17 05:20:36 +07:00
|
|
|
c->options = MIPS_CPU_TLB | MIPS_CPU_FPU |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 32;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_R6000A:
|
|
|
|
c->cputype = CPU_R6000A;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R6000A";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_II);
|
2005-04-17 05:20:36 +07:00
|
|
|
c->options = MIPS_CPU_TLB | MIPS_CPU_FPU |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 32;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_RM7000:
|
|
|
|
c->cputype = CPU_RM7000;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "RM7000";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_IV);
|
2005-04-17 05:20:36 +07:00
|
|
|
c->options = R4K_OPTS | MIPS_CPU_FPU | MIPS_CPU_32FPR |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2013-01-22 18:59:30 +07:00
|
|
|
* Undocumented RM7000: Bit 29 in the info register of
|
2005-04-17 05:20:36 +07:00
|
|
|
* the RM7000 v2.0 indicates if the TLB has 48 or 64
|
|
|
|
* entries.
|
|
|
|
*
|
2013-01-22 18:59:30 +07:00
|
|
|
* 29 1 => 64 entry JTLB
|
|
|
|
* 0 => 48 entry JTLB
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
c->tlbsize = (read_c0_info() & (1 << 29)) ? 64 : 48;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_R8000:
|
|
|
|
c->cputype = CPU_R8000;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "RM8000";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_IV);
|
2005-04-17 05:20:36 +07:00
|
|
|
c->options = MIPS_CPU_TLB | MIPS_CPU_4KEX |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_FPU | MIPS_CPU_32FPR |
|
|
|
|
MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 384; /* has weird TLB: 3-way x 128 */
|
|
|
|
break;
|
|
|
|
case PRID_IMP_R10000:
|
|
|
|
c->cputype = CPU_R10000;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R10000";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_IV);
|
2005-11-23 00:53:59 +07:00
|
|
|
c->options = MIPS_CPU_TLB | MIPS_CPU_4K_CACHE | MIPS_CPU_4KEX |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_FPU | MIPS_CPU_32FPR |
|
2005-04-17 05:20:36 +07:00
|
|
|
MIPS_CPU_COUNTER | MIPS_CPU_WATCH |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 64;
|
|
|
|
break;
|
|
|
|
case PRID_IMP_R12000:
|
|
|
|
c->cputype = CPU_R12000;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R12000";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_IV);
|
2005-11-23 00:53:59 +07:00
|
|
|
c->options = MIPS_CPU_TLB | MIPS_CPU_4K_CACHE | MIPS_CPU_4KEX |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_FPU | MIPS_CPU_32FPR |
|
2005-04-17 05:20:36 +07:00
|
|
|
MIPS_CPU_COUNTER | MIPS_CPU_WATCH |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_LLSC;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->tlbsize = 64;
|
|
|
|
break;
|
2006-05-17 09:23:59 +07:00
|
|
|
case PRID_IMP_R14000:
|
|
|
|
c->cputype = CPU_R14000;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "R14000";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_IV);
|
2006-05-17 09:23:59 +07:00
|
|
|
c->options = MIPS_CPU_TLB | MIPS_CPU_4K_CACHE | MIPS_CPU_4KEX |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_FPU | MIPS_CPU_32FPR |
|
2006-05-17 09:23:59 +07:00
|
|
|
MIPS_CPU_COUNTER | MIPS_CPU_WATCH |
|
2012-05-11 11:21:18 +07:00
|
|
|
MIPS_CPU_LLSC;
|
2006-05-17 09:23:59 +07:00
|
|
|
c->tlbsize = 64;
|
|
|
|
break;
|
2014-02-16 15:01:18 +07:00
|
|
|
case PRID_IMP_LOONGSON_64: /* Loongson-2/3 */
|
2011-04-17 01:29:29 +07:00
|
|
|
switch (c->processor_id & PRID_REV_MASK) {
|
|
|
|
case PRID_REV_LOONGSON2E:
|
2014-03-21 17:44:00 +07:00
|
|
|
c->cputype = CPU_LOONGSON2;
|
|
|
|
__cpu_name[cpu] = "ICT Loongson-2";
|
2011-04-17 01:29:29 +07:00
|
|
|
set_elf_platform(cpu, "loongson2e");
|
2014-11-04 13:13:23 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_III);
|
2011-04-17 01:29:29 +07:00
|
|
|
break;
|
|
|
|
case PRID_REV_LOONGSON2F:
|
2014-03-21 17:44:00 +07:00
|
|
|
c->cputype = CPU_LOONGSON2;
|
|
|
|
__cpu_name[cpu] = "ICT Loongson-2";
|
2011-04-17 01:29:29 +07:00
|
|
|
set_elf_platform(cpu, "loongson2f");
|
2014-11-04 13:13:23 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_III);
|
2011-04-17 01:29:29 +07:00
|
|
|
break;
|
2014-03-21 17:44:00 +07:00
|
|
|
case PRID_REV_LOONGSON3A:
|
|
|
|
c->cputype = CPU_LOONGSON3;
|
|
|
|
__cpu_name[cpu] = "ICT Loongson-3";
|
|
|
|
set_elf_platform(cpu, "loongson3a");
|
2014-11-04 13:13:23 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_M64R1);
|
2014-03-21 17:44:00 +07:00
|
|
|
break;
|
2014-06-26 10:41:30 +07:00
|
|
|
case PRID_REV_LOONGSON3B_R1:
|
|
|
|
case PRID_REV_LOONGSON3B_R2:
|
|
|
|
c->cputype = CPU_LOONGSON3;
|
|
|
|
__cpu_name[cpu] = "ICT Loongson-3";
|
|
|
|
set_elf_platform(cpu, "loongson3b");
|
2014-11-04 13:13:23 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_M64R1);
|
2014-06-26 10:41:30 +07:00
|
|
|
break;
|
2011-04-17 01:29:29 +07:00
|
|
|
}
|
|
|
|
|
2007-06-06 13:52:43 +07:00
|
|
|
c->options = R4K_OPTS |
|
|
|
|
MIPS_CPU_FPU | MIPS_CPU_LLSC |
|
|
|
|
MIPS_CPU_32FPR;
|
|
|
|
c->tlbsize = 64;
|
2014-11-04 13:13:22 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED_ACCELERATED;
|
2007-06-06 13:52:43 +07:00
|
|
|
break;
|
2014-02-16 15:01:18 +07:00
|
|
|
case PRID_IMP_LOONGSON_32: /* Loongson-1 */
|
2012-06-21 02:05:32 +07:00
|
|
|
decode_configs(c);
|
2005-12-08 21:04:24 +07:00
|
|
|
|
2012-06-21 02:05:32 +07:00
|
|
|
c->cputype = CPU_LOONGSON1;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-06-21 02:05:32 +07:00
|
|
|
switch (c->processor_id & PRID_REV_MASK) {
|
|
|
|
case PRID_REV_LOONGSON1B:
|
|
|
|
__cpu_name[cpu] = "Loongson 1B";
|
2005-12-08 21:04:24 +07:00
|
|
|
break;
|
|
|
|
}
|
2005-05-05 23:45:59 +07:00
|
|
|
|
2012-06-21 02:05:32 +07:00
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-30 20:38:45 +07:00
|
|
|
static inline void cpu_probe_mips(struct cpuinfo_mips *c, unsigned int cpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED_ACCELERATED;
|
2013-09-17 22:58:10 +07:00
|
|
|
switch (c->processor_id & PRID_IMP_MASK) {
|
2014-11-24 19:59:44 +07:00
|
|
|
case PRID_IMP_QEMU_GENERIC:
|
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
|
|
|
c->cputype = CPU_QEMU_GENERIC;
|
|
|
|
__cpu_name[cpu] = "MIPS GENERIC QEMU";
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
case PRID_IMP_4KC:
|
|
|
|
c->cputype = CPU_4KC;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "MIPS 4Kc";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case PRID_IMP_4KEC:
|
2005-04-09 03:36:05 +07:00
|
|
|
case PRID_IMP_4KECR2:
|
|
|
|
c->cputype = CPU_4KEC;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "MIPS 4KEc";
|
2005-04-09 03:36:05 +07:00
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
case PRID_IMP_4KSC:
|
2005-10-04 21:01:26 +07:00
|
|
|
case PRID_IMP_4KSD:
|
2005-04-17 05:20:36 +07:00
|
|
|
c->cputype = CPU_4KSC;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "MIPS 4KSc";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case PRID_IMP_5KC:
|
|
|
|
c->cputype = CPU_5KC;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "MIPS 5Kc";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
2012-07-07 02:56:01 +07:00
|
|
|
case PRID_IMP_5KE:
|
|
|
|
c->cputype = CPU_5KE;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2012-07-07 02:56:01 +07:00
|
|
|
__cpu_name[cpu] = "MIPS 5KE";
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
case PRID_IMP_20KC:
|
|
|
|
c->cputype = CPU_20KC;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "MIPS 20Kc";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case PRID_IMP_24K:
|
|
|
|
c->cputype = CPU_24K;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "MIPS 24Kc";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
2013-01-12 04:44:10 +07:00
|
|
|
case PRID_IMP_24KE:
|
|
|
|
c->cputype = CPU_24K;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2013-01-12 04:44:10 +07:00
|
|
|
__cpu_name[cpu] = "MIPS 24KEc";
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
case PRID_IMP_25KF:
|
|
|
|
c->cputype = CPU_25KF;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "MIPS 25Kc";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
2005-07-12 23:12:05 +07:00
|
|
|
case PRID_IMP_34K:
|
|
|
|
c->cputype = CPU_34K;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "MIPS 34Kc";
|
2005-07-12 23:12:05 +07:00
|
|
|
break;
|
2006-05-02 20:08:46 +07:00
|
|
|
case PRID_IMP_74K:
|
|
|
|
c->cputype = CPU_74K;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "MIPS 74Kc";
|
2006-05-02 20:08:46 +07:00
|
|
|
break;
|
2012-07-07 04:56:00 +07:00
|
|
|
case PRID_IMP_M14KC:
|
|
|
|
c->cputype = CPU_M14KC;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2012-07-07 04:56:00 +07:00
|
|
|
__cpu_name[cpu] = "MIPS M14Kc";
|
|
|
|
break;
|
2012-12-07 10:51:35 +07:00
|
|
|
case PRID_IMP_M14KEC:
|
|
|
|
c->cputype = CPU_M14KEC;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2012-12-07 10:51:35 +07:00
|
|
|
__cpu_name[cpu] = "MIPS M14KEc";
|
|
|
|
break;
|
2008-04-28 23:14:26 +07:00
|
|
|
case PRID_IMP_1004K:
|
|
|
|
c->cputype = CPU_1004K;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "MIPS 1004Kc";
|
2008-04-28 23:14:26 +07:00
|
|
|
break;
|
2012-06-26 11:11:03 +07:00
|
|
|
case PRID_IMP_1074K:
|
2014-01-18 04:03:50 +07:00
|
|
|
c->cputype = CPU_1074K;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2012-06-26 11:11:03 +07:00
|
|
|
__cpu_name[cpu] = "MIPS 1074Kc";
|
|
|
|
break;
|
2013-11-20 17:46:02 +07:00
|
|
|
case PRID_IMP_INTERAPTIV_UP:
|
|
|
|
c->cputype = CPU_INTERAPTIV;
|
|
|
|
__cpu_name[cpu] = "MIPS interAptiv";
|
|
|
|
break;
|
|
|
|
case PRID_IMP_INTERAPTIV_MP:
|
|
|
|
c->cputype = CPU_INTERAPTIV;
|
|
|
|
__cpu_name[cpu] = "MIPS interAptiv (multi)";
|
|
|
|
break;
|
2013-11-14 23:12:28 +07:00
|
|
|
case PRID_IMP_PROAPTIV_UP:
|
|
|
|
c->cputype = CPU_PROAPTIV;
|
|
|
|
__cpu_name[cpu] = "MIPS proAptiv";
|
|
|
|
break;
|
|
|
|
case PRID_IMP_PROAPTIV_MP:
|
|
|
|
c->cputype = CPU_PROAPTIV;
|
|
|
|
__cpu_name[cpu] = "MIPS proAptiv (multi)";
|
|
|
|
break;
|
2014-01-22 23:19:39 +07:00
|
|
|
case PRID_IMP_P5600:
|
|
|
|
c->cputype = CPU_P5600;
|
|
|
|
__cpu_name[cpu] = "MIPS P5600";
|
|
|
|
break;
|
2014-03-04 20:34:44 +07:00
|
|
|
case PRID_IMP_M5150:
|
|
|
|
c->cputype = CPU_M5150;
|
|
|
|
__cpu_name[cpu] = "MIPS M5150";
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-09-13 18:32:02 +07:00
|
|
|
|
2013-11-14 23:12:31 +07:00
|
|
|
decode_configs(c);
|
|
|
|
|
2007-09-13 18:32:02 +07:00
|
|
|
spram_config();
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-10-30 20:38:45 +07:00
|
|
|
static inline void cpu_probe_alchemy(struct cpuinfo_mips *c, unsigned int cpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-05-05 23:45:59 +07:00
|
|
|
decode_configs(c);
|
2013-09-17 22:58:10 +07:00
|
|
|
switch (c->processor_id & PRID_IMP_MASK) {
|
2005-04-17 05:20:36 +07:00
|
|
|
case PRID_IMP_AU1_REV1:
|
|
|
|
case PRID_IMP_AU1_REV2:
|
2009-03-25 23:49:28 +07:00
|
|
|
c->cputype = CPU_ALCHEMY;
|
2005-04-17 05:20:36 +07:00
|
|
|
switch ((c->processor_id >> 24) & 0xff) {
|
|
|
|
case 0:
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "Au1000";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case 1:
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "Au1500";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case 2:
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "Au1100";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case 3:
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "Au1550";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
2005-03-01 13:33:16 +07:00
|
|
|
case 4:
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "Au1200";
|
2013-09-17 22:58:10 +07:00
|
|
|
if ((c->processor_id & PRID_REV_MASK) == 2)
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "Au1250";
|
2007-12-06 15:07:55 +07:00
|
|
|
break;
|
|
|
|
case 5:
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "Au1210";
|
2005-03-01 13:33:16 +07:00
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
default:
|
2009-03-25 23:49:28 +07:00
|
|
|
__cpu_name[cpu] = "Au1xxx";
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-30 20:38:45 +07:00
|
|
|
static inline void cpu_probe_sibyte(struct cpuinfo_mips *c, unsigned int cpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-05-05 23:45:59 +07:00
|
|
|
decode_configs(c);
|
2005-10-01 19:06:32 +07:00
|
|
|
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED_ACCELERATED;
|
2013-09-17 22:58:10 +07:00
|
|
|
switch (c->processor_id & PRID_IMP_MASK) {
|
2005-04-17 05:20:36 +07:00
|
|
|
case PRID_IMP_SB1:
|
|
|
|
c->cputype = CPU_SB1;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "SiByte SB1";
|
2005-04-17 05:20:36 +07:00
|
|
|
/* FPU in pass1 is known to have issues. */
|
2013-09-17 22:58:10 +07:00
|
|
|
if ((c->processor_id & PRID_REV_MASK) < 0x02)
|
2006-01-30 01:42:08 +07:00
|
|
|
c->options &= ~(MIPS_CPU_FPU | MIPS_CPU_32FPR);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
2005-10-20 13:56:20 +07:00
|
|
|
case PRID_IMP_SB1A:
|
|
|
|
c->cputype = CPU_SB1A;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "SiByte SB1A";
|
2005-10-20 13:56:20 +07:00
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-30 20:38:45 +07:00
|
|
|
static inline void cpu_probe_sandcraft(struct cpuinfo_mips *c, unsigned int cpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-05-05 23:45:59 +07:00
|
|
|
decode_configs(c);
|
2013-09-17 22:58:10 +07:00
|
|
|
switch (c->processor_id & PRID_IMP_MASK) {
|
2005-04-17 05:20:36 +07:00
|
|
|
case PRID_IMP_SR71000:
|
|
|
|
c->cputype = CPU_SR71000;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "Sandcraft SR71000";
|
2005-04-17 05:20:36 +07:00
|
|
|
c->scache.ways = 8;
|
|
|
|
c->tlbsize = 64;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-30 20:38:45 +07:00
|
|
|
static inline void cpu_probe_nxp(struct cpuinfo_mips *c, unsigned int cpu)
|
2005-07-15 00:47:57 +07:00
|
|
|
{
|
|
|
|
decode_configs(c);
|
2013-09-17 22:58:10 +07:00
|
|
|
switch (c->processor_id & PRID_IMP_MASK) {
|
2005-07-15 00:47:57 +07:00
|
|
|
case PRID_IMP_PR4450:
|
|
|
|
c->cputype = CPU_PR4450;
|
2008-10-30 20:38:45 +07:00
|
|
|
__cpu_name[cpu] = "Philips PR4450";
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_M32R1);
|
2005-07-15 00:47:57 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-30 20:38:45 +07:00
|
|
|
static inline void cpu_probe_broadcom(struct cpuinfo_mips *c, unsigned int cpu)
|
2007-09-25 20:40:12 +07:00
|
|
|
{
|
|
|
|
decode_configs(c);
|
2013-09-17 22:58:10 +07:00
|
|
|
switch (c->processor_id & PRID_IMP_MASK) {
|
2010-11-24 01:26:45 +07:00
|
|
|
case PRID_IMP_BMIPS32_REV4:
|
|
|
|
case PRID_IMP_BMIPS32_REV8:
|
2010-10-17 04:22:30 +07:00
|
|
|
c->cputype = CPU_BMIPS32;
|
|
|
|
__cpu_name[cpu] = "Broadcom BMIPS32";
|
2011-04-17 01:29:28 +07:00
|
|
|
set_elf_platform(cpu, "bmips32");
|
2010-10-17 04:22:30 +07:00
|
|
|
break;
|
|
|
|
case PRID_IMP_BMIPS3300:
|
|
|
|
case PRID_IMP_BMIPS3300_ALT:
|
|
|
|
case PRID_IMP_BMIPS3300_BUG:
|
|
|
|
c->cputype = CPU_BMIPS3300;
|
|
|
|
__cpu_name[cpu] = "Broadcom BMIPS3300";
|
2011-04-17 01:29:28 +07:00
|
|
|
set_elf_platform(cpu, "bmips3300");
|
2010-10-17 04:22:30 +07:00
|
|
|
break;
|
|
|
|
case PRID_IMP_BMIPS43XX: {
|
2013-09-17 22:58:10 +07:00
|
|
|
int rev = c->processor_id & PRID_REV_MASK;
|
2010-10-17 04:22:30 +07:00
|
|
|
|
|
|
|
if (rev >= PRID_REV_BMIPS4380_LO &&
|
|
|
|
rev <= PRID_REV_BMIPS4380_HI) {
|
|
|
|
c->cputype = CPU_BMIPS4380;
|
|
|
|
__cpu_name[cpu] = "Broadcom BMIPS4380";
|
2011-04-17 01:29:28 +07:00
|
|
|
set_elf_platform(cpu, "bmips4380");
|
2010-10-17 04:22:30 +07:00
|
|
|
} else {
|
|
|
|
c->cputype = CPU_BMIPS4350;
|
|
|
|
__cpu_name[cpu] = "Broadcom BMIPS4350";
|
2011-04-17 01:29:28 +07:00
|
|
|
set_elf_platform(cpu, "bmips4350");
|
2010-10-17 04:22:30 +07:00
|
|
|
}
|
2009-08-18 19:23:37 +07:00
|
|
|
break;
|
2010-10-17 04:22:30 +07:00
|
|
|
}
|
|
|
|
case PRID_IMP_BMIPS5000:
|
2014-10-21 11:28:01 +07:00
|
|
|
case PRID_IMP_BMIPS5200:
|
2010-10-17 04:22:30 +07:00
|
|
|
c->cputype = CPU_BMIPS5000;
|
|
|
|
__cpu_name[cpu] = "Broadcom BMIPS5000";
|
2011-04-17 01:29:28 +07:00
|
|
|
set_elf_platform(cpu, "bmips5000");
|
2010-10-17 04:22:30 +07:00
|
|
|
c->options |= MIPS_CPU_ULRI;
|
2009-08-18 19:23:37 +07:00
|
|
|
break;
|
2007-09-25 20:40:12 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-12 06:33:26 +07:00
|
|
|
static inline void cpu_probe_cavium(struct cpuinfo_mips *c, unsigned int cpu)
|
|
|
|
{
|
|
|
|
decode_configs(c);
|
2013-09-17 22:58:10 +07:00
|
|
|
switch (c->processor_id & PRID_IMP_MASK) {
|
2008-12-12 06:33:26 +07:00
|
|
|
case PRID_IMP_CAVIUM_CN38XX:
|
|
|
|
case PRID_IMP_CAVIUM_CN31XX:
|
|
|
|
case PRID_IMP_CAVIUM_CN30XX:
|
2010-02-11 06:12:48 +07:00
|
|
|
c->cputype = CPU_CAVIUM_OCTEON;
|
|
|
|
__cpu_name[cpu] = "Cavium Octeon";
|
|
|
|
goto platform;
|
2008-12-12 06:33:26 +07:00
|
|
|
case PRID_IMP_CAVIUM_CN58XX:
|
|
|
|
case PRID_IMP_CAVIUM_CN56XX:
|
|
|
|
case PRID_IMP_CAVIUM_CN50XX:
|
|
|
|
case PRID_IMP_CAVIUM_CN52XX:
|
2010-02-11 06:12:48 +07:00
|
|
|
c->cputype = CPU_CAVIUM_OCTEON_PLUS;
|
|
|
|
__cpu_name[cpu] = "Cavium Octeon+";
|
|
|
|
platform:
|
2011-04-19 01:37:55 +07:00
|
|
|
set_elf_platform(cpu, "octeon");
|
2008-12-12 06:33:26 +07:00
|
|
|
break;
|
2011-09-24 07:29:54 +07:00
|
|
|
case PRID_IMP_CAVIUM_CN61XX:
|
2010-10-08 06:03:45 +07:00
|
|
|
case PRID_IMP_CAVIUM_CN63XX:
|
2011-09-24 07:29:54 +07:00
|
|
|
case PRID_IMP_CAVIUM_CN66XX:
|
|
|
|
case PRID_IMP_CAVIUM_CN68XX:
|
2013-07-30 05:07:01 +07:00
|
|
|
case PRID_IMP_CAVIUM_CNF71XX:
|
2010-10-08 06:03:45 +07:00
|
|
|
c->cputype = CPU_CAVIUM_OCTEON2;
|
|
|
|
__cpu_name[cpu] = "Cavium Octeon II";
|
2011-04-19 01:37:55 +07:00
|
|
|
set_elf_platform(cpu, "octeon2");
|
2010-10-08 06:03:45 +07:00
|
|
|
break;
|
2013-07-30 05:07:01 +07:00
|
|
|
case PRID_IMP_CAVIUM_CN70XX:
|
|
|
|
case PRID_IMP_CAVIUM_CN78XX:
|
|
|
|
c->cputype = CPU_CAVIUM_OCTEON3;
|
|
|
|
__cpu_name[cpu] = "Cavium Octeon III";
|
|
|
|
set_elf_platform(cpu, "octeon3");
|
|
|
|
break;
|
2008-12-12 06:33:26 +07:00
|
|
|
default:
|
|
|
|
printk(KERN_INFO "Unknown Octeon chip!\n");
|
|
|
|
c->cputype = CPU_UNKNOWN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-17 18:07:51 +07:00
|
|
|
static inline void cpu_probe_ingenic(struct cpuinfo_mips *c, unsigned int cpu)
|
|
|
|
{
|
|
|
|
decode_configs(c);
|
|
|
|
/* JZRISC does not implement the CP0 counter. */
|
|
|
|
c->options &= ~MIPS_CPU_COUNTER;
|
MIPS: Implement random_get_entropy with CP0 Random
Update to commit 9c9b415c50bc298ac61412dff856eae2f54889ee [MIPS:
Reimplement get_cycles().]
On systems were for whatever reasons we can't use the cycle counter, fall
back to the c0_random register as an entropy source. It has however a
very small range that makes it suitable for random_get_entropy only and
not get_cycles.
This optimised version compiles to 8 instructions in the fast path even in
the worst case of all the conditions to check being variable (including a
MFC0 move delay slot that is only required for very old processors):
828: 8cf90000 lw t9,0(a3)
828: R_MIPS_LO16 jiffies
82c: 40057800 mfc0 a1,c0_prid
830: 3c0200ff lui v0,0xff
834: 00a21024 and v0,a1,v0
838: 1040007d beqz v0,a30 <add_interrupt_randomness+0x22c>
83c: 3c030000 lui v1,0x0
83c: R_MIPS_HI16 cpu_data
840: 40024800 mfc0 v0,c0_count
844: 00000000 nop
848: 00409021 move s2,v0
84c: 8ce20000 lw v0,0(a3)
84c: R_MIPS_LO16 jiffies
On most targets the sequence will be shorter and on some it will reduce to
a single `MFC0 <reg>,c0_count', as all MIPS architecture (i.e. non-legacy
MIPS) processors require the CP0 Count register to be present.
The only known exception that reports MIPS architecture compliance, but
contrary to that lacks CP0 Count is the Ingenic JZ4740 thingy. For broken
platforms like that this code requires cpu_has_counter to be hardcoded to
0 (i.e. no variable setting is permitted) so as not to penalise all the
other good platforms out there.
The asm barrier is required so that the compiler does not pull any
potentially costly (cold cache!) `cpu_data' variable access into the fast
path.
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
Signed-off-by: Maciej W. Rozycki <macro@linux-mips.org>
Cc: Theodore Ts'o <tytso@mit.edu>
Cc: John Crispin <blogic@openwrt.org>
Cc: Andrew McGregor <andrewmcgr@gmail.com>
Cc: Dave Taht <dave.taht@bufferbloat.net>
Cc: Felix Fietkau <nbd@nbd.name>
Cc: Simon Kelley <simon@thekelleys.org.uk>
Cc: Jim Gettys <jg@freedesktop.org>
Cc: David Daney <ddaney@caviumnetworks.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/6702/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2014-04-07 03:31:29 +07:00
|
|
|
BUG_ON(!__builtin_constant_p(cpu_has_counter) || cpu_has_counter);
|
2013-09-17 22:58:10 +07:00
|
|
|
switch (c->processor_id & PRID_IMP_MASK) {
|
2010-07-17 18:07:51 +07:00
|
|
|
case PRID_IMP_JZRISC:
|
|
|
|
c->cputype = CPU_JZRISC;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED_ACCELERATED;
|
2010-07-17 18:07:51 +07:00
|
|
|
__cpu_name[cpu] = "Ingenic JZRISC";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
panic("Unknown Ingenic Processor ID!");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-11 13:34:58 +07:00
|
|
|
static inline void cpu_probe_netlogic(struct cpuinfo_mips *c, int cpu)
|
|
|
|
{
|
|
|
|
decode_configs(c);
|
|
|
|
|
2013-09-17 22:58:10 +07:00
|
|
|
if ((c->processor_id & PRID_IMP_MASK) == PRID_IMP_NETLOGIC_AU13XX) {
|
2011-11-02 02:03:30 +07:00
|
|
|
c->cputype = CPU_ALCHEMY;
|
|
|
|
__cpu_name[cpu] = "Au1300";
|
|
|
|
/* following stuff is not for Alchemy */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-01-22 18:59:30 +07:00
|
|
|
c->options = (MIPS_CPU_TLB |
|
|
|
|
MIPS_CPU_4KEX |
|
2011-05-11 13:34:58 +07:00
|
|
|
MIPS_CPU_COUNTER |
|
2013-01-22 18:59:30 +07:00
|
|
|
MIPS_CPU_DIVEC |
|
|
|
|
MIPS_CPU_WATCH |
|
|
|
|
MIPS_CPU_EJTAG |
|
2011-05-11 13:34:58 +07:00
|
|
|
MIPS_CPU_LLSC);
|
|
|
|
|
2013-09-17 22:58:10 +07:00
|
|
|
switch (c->processor_id & PRID_IMP_MASK) {
|
2013-08-11 16:13:54 +07:00
|
|
|
case PRID_IMP_NETLOGIC_XLP2XX:
|
2013-12-21 18:22:20 +07:00
|
|
|
case PRID_IMP_NETLOGIC_XLP9XX:
|
2014-04-29 21:37:53 +07:00
|
|
|
case PRID_IMP_NETLOGIC_XLP5XX:
|
2013-08-11 16:13:54 +07:00
|
|
|
c->cputype = CPU_XLP;
|
|
|
|
__cpu_name[cpu] = "Broadcom XLPII";
|
|
|
|
break;
|
|
|
|
|
2011-11-16 07:21:29 +07:00
|
|
|
case PRID_IMP_NETLOGIC_XLP8XX:
|
|
|
|
case PRID_IMP_NETLOGIC_XLP3XX:
|
2011-11-16 07:21:20 +07:00
|
|
|
c->cputype = CPU_XLP;
|
|
|
|
__cpu_name[cpu] = "Netlogic XLP";
|
|
|
|
break;
|
|
|
|
|
2011-05-11 13:34:58 +07:00
|
|
|
case PRID_IMP_NETLOGIC_XLR732:
|
|
|
|
case PRID_IMP_NETLOGIC_XLR716:
|
|
|
|
case PRID_IMP_NETLOGIC_XLR532:
|
|
|
|
case PRID_IMP_NETLOGIC_XLR308:
|
|
|
|
case PRID_IMP_NETLOGIC_XLR532C:
|
|
|
|
case PRID_IMP_NETLOGIC_XLR516C:
|
|
|
|
case PRID_IMP_NETLOGIC_XLR508C:
|
|
|
|
case PRID_IMP_NETLOGIC_XLR308C:
|
|
|
|
c->cputype = CPU_XLR;
|
|
|
|
__cpu_name[cpu] = "Netlogic XLR";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PRID_IMP_NETLOGIC_XLS608:
|
|
|
|
case PRID_IMP_NETLOGIC_XLS408:
|
|
|
|
case PRID_IMP_NETLOGIC_XLS404:
|
|
|
|
case PRID_IMP_NETLOGIC_XLS208:
|
|
|
|
case PRID_IMP_NETLOGIC_XLS204:
|
|
|
|
case PRID_IMP_NETLOGIC_XLS108:
|
|
|
|
case PRID_IMP_NETLOGIC_XLS104:
|
|
|
|
case PRID_IMP_NETLOGIC_XLS616B:
|
|
|
|
case PRID_IMP_NETLOGIC_XLS608B:
|
|
|
|
case PRID_IMP_NETLOGIC_XLS416B:
|
|
|
|
case PRID_IMP_NETLOGIC_XLS412B:
|
|
|
|
case PRID_IMP_NETLOGIC_XLS408B:
|
|
|
|
case PRID_IMP_NETLOGIC_XLS404B:
|
|
|
|
c->cputype = CPU_XLR;
|
|
|
|
__cpu_name[cpu] = "Netlogic XLS";
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2011-11-16 07:21:20 +07:00
|
|
|
pr_info("Unknown Netlogic chip id [%02x]!\n",
|
2011-05-11 13:34:58 +07:00
|
|
|
c->processor_id);
|
|
|
|
c->cputype = CPU_XLR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-11-16 07:21:20 +07:00
|
|
|
if (c->cputype == CPU_XLP) {
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_M64R2);
|
2011-11-16 07:21:20 +07:00
|
|
|
c->options |= (MIPS_CPU_FPU | MIPS_CPU_ULRI | MIPS_CPU_MCHECK);
|
|
|
|
/* This will be updated again after all threads are woken up */
|
|
|
|
c->tlbsize = ((read_c0_config6() >> 16) & 0xffff) + 1;
|
|
|
|
} else {
|
2012-12-07 11:31:36 +07:00
|
|
|
set_isa(c, MIPS_CPU_ISA_M64R1);
|
2011-11-16 07:21:20 +07:00
|
|
|
c->tlbsize = ((read_c0_config1() >> 25) & 0x3f) + 1;
|
|
|
|
}
|
2013-06-11 21:41:35 +07:00
|
|
|
c->kscratch_mask = 0xf;
|
2011-05-11 13:34:58 +07:00
|
|
|
}
|
|
|
|
|
2010-10-15 01:32:33 +07:00
|
|
|
#ifdef CONFIG_64BIT
|
|
|
|
/* For use by uaccess.h */
|
|
|
|
u64 __ua_limit;
|
|
|
|
EXPORT_SYMBOL(__ua_limit);
|
|
|
|
#endif
|
|
|
|
|
2007-10-12 05:46:17 +07:00
|
|
|
const char *__cpu_name[NR_CPUS];
|
2010-01-29 07:52:12 +07:00
|
|
|
const char *__elf_platform;
|
2007-10-12 05:46:17 +07:00
|
|
|
|
MIPS: Delete __cpuinit/__CPUINIT usage from MIPS code
commit 3747069b25e419f6b51395f48127e9812abc3596 upstream.
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
and are flagged as __cpuinit -- so if we remove the __cpuinit from
the arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
related content into no-ops as early as possible, since that will get
rid of these warnings. In any case, they are temporary and harmless.
Here, we remove all the MIPS __cpuinit from C code and __CPUINIT
from asm files. MIPS is interesting in this respect, because there
are also uasm users hiding behind their own renamed versions of the
__cpuinit macros.
[1] https://lkml.org/lkml/2013/5/20/589
[ralf@linux-mips.org: Folded in Paul's followup fix.]
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/5494/
Patchwork: https://patchwork.linux-mips.org/patch/5495/
Patchwork: https://patchwork.linux-mips.org/patch/5509/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2013-06-18 20:38:59 +07:00
|
|
|
void cpu_probe(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct cpuinfo_mips *c = ¤t_cpu_data;
|
2007-10-12 05:46:17 +07:00
|
|
|
unsigned int cpu = smp_processor_id();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-01-22 18:59:30 +07:00
|
|
|
c->processor_id = PRID_IMP_UNKNOWN;
|
2005-04-17 05:20:36 +07:00
|
|
|
c->fpu_id = FPIR_IMP_NONE;
|
|
|
|
c->cputype = CPU_UNKNOWN;
|
2014-07-18 16:51:32 +07:00
|
|
|
c->writecombine = _CACHE_UNCACHED;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
c->processor_id = read_c0_prid();
|
2013-09-17 22:58:10 +07:00
|
|
|
switch (c->processor_id & PRID_COMP_MASK) {
|
2005-04-17 05:20:36 +07:00
|
|
|
case PRID_COMP_LEGACY:
|
2008-10-30 20:38:45 +07:00
|
|
|
cpu_probe_legacy(c, cpu);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case PRID_COMP_MIPS:
|
2008-10-30 20:38:45 +07:00
|
|
|
cpu_probe_mips(c, cpu);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case PRID_COMP_ALCHEMY:
|
2008-10-30 20:38:45 +07:00
|
|
|
cpu_probe_alchemy(c, cpu);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case PRID_COMP_SIBYTE:
|
2008-10-30 20:38:45 +07:00
|
|
|
cpu_probe_sibyte(c, cpu);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
2007-09-25 20:40:12 +07:00
|
|
|
case PRID_COMP_BROADCOM:
|
2008-10-30 20:38:45 +07:00
|
|
|
cpu_probe_broadcom(c, cpu);
|
2007-09-25 20:40:12 +07:00
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
case PRID_COMP_SANDCRAFT:
|
2008-10-30 20:38:45 +07:00
|
|
|
cpu_probe_sandcraft(c, cpu);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
2008-03-06 16:07:18 +07:00
|
|
|
case PRID_COMP_NXP:
|
2008-10-30 20:38:45 +07:00
|
|
|
cpu_probe_nxp(c, cpu);
|
2006-03-11 15:18:41 +07:00
|
|
|
break;
|
2008-12-12 06:33:26 +07:00
|
|
|
case PRID_COMP_CAVIUM:
|
|
|
|
cpu_probe_cavium(c, cpu);
|
|
|
|
break;
|
2010-07-17 18:07:51 +07:00
|
|
|
case PRID_COMP_INGENIC:
|
|
|
|
cpu_probe_ingenic(c, cpu);
|
|
|
|
break;
|
2011-05-11 13:34:58 +07:00
|
|
|
case PRID_COMP_NETLOGIC:
|
|
|
|
cpu_probe_netlogic(c, cpu);
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-10-08 21:11:51 +07:00
|
|
|
|
2008-10-30 20:38:45 +07:00
|
|
|
BUG_ON(!__cpu_name[cpu]);
|
|
|
|
BUG_ON(c->cputype == CPU_UNKNOWN);
|
|
|
|
|
2007-10-08 21:11:51 +07:00
|
|
|
/*
|
|
|
|
* Platform code can force the cpu type to optimize code
|
|
|
|
* generation. In that case be sure the cpu type is correctly
|
|
|
|
* manually setup otherwise it could trigger some nasty bugs.
|
|
|
|
*/
|
|
|
|
BUG_ON(current_cpu_type() != c->cputype);
|
|
|
|
|
2010-05-03 04:43:52 +07:00
|
|
|
if (mips_fpu_disabled)
|
|
|
|
c->options &= ~MIPS_CPU_FPU;
|
|
|
|
|
|
|
|
if (mips_dsp_disabled)
|
2012-08-03 22:26:04 +07:00
|
|
|
c->ases &= ~(MIPS_ASE_DSP | MIPS_ASE_DSP2P);
|
2010-05-03 04:43:52 +07:00
|
|
|
|
2014-07-14 18:46:13 +07:00
|
|
|
if (mips_htw_disabled) {
|
|
|
|
c->options &= ~MIPS_CPU_HTW;
|
|
|
|
write_c0_pwctl(read_c0_pwctl() &
|
|
|
|
~(1 << MIPS_PWCTL_PWEN_SHIFT));
|
|
|
|
}
|
|
|
|
|
2005-05-05 23:45:59 +07:00
|
|
|
if (c->options & MIPS_CPU_FPU) {
|
2005-04-17 05:20:36 +07:00
|
|
|
c->fpu_id = cpu_get_fpu_id();
|
2005-05-05 23:45:59 +07:00
|
|
|
|
2014-11-13 20:51:51 +07:00
|
|
|
if (c->isa_level & cpu_has_mips_r) {
|
2005-05-05 23:45:59 +07:00
|
|
|
if (c->fpu_id & MIPS_FPIR_3D)
|
|
|
|
c->ases |= MIPS_ASE_MIPS3D;
|
2014-09-11 14:30:18 +07:00
|
|
|
if (c->fpu_id & MIPS_FPIR_FREP)
|
|
|
|
c->options |= MIPS_CPU_FRE;
|
2005-05-05 23:45:59 +07:00
|
|
|
}
|
|
|
|
}
|
2007-10-12 05:46:17 +07:00
|
|
|
|
2014-11-13 20:51:51 +07:00
|
|
|
if (cpu_has_mips_r2_r6) {
|
2007-11-09 01:02:29 +07:00
|
|
|
c->srsets = ((read_c0_srsctl() >> 26) & 0x0f) + 1;
|
2012-07-14 03:44:51 +07:00
|
|
|
/* R2 has Performance Counter Interrupt indicator */
|
|
|
|
c->options |= MIPS_CPU_PCI;
|
|
|
|
}
|
2007-11-09 01:02:29 +07:00
|
|
|
else
|
|
|
|
c->srsets = 1;
|
2010-02-02 23:52:20 +07:00
|
|
|
|
2014-01-28 21:28:43 +07:00
|
|
|
if (cpu_has_msa) {
|
2014-01-27 22:23:10 +07:00
|
|
|
c->msa_id = cpu_get_msa_id();
|
2014-01-28 21:28:43 +07:00
|
|
|
WARN(c->msa_id & MSA_IR_WRPF,
|
|
|
|
"Vector register partitioning unimplemented!");
|
|
|
|
}
|
2014-01-27 22:23:10 +07:00
|
|
|
|
2010-02-02 23:52:20 +07:00
|
|
|
cpu_probe_vmbits(c);
|
2010-10-15 01:32:33 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_64BIT
|
|
|
|
if (cpu == 0)
|
|
|
|
__ua_limit = ~((1ull << cpu_vmbits) - 1);
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
MIPS: Delete __cpuinit/__CPUINIT usage from MIPS code
commit 3747069b25e419f6b51395f48127e9812abc3596 upstream.
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
and are flagged as __cpuinit -- so if we remove the __cpuinit from
the arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
related content into no-ops as early as possible, since that will get
rid of these warnings. In any case, they are temporary and harmless.
Here, we remove all the MIPS __cpuinit from C code and __CPUINIT
from asm files. MIPS is interesting in this respect, because there
are also uasm users hiding behind their own renamed versions of the
__cpuinit macros.
[1] https://lkml.org/lkml/2013/5/20/589
[ralf@linux-mips.org: Folded in Paul's followup fix.]
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/5494/
Patchwork: https://patchwork.linux-mips.org/patch/5495/
Patchwork: https://patchwork.linux-mips.org/patch/5509/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2013-06-18 20:38:59 +07:00
|
|
|
void cpu_report(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct cpuinfo_mips *c = ¤t_cpu_data;
|
|
|
|
|
2013-10-07 16:43:32 +07:00
|
|
|
pr_info("CPU%d revision is: %08x (%s)\n",
|
|
|
|
smp_processor_id(), c->processor_id, cpu_name_string());
|
2005-04-17 05:20:36 +07:00
|
|
|
if (c->options & MIPS_CPU_FPU)
|
2007-10-12 05:46:17 +07:00
|
|
|
printk(KERN_INFO "FPU revision is: %08x\n", c->fpu_id);
|
2014-01-27 22:23:10 +07:00
|
|
|
if (cpu_has_msa)
|
|
|
|
pr_info("MSA revision is: %08x\n", c->msa_id);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|