nuttx/libc/Kconfig

#
# For a description of the syntax of this configuration file,
# see the file kconfig-language.txt in the NuttX tools repository.
#

comment "Standard C Library Options"

config STDIO_DISABLE_BUFFERING
	bool "Disable I/O Buffering"
	default n
	---help---
		Tiny systems may need to disable all support for I/O buffering in
		order to minimum footprint.

config STDIO_BUFFER_SIZE
	int "C STDIO buffer size"
	default 64
	depends on !STDIO_DISABLE_BUFFERING
	---help---
		Size of buffers using within the C buffered I/O interfaces (printf,
		putchar, fwrite, etc.).  This function sets the initial I/O buffer
		size.  Zero disables I/O buffering.  That size may be subsequently
		modified using setvbuf().

config STDIO_LINEBUFFER
	bool "STDIO line buffering"
	default y
	---help---
		Sets the default behavior to flush buffered I/O whenever a newline
		character is found in the output data stream.  This setting just
		sets the initial default behavior of all streams.  The behavior of
		an individual stream can be changed via setvbuf().

config NUNGET_CHARS
	int "Number unget() characters"
	default 2
	---help---
		Number of characters that can be buffered by ungetc() (Only if NFILE_STREAMS > 0)

config LIB_HOMEDIR
	string "Home directory"
	default "/"
	depends on !DISABLE_ENVIRON
	---help---
		The home directory to use with operations like such as 'cd ~'

source libc/dllfcn/Kconfig
source libc/modlib/Kconfig
source libc/math/Kconfig
source libc/machine/Kconfig

config NOPRINTF_FIELDWIDTH
	bool "Disable sprintf support fieldwidth"
	default n
	---help---
		sprintf-related logic is a little smaller if we do not support field
		widths.

config LIBC_FLOATINGPOINT
	bool "Enable floating point in printf"
	default n
	---help---
		By default, floating point
		support in printf, sscanf, etc. is disabled.

config LIBC_LONG_LONG
	bool "Enable long long support in printf"
	default y if !DEFAULT_SMALL
	default n if DEFAULT_SMALL
	---help---
		Enables support for long long formats in printf, sscanf, etc. is
		enabled.  This is enabled by default but if you are trying to
		reduce the FLASH footprint, then disabling this feature is one
		option.  The FLASH saves comes not from disabling the long long
		formats, but rather from omitting the large long long arithmetic
		libraries that will be drawn into the build if long long support
		is enabled.

config LIBC_SCANSET
	bool "Scanset support"
	default n
	---help---
		Add scanset support to sscanf().

config LIBC_IOCTL_VARIADIC
	bool "Enable variadic ioctl()"
	default n
	---help---
		By default, NuttX implements the "old style," three-parameter,
		ioctl() interface with this function prototype:

			int ioctl(int fd, int req, unsigned long arg);

		That function is implemented as part of the VFS.  If
		LIBC_IOCTL_VARIADIC is selected, then an additional compatibility
		layer will be provided in the C library.  The enabled, then function
		prototype will become:

			int ioctl(int fd, int req, ...);

		The ioctl() is not controlled by any standard so it is really
		arbitrary which format you used.  You may select the variadic
		function prototype with this option.  That will slightly increase
		code size and ioctl() processing time.  It will not support a
		variable number of arguments and it still always expects to see a
		third argument of type 'unsigned long'.  The only benefit of this
		alternative function signature is that it may provide greater
		compatibility if you are porting code from other platforms that use
		the variadic ioctl() function.

		WARNING:  Use of this option could cause subtle system errors is
		the third argument is omitted or if the sizeof the thread argument
		is anything other than sizeof (unsigned long).  Most small integers
		will be promoted to 'int'.  The following assertion appears in ioctl():

			DEBUGASSERT(sizeof(int)        == sizeof(unsigned long) &&
			            sizeof(FAR void *) == sizeof(unsigned long));

		Do not enable this option if the above is not true.  32-bit ARM
		should pass this test with all three types having sizeof(type) == 4
		bytes.  'float' should also be tested.  But 'long long' and 'double'
		are out of the question!  Don't event try to pass them.

		And what will happen if no third argument is passed?  In most cases,
		this should just result in a garbage value for arg.  But you may
		discover cases where something worse happens!

