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 <cjordan@synopsys.com>
M:	Benjamin Walsh <benjamin.walsh@windriver.com>
S:	Supported
F:	arch/arc/
F:	include/arch/arc/
F:	boards/arc/

ARM ARCHITECTURE
M:	Maureen Helm <maureen.helm@nxp.com>
M:	Kumar Gala <kumar.gala@linaro.org>
S:	Supported
F:	arch/arm/
F:	include/arch/arm/
F:	boards/arm/

ARM CORTEX MICROCONTROLLER SOFTWARE INTERFACE STANDARD (CMSIS)
M:	Maureen Helm <maureen.helm@nxp.com>
M:	Kumar Gala <kumar.gala@linaro.org>
S:	Supported
F:	ext/hal/cmsis/

BOARDS/ARC - ARDUINO 101 SSS
M:      Anas Nashif <anas.nashif@intel.com>
S:	Supported
F:	boards/arc/arduino_101_sss/

BOARDS/ARC - EM Starterkit
M:	Chuck Jordan <cjordan@synopsys.com>
S:	Supported
F:	boards/arc/em_starterkit/

BOARDS/ARC - QUARK SE C1000 SS Devboard
M:      Anas Nashif <anas.nashif@intel.com>
S:	Supported
F:	boards/arc/quark_se_c1000_ss_devboard/

BOARDS/ARM - 96Boards CARBON
M:	Amit Kucheria <amit.kucheria@linaro.org>
M:	Ricardo Salveti <ricardo.salveti@linaro.org>
S:	Supported
F:	boards/arm/96b_carbon/

BOARDS/ARM - 96Boards NITROGEN
M:	Amit Kucheria <amit.kucheria@linaro.org>
S:	Supported
F:	boards/arm/96b_nitrogen/

BOARDS/ARM - ARDUINO 101 BLE
M:	Johan Hedberg <johan.hedberg@intel.com>
S:	Supported
F:	boards/arm/arduino_101_ble/

BOARDS/ARM - CC3200 LAUNCHXL
M:      Gil Pitney <gil.pitney@linaro.org>
S:      Supported
F:      boards/arm/cc3200_launchxl/

BOARDS/ARM - NXP FRDM-K64F
M:	Maureen Helm <maureen.helm@nxp.com>
S:	Supported
F:	boards/arm/frdm_k64f/

BOARDS/ARM - NXP FRDM-KW41Z
M:	Maureen Helm <maureen.helm@nxp.com>
S:	Supported
F:	boards/arm/frdm_kw41z/

BOARDS/ARM - NXP Hexiwear
M:	Maureen Helm <maureen.helm@nxp.com>
S:	Supported
F:	boards/arm/hexiwear_k64/

BOARDS/ARM - NORDIC NRF51 REDBEAR BLENANO
M:	Ricardo Salveti <ricardo.salveti@linaro.org>
S:	Supported
F:	boards/arm/nrf51_blenano/

BOARDS/ARM - NORDIC NRF52 PCA10040
M:	Carles Cufi <carles.cufi@nordicsemi.no>
S:	Supported
F:	boards/arm/nrf52_pca10040/

BOARDS/ARM - NUCLEO-64 F401RE Devboard
M:	Amit Kucheria <amit.kucheria@linaro.org>
M:	Ricardo Salveti <ricardo.salveti@linaro.org>
S:	Supported
F:	boards/arm/nucleo_f401re/

BOARDS/ARM - ARM LTD V2M Beetle
M:	Vincenzo Frascino <vincenzo.frascino@linaro.org>
S:	Supported
F:	boards/arm/v2m_beetle/

BOARDS/NIOS2 - ALTERA MAX10
M:	Andrew Boie <andrew.p.boie@intel.com>
S:	Supported
F:	boards/nios2/altera_max10/

BOARDS/X86 - ARDUINO 101
M:      Anas Nashif <anas.nashif@intel.com>
S:	Supported
F:	boards/x86/arduino_101/

BOARDS/X86 - Galileo
M:      Anas Nashif <anas.nashif@intel.com>
S:	Supported
F:	boards/x86/galileo/

BOARDS/X86 - QUARK D2000 Devboard
M:      Anas Nashif <anas.nashif@intel.com>
S:	Supported
F:	boards/x86/quark_d2000/

BOARDS/X86 - QUARK SE C1000 Devboard
M:      Anas Nashif <anas.nashif@intel.com>
S:	Supported
F:	boards/x86/quark_se_c1000/

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:	subsys/bluetooth/
F:	include/bluetooth/
F:	include/drivers/bluetooth/
F:	drivers/bluetooth/
F:	samples/bluetooth/
F:	tests/bluetooth/
F:	doc/subsystems/bluetooth/

BLUETOOTH CONTROLLER
M:	Vinayak Chettimada <vinayak.kariappa.chettimada@nordicsemi.no>
M:	Carles Cufi <carles.cufi@nordicsemi.no>
S:	Supported
F:	subsys/bluetooth/controller/

CC3200 SDK
M:      Gil Pitney <gil.pitney@linaro.org>
S:      Supported
F:      ext/hal/cc3200sdk/

CC32XX SOC - TI SIMPLELINK
M:      Gil Pitney <gil.pitney@linaro.org>
S:      Supported
F:      arch/arm/soc/ti_simplelink/

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

