Originally from the Linux Kernel.
# Licensed under the terms of the GNU GPL License version 2

Descriptions of section entries:

	P: Person (obsolete)
	M: Mail patches to: FullName <address@domain>
	R: Designated reviewer: FullName <address@domain>
	   These reviewers should be CCed on patches.
	L: Mailing list that is relevant to this area
	W: Web-page with status/info
	Q: Patchwork web based patch tracking system site
	T: SCM tree type and location.
	   Type is one of: git, hg, quilt, stgit, topgit
	S: Status, one of the following:
	   Supported:	Someone is actually paid to look after this.
	   Maintained:	Someone actually looks after it.
	   Odd Fixes:	It has a maintainer but they don't have time to do
			much other than throw the odd patch in. See below..
	   Orphan:	No current maintainer [but maybe you could take the
			role as you write your new code].
	   Obsolete:	Old code. Something tagged obsolete generally means
			it has been replaced by a better system and you
			should be using that.
	F: Files and directories with wildcard patterns.
	   A trailing slash includes all files and subdirectory files.
	   F:	drivers/net/	all files in and below drivers/net
	   F:	drivers/net/*	all files in drivers/net, but not below
	   F:	*/net/*		all files in "any top level directory"/net
	   One pattern per line.  Multiple F: lines acceptable.
	N: Files and directories with regex patterns.
	   N:	[^a-z]tegra	all files whose path contains the word tegra
	   One pattern per line.  Multiple N: lines acceptable.
	   scripts/get_maintainer.pl has different behavior for files that
	   match F: pattern and matches of N: patterns.  By default,
	   get_maintainer will not look at git log history when an F: pattern
	   match occurs.  When an N: match occurs, git log history is used
	   to also notify the people that have git commit signatures.
	X: Files and directories that are NOT maintained, same rules as F:
	   Files exclusions are tested before file matches.
	   Can be useful for excluding a specific subdirectory, for instance:
	   F:	net/
	   X:	net/ipv6/
	   matches all files in and below net excluding net/ipv6/
	K: Keyword perl extended regex pattern to match content in a
	   patch or file.  For instance:
	   K: of_get_profile
	      matches patches or files that contain "of_get_profile"
	   K: \b(printk|pr_(info|err))\b
	      matches patches or files that contain one or more of the words
	      printk, pr_info or pr_err
	   One regex pattern per line.  Multiple K: lines acceptable.

Note: For the hard of thinking, this list is meant to remain in alphabetical
order. If you could add yourselves to it in alphabetical order that would be
so much easier [Ed]

Maintainers List (try to look for most precise areas first)

		-----------------------------------

ARC ARCHITECTURE
M:	Ruud Derwig <Ruud.Derwig@synopsys.com>
M:	Chuck Jordan <Chuck.Jordan@synopsys.com
M:	Benjamin Walsh <benjamin.walsh@windriver.com>
S:	Supported
F:	arch/arc/
F:	include/arch/arc/

ARM ARCHITECTURE
M:	Maureen Helm <maureen.helm@nxp.com>
S:	Supported
F:	arch/arm/
F:	include/arch/arm/

BLUETOOTH
M:	Johan Hedberg <johan.hedberg@intel.com>
M:	Luiz Augusto von Dentz <luiz.dentz@gmail.com>
M:	Szymon Janc <szymon.janc@gmail.com>
S:	Supported
W:	https://www.zephyrproject.org/doc/subsystems/bluetooth/bluetooth.html
F:	net/bluetooth/
F:	include/bluetooth/
F:	drivers/bluetooth/
F:	samples/bluetooth/
F:	tests/bluetooth/

DOCUMENTATION
M:	Kinder, David <david.b.kinder@intel.com>
M:	Perez-Gonzalez, Inaky <inaky.perez-gonzalez@intel.com>
S:	Supported
F:	doc/

FILE SYSTEM
M:	Ramesh Thomas <ramesh.thomas@intel.com>
M:	Kuo-Lang Tseng <kuo-lang.tseng@intel.com>
S:	Supported
F:	ext/fs/
F:	fs/
F:	include/fs/
F:	include/fs.h
F:	samples/fs/

FLASH DRIVER
M:	Baohong Liu <baohong.liu@intel.com>
M:	Kuo-Lang Tseng <kuo-lang.tseng@intel.com>
S:	Supported
F:	drivers/flash/

INTERRUPTS
M:	Andrew Boie <andrew.p.boie@intel.com>
S:	Supported
F:	drivers/interrupt_controller/
F:	arch/arc/core/
F:	arch/arm/core/
F:	arch/nios2/core/
F:	arch/x86/core/
F:	include/irq.h
F:	include/arch/x86/arch.h
F:	include/arch/arm/cortex_m/irq.h
F:	include/arch/nios2/arch.h
F:	include/arch/arc/arch.h
F:	include/arch/arc/v2/irq.h
F:	include/drivers/loapic.h
F:	include/drivers/ioapic.h
F:	include/drivers/mvic.h

KERNEL CORE
M:	Benjamin Walsh <benjamin.walsh@windriver.com>
M:	Allan Stephens <allan.stephens@windriver.com>
S:	Supported
F:	kernel/
F:	include/nanokernel.h
F:	include/microkernel.h
F:	include/microkernel/
F:	include/misc/
F:	include/toolchain/
F:	include/atomic.h
F:	include/cache.h
F:	include/init.h
F:	include/irq.h
F:	include/irq_offload.h
F:	include/kernel_version.h
F:	include/linker-defs.h
F:	include/linker-tool-gcc.h
F:	include/linker-tool.h
F:	include/section_tags.h
F:	include/sections.h
F:	include/shared_irq.h
F:	include/sw_isr_table.h
F:	include/sys_clock.h
F:	include/sys_io.h
F:	include/toolchain.h
F:	include/zephyr.h

KNOWN ISSUES
M:	Anas Nashif <anas.nashif@intel.com>
M:	Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
M:	Javier B Perez <javier.b.perez.hernandez@intel.com>
F:	.known-issues/

MAINTAINERS
M:	Javier B Perez <javier.b.perez.hernandez@intel.com>
M:	Anas Nashif <anas.nashif@intel.com>
M:	Perez-Gonzalez, Inaky <inaky.perez-gonzalez@intel.com>
S:	Supported
F:	MAINTAINERS

MBEDTLS
M:	Sergio Rodriguez <sergio.sf.rodriguez@intel.com>
M:	Jithu Joseph <jithu.joseph@intel.com>
M:	Kuo-Lang Tseng <kuo-lang.tseng@intel.com>
S:	Supported
F:	ext/lib/crypto/mbedtls/
F:	samples/net/mbedtls_sslclient/
F:	tests/crypto/test_mbedtls/

NETWORKING
M:	Jukka Rissanen <jukka.rissanen@linux.intel.com>
S:	Supported
W:	https://www.zephyrproject.org/doc/subsystems/networking/networking.html
F:	net/ip/
F:	include/net/
F:	samples/net/
F:	tests/net/

NETWORK APPLICATIONS
M:	Flavio Santes <flavio.santes@intel.com>
S:	Supported
F:	samples/net/dns_client/
F:	samples/net/nats_clients/
F:	samples/net/paho_mqtt_clients/

NETWORK BUFFERS
M:	Johan Hedberg <johan.hedberg@intel.com>
M:	Jukka Rissanen <jukka.rissanen@linux.intel.com>
S:	Supported
W:	https://www.zephyrproject.org/doc/subsystems/networking/buffers.html
F:	net/buf.c
F:	include/net/buf.h
F:	tests/net/buf/

NIOS II
M:	Andrew Boie <andrew.p.boie@intel.com>
S:	Supported
F:	arch/nios2/
F:	include/arch/nios2/
F:	drivers/serial/uart_altera_jtag.c
F:	drivers/timer/altera_avalon_timer.c
F:	tests/kernel/test_intmath/

NORDIC MDK
M:	Carles Cufi <carles.cufi@nordicsemi.no>
S:	Supported
F:	ext/hal/nordic/mdk/

POWER MANAGEMENT
M:	Ramesh Thomas <ramesh.thomas@intel.com>
M:	Kuo-Lang Tseng <kuo-lang.tseng@intel.com>
S:	Supported
F:	arch/x86/core/crt0.S
F:	include/device.h
F:	include/init.h
F:	include/power.h
F:	kernel/microkernel/k_idle.c
F:	kernel/nanokernel/device.c
F:	samples/power/

QMSI
M:	Anas Nashif <anas.nashif@intel.com>
S:	Supported
F:	ext/hal/qmsi/

QMSI DRIVERS
M:	Sergio Rodriguez <sergio.sf.rodriguez@intel.com>
M:	Baohong Liu <baohong.liu@intel.com>
M:	Kuo-Lang Tseng <kuo-lang.tseng@intel.com>
S:	Supported
F:	drivers/*/*qmsi*
F:	drivers/*/*/*qmsi*