config LIBC_WCHAR
	bool "Enable wide-characters (Unicode) support"
	default n
	---help---
		By default, wide-characters support is disabled.

config LIBC_LOCALE
	bool "Enable I18N (LOCALE) support"
	default n
	---help---
		By default, i18n (locale) support is disabled.

config LIB_RAND_ORDER
	int "Order of the random number generate"
	default 1
	range 1 3
	---help---
		The order of the random number generator. 1=fast but very bad random
		numbers, 3=slow but very good random numbers.

choice
	prompt "Newline Options"
	default EOL_IS_EITHER_CRLF
	---help---
		This selection determines the line terminating character that is used.
		Some environments may return CR as end-of-line, others LF, and others
		both.  If not specified, the default is either CR or LF (but not both)
		as the line terminating charactor.

config EOL_IS_CR
	bool "EOL is CR"

config EOL_IS_LF
	bool "EOL is LF"

config EOL_IS_BOTH_CRLF
	bool "EOL is CR and LF"

config EOL_IS_EITHER_CRLF
	bool "EOL is CR or LF"

endchoice

config LIBC_EXECFUNCS
	bool "Enable exec[l|v] / posix_spawn() Support"
	default n
	depends on !BINFMT_DISABLE
	---help---
		Enable support for the exec[l|v] family of functions that can be
		used to start other programs, terminating the current program and
		the posix_spawn() familty of functions that can be used start other
		programs without terminating the current program.  The typical
		usage of the exec[l|v] functions is (1) first call vfork() to create
		a new thread, then (2) call exec[l|v] to replace the new thread with
		a program from the file system.

		NOTE 1: This two step process start is completely unnecessary in
		NuttX and is provided only for compatibily with Unix systems.  These
		functions are essentially just wrapper functions that (1) call the
		non-standard binfmt function 'exec', and then (2) exit(0).  Since
		the new thread will be terminated by the exec[l|v] call, it really
		served no purpose other than to suport Unix compatility.

		The posix_spawn() functions do not have this inefficiency.

		NOTE 2: Support for exec[l|v] and posix_spawn() is conditional
		because they require additional support for symbol tables that
		will not be available in the typical system.

if LIBC_EXECFUNCS

config EXECFUNCS_HAVE_SYMTAB
	bool "Have symbol table"
	default n if BUILD_KERNEL
	default y if !BUILD_KERNEL
	---help---
		If you have a system symbol table, then you must select this
		option in order to use it.  Symbol tables are required in most
		cases in order to like executable programs to the base code.

if EXECFUNCS_HAVE_SYMTAB
config EXECFUNCS_SYMTAB
	string "Symbol table used by exec[l|v]"
	default "g_symtab"
	---help---
		The exec[l|v] and posix_spawn() functions are wrapper functions that
		call the non-standard binfmt function 'exec').  The binfmt
		function 'exec' needs to have (1) a symbol table that provides the
		list of symbols exported by the base code, and (2) the number of
		symbols in that table.  This selection provides the name of that
		symbol table.

config EXECFUNCS_NSYMBOLS
	int "Number of Symbols in the Table"
	default 0
	---help---
		The exec[l|v] and posix_spawn() functions are wrapper functions that
		call the non-standard binfmt function 'exec').  The binfmt
		function 'exec' needs to have (1) a symbol table that provides the
		list of symbols exported by the base code, and (2) the number of
		symbols in that table.  This selection provides the number of
		symbols in the symbol table.

endif # EXECFUNCS_HAVE_SYMTAB
endif # LIBC_EXECFUNCS

config POSIX_SPAWN_PROXY_STACKSIZE
	int "Spawn Stack Size"
	default 1024
	---help---
		If posix_spawn[p]() and task_spawn() use I/O redirection options,
		they will require an intermediary/proxy task to muck with the file
		descriptors.  This configuration item specifies the stack size
		used for the proxy. Default: 1024 bytes.

