config/target.in
author "Benoît THÉBAUDEAU" <benoit.thebaudeau@advansee.com>
Tue May 31 16:27:39 2011 +0200 (2011-05-31)
changeset 2484 d1a8c2ae7946
parent 2413 ac27814977fd
child 2564 5d4e91c0343e
permissions -rw-r--r--
kconfig: remove useless 'default n'

kconfig bools are disabled by default, so specifying 'default n' is useless and
noisy. This patch removes all occurrences of 'default n'.

Signed-off-by: "Benoît THÉBAUDEAU" <benoit.thebaudeau@advansee.com>
     1 # Target definition: architecture, optimisations, etc...
     2 
     3 menu "Target options"
     4 
     5 config ARCH
     6     string
     7 
     8 # Pre-declare target optimisation variables
     9 config ARCH_SUPPORTS_BOTH_MMU
    10 config ARCH_SUPPORTS_BOTH_ENDIAN
    11 config ARCH_SUPPORTS_32
    12 config ARCH_SUPPORTS_64
    13 config ARCH_SUPPORT_ARCH
    14 config ARCH_SUPPORT_ABI
    15 config ARCH_SUPPORT_CPU
    16 config ARCH_SUPPORT_TUNE
    17 config ARCH_SUPPORT_FPU
    18 
    19 config ARCH_DEFAULT_HAS_MMU
    20 config ARCH_DEFAULT_BE
    21 config ARCH_DEFAULT_LE
    22 config ARCH_DEFAULT_32
    23 config ARCH_DEFAULT_64
    24 
    25 config ARCH_ARCH
    26 config ARCH_ABI
    27 config ARCH_CPU
    28 config ARCH_TUNE
    29 config ARCH_FPU
    30 config ARCH_BE
    31 config ARCH_LE
    32 config ARCH_32
    33 config ARCH_64
    34 config ARCH_BITNESS
    35 config ARCH_FLOAT_HW
    36 config ARCH_FLOAT_SW
    37 config TARGET_CFLAGS
    38 config TARGET_LDFLAGS
    39 
    40 source "config.gen/arch.in"
    41 
    42 #--------------------------------------
    43 comment "Generic target options"
    44 
    45 config ARCH_SUPPORTS_BOTH_MMU
    46     bool
    47 
    48 config ARCH_DEFAULT_HAS_MMU
    49     bool
    50 
    51 config ARCH_USE_MMU
    52     bool
    53     prompt "Use the MMU" if ARCH_SUPPORTS_BOTH_MMU
    54     default y if ARCH_DEFAULT_HAS_MMU
    55     help
    56       If your architecture has an MMU and you want to use it,
    57       say 'Y' here.
    58       
    59       OTOH, if you don't want to use the MMU, or your arch
    60       lacks an MMU, say 'N' here.
    61       
    62       Note that some architectures (eg. ARM) has variants that
    63       lacks an MMU (eg. ARM Cortex-M3), while other variants
    64       have one (eg. ARM Cortex-A8).
    65 
    66 #--------------------------------------
    67 config ARCH_SUPPORTS_BOTH_ENDIAN
    68     bool
    69 
    70 config ARCH_DEFAULT_BE
    71     bool
    72 
    73 config ARCH_DEFAULT_LE
    74     bool
    75 
    76 choice
    77     bool
    78     prompt "Endianness:"
    79     depends on ARCH_SUPPORTS_BOTH_ENDIAN
    80     default ARCH_BE if ARCH_DEFAULT_BE
    81     default ARCH_LE if ARCH_DEFAULT_LE
    82 
    83 config ARCH_BE
    84     bool
    85     prompt "Big endian"
    86 
    87 config ARCH_LE
    88     bool
    89     prompt "Little endian"
    90 
    91 endchoice
    92 
    93 #--------------------------------------
    94 config ARCH_SUPPORTS_32
    95     bool
    96 
    97 config ARCH_SUPPORTS_64
    98     bool
    99 
   100 config ARCH_DEFAULT_32
   101     bool
   102 
   103 config ARCH_DEFAULT_64
   104     bool
   105 
   106 config ARCH_BITNESS
   107     int
   108     default "32"    if ARCH_32
   109     default "64"    if ARCH_64
   110 
   111 choice
   112     bool
   113     prompt "Bitness:"
   114     default ARCH_32 if ARCH_DEFAULT_32
   115     default ARCH_64 if ARCH_DEFAULT_64
   116 
   117 config ARCH_32
   118     bool
   119     prompt "32-bit"
   120     depends on ARCH_SUPPORTS_32
   121 
   122 config ARCH_64
   123     bool
   124     prompt "64-bit"
   125     depends on ARCH_SUPPORTS_64
   126 
   127 endchoice
   128 
   129 #--------------------------------------
   130 comment "Target optimisations"
   131 
   132 config ARCH_SUPPORT_ARCH
   133     bool
   134 
   135 config ARCH_SUPPORT_ABI
   136     bool
   137 
   138 config ARCH_SUPPORT_CPU
   139     bool
   140 
   141 config ARCH_SUPPORT_TUNE
   142     bool
   143 
   144 config ARCH_SUPPORT_FPU
   145     bool
   146 
   147 config ARCH_ARCH
   148     string
   149     prompt "Architecture level"
   150     depends on ARCH_SUPPORT_ARCH
   151     default ""
   152     help
   153       GCC uses this name to determine what kind of instructions it can emit
   154       when generating assembly code. This option can be used in conjunction
   155       with or instead of the ARCH_CPU option (above), or a (command-line)
   156       -mcpu= option.
   157       
   158       This is the configuration flag --with-arch=XXXX, and the runtime flag
   159       -march=XXX.
   160       
   161       Pick a value from the gcc manual for your choosen gcc version and your
   162       target CPU.
   163       
   164       Leave blank if you don't know, or if your target architecture does not
   165       offer this option.
   166 
   167 config ARCH_ABI
   168     string
   169     prompt "Generate code for the specific ABI"
   170     depends on ARCH_SUPPORT_ABI
   171     default ""
   172     help
   173       Generate code for the given ABI.
   174 
   175       This is the configuration flag --with-abi=XXXX, and the runtime flag
   176       -mabi=XXX.
   177 
   178       Pick a value from the gcc manual for your choosen gcc version and your
   179       target CPU.
   180 
   181       Leave blank if you don't know, or if your target architecutre does not
   182       offer this option.
   183 
   184 config ARCH_CPU
   185     string
   186     prompt "Emit assembly for CPU"
   187     depends on ARCH_SUPPORT_CPU
   188     default ""
   189     help
   190       This specifies the name of the target processor. GCC uses this name
   191       to determine what kind of instructions it can emit when generating
   192       assembly code.
   193       
   194       This is the configuration flag --with-cpu=XXXX, and the runtime flag
   195       -mcpu=XXX.
   196 
   197       Pick a value from the gcc manual for your choosen gcc version and your
   198       target CPU.
   199       
   200       Leave blank if you don't know, or if your target architecture does not
   201       offer this option.
   202 
   203 config ARCH_TUNE
   204     string
   205     prompt "Tune for CPU"
   206     depends on ARCH_SUPPORT_TUNE
   207     default ""
   208     help
   209       This option is very similar to the ARCH_CPU option (above), except
   210       that instead of specifying the actual target processor type, and hence
   211       restricting which instructions can be used, it specifies that GCC should
   212       tune the performance of the code as if the target were of the type
   213       specified in this option, but still choosing the instructions that it
   214       will generate based on the cpu specified by the ARCH_CPU option
   215       (above), or a (command-line) -mcpu= option.
   216       
   217       This is the configuration flag --with-tune=XXXX, and the runtime flag
   218       -mtune=XXX.
   219       
   220       Pick a value from the gcc manual for your choosen gcc version and your
   221       target CPU.
   222       
   223       Leave blank if you don't know, or if your target architecture does not
   224       offer this option.
   225 
   226 config ARCH_FPU
   227     string
   228     prompt "Use specific FPU"
   229     depends on ARCH_SUPPORT_FPU
   230     default ""
   231     help
   232       On some targets (eg. ARM), you can specify the kind of FPU to emit
   233       code for.
   234 
   235       This is the configuration flag --with-fpu=XXX, and the runtime flag
   236       -mfpu=XXX.
   237       
   238       See below wether to actually emit FP opcodes, or to emulate them.
   239       
   240       Pick a value from the gcc manual for your choosen gcc version and your
   241       target CPU.
   242       
   243       Leave blank if you don't know, or if your target architecture does not
   244       offer this option.
   245 
   246 choice
   247     bool
   248     prompt "Floating point:"
   249 
   250 config ARCH_FLOAT_HW
   251     bool
   252     prompt "hardware (FPU)"
   253     help
   254       Emit hardware floating point opcodes.
   255       
   256       If you've got a processor with a FPU, then you want that.
   257       If your hardware has no FPU, you still can use HW floating point, but
   258       need to compile support for FPU emulation in your kernel. Needless to
   259       say that emulating the FPU is /slooowwwww/...
   260       
   261       One situation you'd want HW floating point without a FPU is if you get
   262       binary blobs from different vendors that are compiling this way and
   263       can't (don't wan't to) change.
   264 
   265 config ARCH_FLOAT_SW
   266     bool
   267     prompt "software"
   268     help
   269       Do not emit any hardware floating point opcode.
   270       
   271       If your processor has no FPU, then you most probably want this, as it
   272       is faster than emulating the FPU in the kernel.
   273 
   274 endchoice
   275 
   276 config TARGET_CFLAGS
   277     string
   278     prompt "Target CFLAGS"
   279     default ""
   280     help
   281       Used to add specific options when compiling libraries of the toolchain,
   282       that will run on the target (eg. libc.so).
   283       
   284       Note that the options above for ARCH, ABI, CPU, TUNE and FPU will be
   285       automaticaly used. You don't need to specify them here.
   286       
   287       Leave blank if you don't know better.
   288 
   289 config TARGET_LDFLAGS
   290     string
   291     prompt "Target LDFLAGS"
   292     default ""
   293     help
   294       Used to add specific options when linking libraries of the toolchain,
   295       that will run on your target.
   296       
   297       Leave blank if you don't know better.
   298 
   299 source "config.gen/arch.in.2"
   300 
   301 endmenu