SANITYCHECK
M:	Andrew Boie <andrew.p.boie@intel.com>
S:	Supported
F:	scripts/sanitycheck
F:	scripts/expr_parser.py
F:	scripts/sanity_chk/

SENSOR DRIVERS
M:	Bogdan Davidoaia <bogdan.m.davidoaia@intel.com>
M:	Laurentiu Palcu <laurentiu.palcu@intel.com>
M:	Murtaza Alexandru <alexandru.murtaza@intel.com>
M:	Vlad Dogaru <vlad.dogaru@intel.com>
S:	Supported
W:	https://www.zephyrproject.org/doc/subsystems/sensor.html
F:	include/sensor.h
F:	drivers/sensor/
F:	samples/sensor/

TINYCRYPT
M:	Constanza Heath <constanza.m.heath@intel.com>
M:	Flavio Santes <flavio.santes@intel.com>
S:	Supported
F:	ext/lib/crypto/tinycrypt/
F:	tests/crypto/

X86 ARCH
M:	Benjamin Walsh <benjamin.walsh@windriver.com>
M:	Allan Stephens <allan.stephens@windriver.com>
S:	Supported
F:	arch/x86/
F:	include/arch/x86/

THE REST
M:	Anas Nashif <anas.nashif@intel.com>
L:	devel@lists.zephyrproject.com
T:	git https://gerrit.zephyrproject.org/r/a/zephyr
S:	Buried alive in reporters
F:	*
F:	*/