config TASK_SPAWN_DEFAULT_STACKSIZE
	int "Default task_spawn Stack Size"
	default 2048
	depends on !ARCH_ADDRENV
	---help---
		The actual size to use for the child task's stack can be set with
		task_spawnattr_setstacksize().  This value specifies the default
		stack size to use if task_spawnattr_setstacksize() is not used.
		Default: 2048.

config LIBC_STRERROR
	bool "Enable strerror"
	default n
	---help---
		strerror() is useful because it decodes 'errno' values into a human readable
		strings.  But it can also require a lot of memory.  If this option is selected,
		strerror() will still exist in the build but it will not decode error values.
		This option should be used by other logic to decide if it should use strerror()
		or not.  For example, the NSH application will not use strerror() if this
		option is not selected; perror() will not use strerror() is this option is not
		selected (see also NSH_STRERROR).

config LIBC_STRERROR_SHORT
	bool "Use short error descriptions in strerror()"
	default n
	depends on LIBC_STRERROR
	---help---
		If this option is selected, then strerror() will use a shortened string when
		it decodes the error.  Specifically, strerror() is simply use the string that
		is the common name for the error.  For example, the 'errno' value of 2 will
		produce the string "No such file or directory" is LIBC_STRERROR_SHORT
		is not defined but the string "ENOENT" is LIBC_STRERROR_SHORT is defined.

config LIBC_PERROR_STDOUT
	bool "perror() to stdout"
	default n
	---help---
		POSIX requires that perror() provide its output on stderr.  This option may
		be defined, however, to provide perror() output that is serialized with
		other stdout messages.

config LIBC_TMPDIR
	string "Temporary file directory"
	default "/tmp"
	depends on FS_WRITABLE
		---help---
		If a write-able file system is selected, this string will be
		provided to specify the full path to a directory where temporary
		files can be created.  This would be a good application of RAM disk:
		To provide temporary storage for application data.

config LIBC_MAX_TMPFILE
	int "Maximum size of a temporary file path"
	default 32
	depends on FS_WRITABLE
		---help---
		If a write-able file system is selected, then temporary file may be
		supported at the path provided by LIBC_TMPDIR.  The tmpnam() interface
		keeps a static copy of this last filename produced; this value is the
		maximum size of that last filename.  This size is the size of the full
		file path.

config ARCH_LOWPUTC
	bool "Low-level console output"
	default "y"
	---help---
		architecture supports low-level, boot time console output

config LIBC_LOCALTIME
	bool "localtime API call support"
	default "n"
	depends on !DISABLE_ENVIRON
	---help---
		localtime API call support

		Logic currently depends on file system support with, at a minimum, these
		files in the zoneinfo directory:  GMT and posixrules.  An additional
		timezone file is required for any additional, local time zone(s) and the
		environment variable TZ must be set to the name of that timezone file
		when tzset() is called.

		See https://www.iana.org/time-zones .  See also nuttx/zoneinfo
		which provides a framework for incorporating the TZ database into a
		NuttX build.

if LIBC_LOCALTIME

config LIBC_TZ_MAX_TIMES
	int "Maximum number of times in timezone"
	default 370
	---help---
		Timezone files with more than this number of times will not be usedi
		(tmecnt).

		Warning: Some files in IANA TZ database include many times.  The current
		posixrules file, for example, has timecnt = 236.  The value of
		TX_MAX_ITMES in the tzfile.h header file on my Linux system is 370, the
		default used here.  You may want to reduce this value for a smaller
		footprint.

config LIBC_TZ_MAX_TYPES
	int "Maximum number of TZ types"
	default 20
	---help---
		Maximum number of local time types.  You may want to reduce this value
		for a smaller footprint.

config LIBC_TZDIR
	string "zoneinfo directory path"
	default "/etc/zoneinfo"
	---help---
		This is the full path to the location where the TZ database is expected
		to be found.

config LIB_ZONEINFO
	bool "TZ database"
	default n
	---help---
		Download and build the TZ/Olson database.

if LIB_ZONEINFO