FILE SYSTEM
M:	Ramesh Thomas <ramesh.thomas@intel.com>
M:	Kuo-Lang Tseng <kuo-lang.tseng@intel.com>
S:	Supported
F:	ext/fs/
F:	subsys/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:	Andrew Boie <andrew.p.boie@intel.com>
M:	Andy Ross <andrew.j.ross@intel.com>
S:	Supported
F:	kernel/
F:	include/nanokernel.h
F:	include/microkernel.h
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
F:	include/kernel.h
F:	include/legacy.h
F:	tests/kernel/

KNOWN ISSUES
M:	Anas Nashif <anas.nashif@intel.com>
M:	Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
M:	Genaro Saucedo <genaro.saucedo.tejada@intel.com>
F:	.known-issues/


MAINTAINERS
M:	Genaro Saucedo <genaro.saucedo.tejada@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/

MCUXPRESSO SOFTWARE DEVELOPMENT KIT (MCUX)
M:	Maureen Helm <maureen.helm@nxp.com>
S:	Supported
F:	ext/hal/nxp/mcux/

MPS2 - ARM LTD CORTEX-M PROTOTYPING SYSTEM
M:	Vincenzo Frascino <vincenzo.frascino@linaro.org>
S:	Supported
F:	arch/arm/soc/arm/mps2/
F:	boards/arm/mps2/

NETWORKING
M:	Jukka Rissanen <jukka.rissanen@linux.intel.com>
M:	Tomasz Bursztyka <tomasz.bursztyka@linux.intel.com>
S:	Supported
W:	https://www.zephyrproject.org/doc/subsystems/networking/networking.html
F:	subsys/net/ip/
F:	subsys/net/lib/
F:	include/net/
F:	samples/net/
F:	tests/net/
F:	tests/net/lib/
F:	drivers/ethernet/
F:	drivers/ieee802154/
F:	drivers/slip/

NETWORK APPLICATIONS
M:	Flavio Santes <flavio.santes@intel.com>
S:	Supported
F:	subsys/net/lib/dns/
F:	subsys/net/lib/http/
F:	subsys/net/lib/mqtt/
F:	samples/net/dns_client/
F:	samples/net/http_server/
F:	samples/net/mqtt_publisher/
F:	tests/net/lib/http_header_fields/
F:	tests/net/lib/mqtt_packet/

NETWORK BUFFERS
M:	Johan Hedberg <johan.hedberg@intel.com>
M:	Jukka Rissanen <jukka.rissanen@linux.intel.com>
M:	Tomasz Bursztyka <tomasz.bursztyka@linux.intel.com>
S:	Supported
W:	https://www.zephyrproject.org/doc/subsystems/networking/buffers.html
F:	subsys/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/
F:	boards/nios2/

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/k_idle.c
F:	kernel/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*

QUARK D2000 SOC
M:      Anas Nashif <anas.nashif@intel.com>
S:	Supported
F:	arch/x86/soc/intel_quark/quark_d2000/

QUARK SE C1000 SOC
M:      Anas Nashif <anas.nashif@intel.com>
S:	Supported
F:	arch/x86/soc/intel_quark/quark_se_c1000/

QUARK X1000 SOC
M:      Anas Nashif <anas.nashif@intel.com>
S:	Supported
F:	arch/x86/soc/intel_quark/quark_x1000/

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.davidoaia@linaro.org>
M:	Murtaza Alexandru <murtaza.alexandru1995@gmail.com>
S:	Supported
W:	https://www.zephyrproject.org/doc/subsystems/sensor.html
F:	include/sensor.h
F:	drivers/sensor/
F:	samples/sensor/

STM32CUBE SDK
M:	Erwan Gouriou <erwan.gouriou@linaro.org>
S:	Supported
F:	ext/hal/st/stm32cube/

STM32F4X SoC FAMILY and DRIVERS
M:	Amit Kucheria <amit.kucheria@linaro.org>
M:	Ricardo Salveti <ricardo.salveti@linaro.org>
S:	Supported
F:	arch/arm/soc/st_stm32/stm32f4/
F:	drivers/pinmux/stm32/
F:	drivers/gpio/*stm32*
F:	drivers/clock_control/*stm32f4*

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/

SPI
M:	Tomasz Bursztyka <tomasz.bursztyka@linux.intel.com>
S:	Supported
F:	drivers/spi/
F:	include/spi.h
F:	tests/drivers/spi_test/

USB
M:	Jithu Joseph <jithu.joseph@intel.com>
S:	Supported
F:	subsys/usb
F:	drivers/usb
F:	samples/usb

X86 ARCH
M:	Benjamin Walsh <benjamin.walsh@windriver.com>
M:	Andrew Boie <andrew.p.boie@intel.com>
S:	Supported
F:	arch/x86/
F:	include/arch/x86/
F:	boards/x86/

XTENSA ARCH
M:	Andrew Boie <andrew.p.boie@intel.com>
S:	Supported
F:	arch/xtensa
F:	include/arch/xtensa/
F:	boards/xtensa/

RISCV32 ARCH
M:	Jean-Paul Etienne <fractalclone@gmail.com>
S:	Supported
F:	arch/riscv32
F:	include/arch/riscv32
F:	boards/riscv32
F:	drivers/serial/uart_riscv_qemu.c
F:	drivers/timer/pulpino_timer.c
F:	drivers/timer/riscv_machine_timer.c
F:	drivers/gpio/gpio_pulpino.c

ZOAP
M:	Vinicius Costa Gomes <vinicius.gomes@intel.com>
S:	Supported
F:	subsys/net/lib/zoap/
F:	samples/net/zoap_client/
F:	samples/net/zoap_server/
F:	tests/net/lib/zoap/

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