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)

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

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

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

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

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/

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

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:	*/