config LIB_ZONEINFO_ROMFS
	bool "Build ROMFS filesystem"
	default n
	depends on FS_ROMFS
	---help---
		Build a mountable ROMFS filesystem containing the TZ/Olson database

endif # LIB_ZONEINFO
endif # LIBC_LOCALTIME

config TIME_EXTENDED
	bool "Add day of week, year support"
	default "n"
	depends on !LIBC_LOCALTIME
	---help---
		Selecting TIME_EXTENDED adds tm_wday, tm_yday and tm_isdst
		to the tm struct. This allows integration with 3rd party libraries
		that expect the tm struct to contain these members.

		Note: tm_isdst is always 0

config LIB_SENDFILE_BUFSIZE
	int "sendfile() buffer size"
	default 512
	---help---
		Size of the I/O buffer to allocate in sendfile().  Default: 512b

config ARCH_ROMGETC
	bool "Support for ROM string access"
	default n
	---help---
		In Harvard architectures, data accesses and instruction accesses
		occur on different buses, perhaps concurrently.  All data accesses
		are performed on the data bus unless special machine instructions
		are used to read data from the instruction address space.  Also, in
		the typical MCU, the available SRAM data memory is much smaller that
		the non-volatile FLASH instruction memory.  So if the application
		requires many constant strings, the only practical solution may be
		to store those constant strings in FLASH memory where they can only
		be accessed using architecture-specific machine instructions.

		If ARCH_ROMGETC is defined, then the architecture logic must export
		the function up_romgetc().  up_romgetc() will simply read one byte
		of data from the instruction space.

		If ARCH_ROMGETC is selected, certain C stdio functions are effected: (1)
		All format strings in printf, fprintf, sprintf, etc. are assumed to lie
		in FLASH (string arguments for %s are still assumed to reside in SRAM).
		And (2), the string argument to puts and fputs is assumed to reside
		in FLASH.  Clearly, these assumptions may have to modified for the
		particular needs of your environment.  There is no "one-size-fits-all"
		solution for this problem.

config MEMCPY_VIK
	bool "Vik memcpy()"
	default n
	depends on !LIBC_ARCH_MEMCPY
	---help---
		Select this option to use the optimized memcpy() function by Daniel Vik.
		Select this option for improved performance at the expense of increased
		size. See licensing information in the top-level COPYING file.

if MEMCPY_VIK

config MEMCPY_PRE_INC_PTRS
	bool "Pre-increment pointers"
	default n
	---help---
		Use pre-increment of pointers. Default is post increment of pointers.

config MEMCPY_INDEXED_COPY
	bool "Array indexing"
	default y
	---help---
		Copying data using array indexing. Using this option, disables the
		MEMCPY_PRE_INC_PTRS option.

config MEMCPY_64BIT
	bool "64-bit memcpy()"
	default n
	---help---
		Compiles memcpy() for architectures that suppport 64-bit operations
		efficiently.

endif # MEMCPY_VIK

config MEMSET_OPTSPEED
	bool "Optimize memset() for speed"
	default n
	depends on !LIBC_ARCH_MEMSET
	---help---
		Select this option to use a version of memcpy() optimized for speed.
		Default: memcpy() is optimized for size.

config MEMSET_64BIT
	bool "64-bit memset()"
	default n
	depends on MEMSET_OPTSPEED
	---help---
		Compiles memset() for architectures that suppport 64-bit operations
		efficiently.

config ARCH_HAVE_TLS
	bool
	default n
	---help---
		Selected by the configuration system if the current architecture
		supports TLS.

menuconfig TLS
	bool "Thread Local Storage (TLS)"
	default n
	depends on ARCH_HAVE_TLS
	---help---
		Build in support for stack based thread local storage (TLS).

if TLS

config TLS_LOG2_MAXSTACK
	int "Maximum stack size (log2)"
	default 13
	range 11 24
	---help---
		Stack based TLS works by fetch thread information from the beginning
		of the stack memory allocation.  In order to do this, the memory
		must be aligned in such a way that the executing logic can simply
		masking the current stack pointer to get the beginning of the stack
		allocation.

		This setting specifies the alignment of the stack as a power of 2:
		11=2KB, 12=4KB, 13=8KB, etc.  The exact alignment is not so critical
		except that (1) a very large value can cause you to run out of
		alignable memory (and fail memory allocations), and (2) smaller
		values will limit the maximum size of the stack (hence the naming
		of this configuration value).

config TLS_NELEM
	int "Number of TLS elements"
	default 1
	---help---
		The number of unique TLS elements.  These can be accessed with
		the user library functions tls_get_element() and tls_set_element().

endif # TLS

config LIBC_IPv4_ADDRCONV
	bool "IPv4 address conversions"
	default n
	depends on !NET_IPv4

config LIBC_IPv6_ADDRCONV
	bool "IPv6 address conversions"
	default n
	depends on !NET_IPv6

config LIBC_NETDB
	bool
	default n

menuconfig NETDB_HOSTFILE
	bool "Network host file support"
	default n
	depends on FS_READABLE
	select LIBC_NETDB
	---help---
		Enable network host table look ups via gethostbyname() and
		gethostbyaddr().

if NETDB_HOSTFILE

config NETDB_HOSTCONF_PATH
	string "Path to host configuration file"
	default "/etc/hosts"

config NETDB_MAX_ALTNAMES
	int "Max number of alternate host names"
	default 4

config NETDB_BUFSIZE
	int "gethostname() buffer size"
	default 128

endif # NETDB_HOSTFILE

menuconfig NETDB_DNSCLIENT
	bool "DNS Name resolution"
	default n
	depends on NET && NET_UDP
	select LIBC_NETDB
	---help---
		Enable support for the name resolution; Enable network host
		resolution via gethostbyname().

if NETDB_DNSCLIENT

config NETDB_DNSCLIENT_ENTRIES
	int "Number of DNS resolver entries"
	default 0 if DEFAULT_SMALL
	default 8 if !DEFAULT_SMALL
	range 0 255
	---help---
		Number of cached DNS resolver entries.  Default: 8.  Zero disables
		all cached name resolutions.

		Disabling the DNS cache means that each access call to
		gethostbyname() will result in a new DNS network query.  If
		CONFIG_NETDB_DNSCLIENT_ENTRIES is non-zero, then entries will be
		cached and if the name mapping can be found in that cache, the
		network query can be avoid.  Of course, this is only useful if you
		query the same name often and if the IP address of the name is
		stable.  If the IP address can change, then cachin DNS address
		might have undesirable side-effects (see help for
		CONFIG_NETDB_DNSCLIENT_LIFESEC).

config NETDB_DNSCLIENT_NAMESIZE
	int "Max size of a cached hostname"
	default 32
	---help---
		The size of a hostname string in the DNS resolver cache is fixed.
		This setting provides the maximum size of a hostname.  Names longer
		than this will be aliased!  Default: 32

config NETDB_DNSCLIENT_LIFESEC
	int "Life of a DNS cache entry (seconds)"
	default 3600
	---help---
		Cached entries in the name resolution cache older than this will not
		be used.  Default: 1 hour.  Zero means that entries will not expire.

		Small values of CONFIG_NETDB_DNSCLIENT_LIFESEC may result in more
		network DNS queries; larger values can make a host unreachable for
		the entire duration of the timeout value.  This might happen, for
		example, if the remote host was assigned a different IP address by
		a DHCP server.

config NETDB_DNSCLIENT_MAXRESPONSE
	int "Max response size"
	default 96
	---help---
		This setting determines the maximum size of response message that
		can be received by the DNS resolver.  The default is 96 but may
		need to be larger on enterprise networks (perhaps 176).


config NETDB_RESOLVCONF
	bool "DNS resolver file support"
	default n
	depends on FS_READABLE
	---help---
		Enable DNS server look ups in resolver file like /etc/resolv.conf.

if NETDB_RESOLVCONF

config NETDB_RESOLVCONF_PATH
	string "Path to host configuration file"
	default "/etc/resolv.conf"

config NETDB_RESOLVCONF_NONSTDPORT
	bool "Non-standard port support"
	default n
	---help---
		By default, the resolv.conf file will hold only records like:

			nameserver xx.xx.xx.xx
			nameserver xxxx:::::::xxxx

		The default port of 53 is always assumed.

		If this option is selected, then OpenBSD style resolv.conf files
		will be supported.  This adds logic for a bracket port notation
		like:

			nameserver [xx.xx.xx.xx]:ppppp
			nameserver [xxxx:::::::xxxx]:ppppp

endif # NETDB_RESOLVCONF

choice
	prompt "DNS server address type"
	default NETDB_DNSSERVER_IPv4 if NET_IPv4
	default NETDB_DNSSERVER_IPv6 if !NET_IPv4 && NET_IPv6
	default NETDB_DNSSERVER_NOADDR if !NET_IPv4 && !NET_IPv6
	depends on !NETDB_RESOLVCONF

config NETDB_DNSSERVER_NOADDR
	bool "No default DNS server address"
	---help---
		There is not default DNS nameserver address.  Application must call
		dns_add_server() at runtime to add the DNS server address.

config NETDB_DNSSERVER_IPv4
	bool "IPv4 DNS server address"
	depends on NET_IPv4
	---help---
		An IPv4 default DNS nameserver address will be provided.  Application
		may overwrite this start default server address by calling
		dns_add_server() at runtime.

config NETDB_DNSSERVER_IPv6
	bool "IPv6 DNS server address"
	depends on NET_IPv6
	---help---
		An IPv6 default DNS nameserver address will be provided.  Application
		may overwrite this start default server address by calling
		dns_add_server() at runtime.

endchoice # DNS server address type

config NETDB_DNSSERVER_IPv4ADDR
	hex "Target IPv4 address"
	default 0x0a000001
	depends on NETDB_DNSSERVER_IPv4
	---help---
		Default DNS server IPv4 address in host byte order.  Default value
		10.0.0.0.1.  This may be changed via dns_add_nameserver().

if NETDB_DNSSERVER_IPv6

config NETDB_DNSSERVER_IPv6ADDR_1
	hex "[0]"
	default 0xfc00
	range 0x0 0xffff
	---help---
		This is the default IP address of the DNS server.  This is a 16-bit
		integer value in host order.  Each of the eight values forming the
		full IPv6 address must be specified individually.  This is the first
		of the 8-values.  The default for all eight values is fc00::1.

config NETDB_DNSSERVER_IPv6ADDR_2
	hex "[1]"
	default 0x0000
	range 0x0 0xffff
	---help---
		This is the default IP address of the DNS server.  This is a 16-bit
		integer value in host order.  Each of the eight values forming the
		full IPv6 address must be specified individually.  This is the second
		of the 8-values.  The default for all eight values is fc00::1.

config NETDB_DNSSERVER_IPv6ADDR_3
	hex "[2]"
	default 0x0000
	range 0x0 0xffff
	---help---
		This is the default IP address of the DNS server.  This is a 16-bit
		integer value in host order.  Each of the eight values forming the
		full IPv6 address must be specified individually.  This is the third
		of the 8-values.  The default for all eight values is fc00::1.

config NETDB_DNSSERVER_IPv6ADDR_4
	hex "[3]"
	default 0x0000
	range 0x0 0xffff
	---help---
		This is the default IP address of the DNS server.  This is a 16-bit
		integer value in host order.  Each of the eight values forming the
		full IPv6 address must be specified individually.  This is the fourth
		of the 8-values.  The default for all eight values is fc00::1.

config NETDB_DNSSERVER_IPv6ADDR_5
	hex "[4]"
	default 0x0000
	range 0x0 0xffff
	---help---
		This is the default IP address of the DNS server.  This is a 16-bit
		integer value in host order.  Each of the eight values forming the
		full IPv6 address must be specified individually.  This is the fifth
		of the 8-values.  The default for all eight values is fc00::1.

config NETDB_DNSSERVER_IPv6ADDR_6
	hex "[5]"
	default 0x0000
	range 0x0 0xffff
	---help---
		This is the default IP address of the DNS server.  This is a 16-bit
		integer value in host order.  Each of the eight values forming the
		full IPv6 address must be specified individually.  This is the sixth
		of the 8-values.  The default for all eight values is fc00::1.

config NETDB_DNSSERVER_IPv6ADDR_7
	hex "[6]"
	default 0x0000
	range 0x0 0xffff
	---help---
		This is the default IP address of the DNS server.  This is a 16-bit
		integer value in host order.  Each of the eight values forming the
		full IPv6 address must be specified individually.  This is the seventh
		of the 8-values.  The default for all eight values is fc00::1.

config NETDB_DNSSERVER_IPv6ADDR_8
	hex "[7]"
	default 0x0001
	range 0x0 0xffff
	---help---
		This is the default IP address of the DNS server.  This is a 16-bit
		integer value in host order.  Each of the eight values forming the
		full IPv6 address must be specified individually.  This is the last
		of the 8-values.  The default for all eight values is fc00::1.

endif # NETDB_DNSSERVER_IPv6
endif # NETDB_DNSCLIENT

comment "Non-standard Library Support"

config LIB_CRC64_FAST
	bool "Fast CRC64"
	default n
	---help---
		Enable the CRC64 lookup table to compute the CRC64 faster.

if BUILD_PROTECTED || BUILD_KERNEL

config LIB_USRWORK
	bool "User mode worker thread"
	default n
	depends on !DISABLE_SIGNALS
	---help---
		User space work queues can also be made available for deferred
		processing in the NuttX kernel build.

if LIB_USRWORK

config LIB_USRWORKPRIORITY
	int "User mode priority worker thread priority"
	default 100
	---help---
		The execution priority of the user-mode priority worker thread.  Default: 100

config LIB_USRWORKPERIOD
	int "User mode worker thread period"
	default 100000
	---help---
		How often the lower priority worker thread checks for work in units
		of microseconds. Default: 100*1000 (100 MS).

config LIB_USRWORKSTACKSIZE
	int "User mode worker thread stack size"
	default 2048
	---help---
		The stack size allocated for the lower priority worker thread.  Default: 2K.

endif # LIB_USRWORK
endif # BUILD_PROTECTED || BUILD_KERNEL

config LIB_KBDCODEC
	bool "Keyboard CODEC"
	default n
	---help---
		In NuttX, a keyboard/keypad driver is simply a character driver that
		may have an (optional) encoding/decoding layer on the data returned
		by the character driver. A keyboard may return simple text data
		(alphabetic, numeric, and punctuaction) or control characters
		(enter, control-C, etc.).  However, in addition, most keyboards
		support actions that cannot be represented as text data. Such
		actions include things like cursor controls (home, up arrow,
		page down, etc.), editing functions (insert, delete, etc.), volume
		controls, (mute, volume up, etc.) and other special functions.
		Some special encoding may be required to multiplex these two classes
		of data.

		This option enables the functions that implement the encoding and
		decoding of keyboard data.  These are the interfaces prototyped in
		include/nuttx/input/kbd_codec.h.  While not correctly a part of
		the C library, it is included here because the decoding side of this
		interface must be accessible by end user programs.

config LIB_SLCDCODEC
	bool "Segment LCD CODEC"
	default n
	---help---
		In NuttX, a character-oriented, segment LCD (SLCD) driver is simply
		a character device that may have an (optional) encoding/decoding
		layer on the data provided to the SLCD driver.  The application may
		provide simple text data (alphabetic, numeric, and punctuaction) or
		control characters (enter, control-C, etc.).  However, in addition,
		most SLCDs support actions that cannot be represented as text data.
		Such actions include things like cursor controls (home, up arrow,
		page down, etc.) and other special functions (e.g., blinking).  Some
		special encoding may be required to multiplex these two classes of
		data.

		This option enables the functions that implement the encoding and
		decoding of SLCD data.  These are the interfaces prototyped in
		include/nuttx/lcd/slcd_codec.h.  While not correctly a part of the C
		library, it is included here because the encoding side of this
		interface must be accessible by end user programs.

config LIB_HEX2BIN
	bool "Intel HEX to binary conversion library"
	default n
	---help---
		Build in support for conversions from Intel Hex format to binary.
		This selection enables the interfaces of include/hex2bin.h.