

	List of maintainers and how to submit kernel changes

Please try to follow the guidelines below.  This will make things
easier on the maintainers.  Not all of these guidelines matter for every
trivial patch so apply some common sense.

1.	Always _test_ your changes, however small, on at least 4 or
	5 people, preferably many more.

2.	Try to release a few ALPHA test versions to the net. Announce
	them onto the kernel channel and await results. This is especially
	important for device drivers, because often that's the only way
	you will find things like the fact version 3 firmware needs
	a magic fix you didn't know about, or some clown changed the
	chips on a board and not its name.  (Don't laugh!  Look at the
	SMC etherpower for that.)

3.	Make sure your changes compile correctly in multiple
	configurations. In particular check that changes work both as a
	module and built into the kernel.

4.	When you are happy with a change make it generally available for
	testing and await feedback.

5.	Make a patch available to the relevant maintainer in the list. Use
	'diff -u' to make the patch easy to merge. Be prepared to get your
	changes sent back with seemingly silly requests about formatting
	and variable names.  These aren't as silly as they seem. One
	job the maintainers (and especially Linus) do is to keep things
	looking the same. Sometimes this means that the clever hack in
	your driver to get around a problem actually needs to become a
	generalized kernel feature ready for next time.

	PLEASE check your patch with the automated style checker
	(scripts/checkpatch.pl) to catch trivial style violations.
	See Documentation/process/coding-style.rst for guidance here.

	PLEASE CC: the maintainers and mailing lists that are generated
	by scripts/get_maintainer.pl.  The results returned by the
	script will be best if you have git installed and are making
	your changes in a branch derived from Linus' latest git tree.
	See Documentation/process/submitting-patches.rst for details.

	PLEASE try to include any credit lines you want added with the
	patch. It avoids people being missed off by mistake and makes
	it easier to know who wants adding and who doesn't.

	PLEASE document known bugs. If it doesn't work for everything
	or does something very odd once a month document it.

	PLEASE remember that submissions must be made under the terms
	of the Linux Foundation certificate of contribution and should
	include a Signed-off-by: line.  The current version of this
	"Developer's Certificate of Origin" (DCO) is listed in the file
	Documentation/process/submitting-patches.rst.

6.	Make sure you have the right to send any changes you make. If you
	do changes at work you may find your employer owns the patch
	not you.

7.	When sending security related changes or reports to a maintainer
	please Cc: security@kernel.org, especially if the maintainer
	does not respond. Please keep in mind that the security team is
	a small set of people who can be efficient only when working on
	verified bugs. Please only Cc: this list when you have identified
	that the bug would present a short-term risk to other users if it
	were publicly disclosed. For example, reports of address leaks do
	not represent an immediate threat and are better handled publicly,
	and ideally, should come with a patch proposal. Please do not send
	automated reports to this list either. Such bugs will be handled
	better and faster in the usual public places.

8.	Happy hacking.

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
	B: URI for where to file bugs. A web-page with detailed bug
	   filing info, a direct bug tracker link, or a mailto: URI.
	C: URI for chat protocol, server and channel where developers
	   usually hang out, for example irc://server/channel.
	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)

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

3C59X NETWORK DRIVER
M:	Steffen Klassert <klassert@kernel.org>
L:	netdev@vger.kernel.org
S:	Odd Fixes
F:	Documentation/networking/vortex.txt
F:	drivers/net/ethernet/3com/3c59x.c

3CR990 NETWORK DRIVER
M:	David Dillow <dave@thedillows.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/3com/typhoon*

3WARE SAS/SATA-RAID SCSI DRIVERS (3W-XXXX, 3W-9XXX, 3W-SAS)
M:	Adam Radford <aradford@gmail.com>
L:	linux-scsi@vger.kernel.org
W:	http://www.lsi.com
S:	Supported
F:	drivers/scsi/3w-*

53C700 AND 53C700-66 SCSI DRIVER
M:	"James E.J. Bottomley" <James.Bottomley@HansenPartnership.com>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	drivers/scsi/53c700*

6LOWPAN GENERIC (BTLE/IEEE 802.15.4)
M:	Alexander Aring <alex.aring@gmail.com>
M:	Jukka Rissanen <jukka.rissanen@linux.intel.com>
L:	linux-bluetooth@vger.kernel.org
L:	linux-wpan@vger.kernel.org
S:	Maintained
F:	net/6lowpan/
F:	include/net/6lowpan.h
F:	Documentation/networking/6lowpan.txt

6PACK NETWORK DRIVER FOR AX.25
M:	Andreas Koensgen <ajk@comnets.uni-bremen.de>
L:	linux-hams@vger.kernel.org
S:	Maintained
F:	drivers/net/hamradio/6pack.c

8169 10/100/1000 GIGABIT ETHERNET DRIVER
M:	Realtek linux nic maintainers <nic_swsd@realtek.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/realtek/r8169.c

8250/16?50 (AND CLONE UARTS) SERIAL DRIVER
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
L:	linux-serial@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty.git
F:	drivers/tty/serial/8250*
F:	include/linux/serial_8250.h

8390 NETWORK DRIVERS [WD80x3/SMC-ELITE, SMC-ULTRA, NE2000, 3C503, etc.]
L:	netdev@vger.kernel.org
S:	Orphan / Obsolete
F:	drivers/net/ethernet/8390/

9P FILE SYSTEM
M:	Eric Van Hensbergen <ericvh@gmail.com>
M:	Ron Minnich <rminnich@sandia.gov>
M:	Latchesar Ionkov <lucho@ionkov.net>
L:	v9fs-developer@lists.sourceforge.net
W:	http://swik.net/v9fs
Q:	http://patchwork.kernel.org/project/v9fs-devel/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ericvh/v9fs.git
S:	Maintained
F:	Documentation/filesystems/9p.txt
F:	fs/9p/
F:	net/9p/
F:	include/net/9p/
F:	include/uapi/linux/virtio_9p.h
F:	include/trace/events/9p.h

A8293 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/a8293*

AACRAID SCSI RAID DRIVER
M:	Adaptec OEM Raid Solutions <aacraid@microsemi.com>
L:	linux-scsi@vger.kernel.org
W:	http://www.adaptec.com/
S:	Supported
F:	Documentation/scsi/aacraid.txt
F:	drivers/scsi/aacraid/

ABI/API
L:	linux-api@vger.kernel.org
F:	include/linux/syscalls.h
F:	kernel/sys_ni.c

ABIT UGURU 1,2 HARDWARE MONITOR DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/abituguru.c

ABIT UGURU 3 HARDWARE MONITOR DRIVER
M:	Alistair John Strachan <alistair@devzero.co.uk>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/abituguru3.c

ACCES 104-DIO-48E GPIO DRIVER
M:	William Breathitt Gray <vilhelm.gray@gmail.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-104-dio-48e.c

ACCES 104-IDI-48 GPIO DRIVER
M:	"William Breathitt Gray" <vilhelm.gray@gmail.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-104-idi-48.c

ACCES 104-IDIO-16 GPIO DRIVER
M:	"William Breathitt Gray" <vilhelm.gray@gmail.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-104-idio-16.c

ACCES 104-QUAD-8 IIO DRIVER
M:	William Breathitt Gray <vilhelm.gray@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-iio-counter-104-quad-8
F:	drivers/iio/counter/104-quad-8.c

ACCES PCI-IDIO-16 GPIO DRIVER
M:	William Breathitt Gray <vilhelm.gray@gmail.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-pci-idio-16.c

ACCES PCIe-IDIO-24 GPIO DRIVER
M:	William Breathitt Gray <vilhelm.gray@gmail.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-pcie-idio-24.c

ACENIC DRIVER
M:	Jes Sorensen <jes@trained-monkey.org>
L:	linux-acenic@sunsite.dk
S:	Maintained
F:	drivers/net/ethernet/alteon/acenic*

ACER ASPIRE ONE TEMPERATURE AND FAN DRIVER
M:	Peter Feuerer <peter@piie.net>
L:	platform-driver-x86@vger.kernel.org
W:	http://piie.net/?section=acerhdf
S:	Maintained
F:	drivers/platform/x86/acerhdf.c

ACER WMI LAPTOP EXTRAS
M:	"Lee, Chun-Yi" <jlee@suse.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/acer-wmi.c

ACPI
M:	"Rafael J. Wysocki" <rjw@rjwysocki.net>
M:	Len Brown <lenb@kernel.org>
L:	linux-acpi@vger.kernel.org
W:	https://01.org/linux-acpi
Q:	https://patchwork.kernel.org/project/linux-acpi/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
B:	https://bugzilla.kernel.org
S:	Supported
F:	drivers/acpi/
F:	drivers/pnp/pnpacpi/
F:	include/linux/acpi.h
F:	include/linux/fwnode.h
F:	include/acpi/
F:	Documentation/acpi/
F:	Documentation/ABI/testing/sysfs-bus-acpi
F:	Documentation/ABI/testing/configfs-acpi
F:	drivers/pci/*acpi*
F:	drivers/pci/*/*acpi*
F:	drivers/pci/*/*/*acpi*
F:	tools/power/acpi/

ACPI APEI
M:	"Rafael J. Wysocki" <rjw@rjwysocki.net>
M:	Len Brown <lenb@kernel.org>
L:	linux-acpi@vger.kernel.org
R:	Tony Luck <tony.luck@intel.com>
R:	Borislav Petkov <bp@alien8.de>
F:	drivers/acpi/apei/

ACPI COMPONENT ARCHITECTURE (ACPICA)
M:	Robert Moore <robert.moore@intel.com>
M:	Erik Schmauss <erik.schmauss@intel.com>
M:	"Rafael J. Wysocki" <rafael.j.wysocki@intel.com>
L:	linux-acpi@vger.kernel.org
L:	devel@acpica.org
W:	https://acpica.org/
W:	https://github.com/acpica/acpica/
Q:	https://patchwork.kernel.org/project/linux-acpi/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
B:	https://bugzilla.kernel.org
B:	https://bugs.acpica.org
S:	Supported
F:	drivers/acpi/acpica/
F:	include/acpi/
F:	tools/power/acpi/

ACPI FAN DRIVER
M:	Zhang Rui <rui.zhang@intel.com>
L:	linux-acpi@vger.kernel.org
W:	https://01.org/linux-acpi
B:	https://bugzilla.kernel.org
S:	Supported
F:	drivers/acpi/fan.c

ACPI FOR ARM64 (ACPI/arm64)
M:	Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
M:	Hanjun Guo <hanjun.guo@linaro.org>
M:	Sudeep Holla <sudeep.holla@arm.com>
L:	linux-acpi@vger.kernel.org
S:	Maintained
F:	drivers/acpi/arm64

ACPI PMIC DRIVERS
M:	"Rafael J. Wysocki" <rjw@rjwysocki.net>
M:	Len Brown <lenb@kernel.org>
R:	Andy Shevchenko <andy@infradead.org>
R:	Mika Westerberg <mika.westerberg@linux.intel.com>
L:	linux-acpi@vger.kernel.org
Q:	https://patchwork.kernel.org/project/linux-acpi/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
B:	https://bugzilla.kernel.org
S:	Supported
F:	drivers/acpi/pmic/

ACPI THERMAL DRIVER
M:	Zhang Rui <rui.zhang@intel.com>
L:	linux-acpi@vger.kernel.org
W:	https://01.org/linux-acpi
B:	https://bugzilla.kernel.org
S:	Supported
F:	drivers/acpi/*thermal*

ACPI VIDEO DRIVER
M:	Zhang Rui <rui.zhang@intel.com>
L:	linux-acpi@vger.kernel.org
W:	https://01.org/linux-acpi
B:	https://bugzilla.kernel.org
S:	Supported
F:	drivers/acpi/acpi_video.c

ACPI WMI DRIVER
L:	platform-driver-x86@vger.kernel.org
S:	Orphan
F:	drivers/platform/x86/wmi.c
F:	include/uapi/linux/wmi.h

AD1889 ALSA SOUND DRIVER
M:	Thibaut Varene <T-Bone@parisc-linux.org>
W:	http://wiki.parisc-linux.org/AD1889
L:	linux-parisc@vger.kernel.org
S:	Maintained
F:	sound/pci/ad1889.*

AD525X ANALOG DEVICES DIGITAL POTENTIOMETERS DRIVER
M:	Michael Hennerich <michael.hennerich@analog.com>
W:	http://wiki.analog.com/AD5254
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	drivers/misc/ad525x_dpot.c

AD5398 CURRENT REGULATOR DRIVER (AD5398/AD5821)
M:	Michael Hennerich <michael.hennerich@analog.com>
W:	http://wiki.analog.com/AD5398
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	drivers/regulator/ad5398.c

AD714X CAPACITANCE TOUCH SENSOR DRIVER (AD7142/3/7/8/7A)
M:	Michael Hennerich <michael.hennerich@analog.com>
W:	http://wiki.analog.com/AD7142
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	drivers/input/misc/ad714x.c

AD7877 TOUCHSCREEN DRIVER
M:	Michael Hennerich <michael.hennerich@analog.com>
W:	http://wiki.analog.com/AD7877
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	drivers/input/touchscreen/ad7877.c

AD7879 TOUCHSCREEN DRIVER (AD7879/AD7889)
M:	Michael Hennerich <michael.hennerich@analog.com>
W:	http://wiki.analog.com/AD7879
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	drivers/input/touchscreen/ad7879.c

ADDRESS SPACE LAYOUT RANDOMIZATION (ASLR)
M:	Jiri Kosina <jikos@kernel.org>
S:	Maintained

ADF7242 IEEE 802.15.4 RADIO DRIVER
M:	Michael Hennerich <michael.hennerich@analog.com>
W:	https://wiki.analog.com/ADF7242
W:	http://ez.analog.com/community/linux-device-drivers
L:	linux-wpan@vger.kernel.org
S:	Supported
F:	drivers/net/ieee802154/adf7242.c
F:	Documentation/devicetree/bindings/net/ieee802154/adf7242.txt

ADM1025 HARDWARE MONITOR DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/adm1025
F:	drivers/hwmon/adm1025.c

ADM1029 HARDWARE MONITOR DRIVER
M:	Corentin Labbe <clabbe.montjoie@gmail.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/adm1029.c

ADM8211 WIRELESS DRIVER
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/
S:	Orphan
F:	drivers/net/wireless/admtek/adm8211.*

ADP1653 FLASH CONTROLLER DRIVER
M:	Sakari Ailus <sakari.ailus@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/adp1653.c
F:	include/media/i2c/adp1653.h

ADP5520 BACKLIGHT DRIVER WITH IO EXPANDER (ADP5520/ADP5501)
M:	Michael Hennerich <michael.hennerich@analog.com>
W:	http://wiki.analog.com/ADP5520
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	drivers/mfd/adp5520.c
F:	drivers/video/backlight/adp5520_bl.c
F:	drivers/leds/leds-adp5520.c
F:	drivers/gpio/gpio-adp5520.c
F:	drivers/input/keyboard/adp5520-keys.c

ADP5588 QWERTY KEYPAD AND IO EXPANDER DRIVER (ADP5588/ADP5587)
M:	Michael Hennerich <michael.hennerich@analog.com>
W:	http://wiki.analog.com/ADP5588
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	drivers/input/keyboard/adp5588-keys.c
F:	drivers/gpio/gpio-adp5588.c

ADP8860 BACKLIGHT DRIVER (ADP8860/ADP8861/ADP8863)
M:	Michael Hennerich <michael.hennerich@analog.com>
W:	http://wiki.analog.com/ADP8860
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	drivers/video/backlight/adp8860_bl.c

ADS1015 HARDWARE MONITOR DRIVER
M:	Dirk Eibach <eibach@gdsys.de>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/ads1015
F:	drivers/hwmon/ads1015.c
F:	include/linux/platform_data/ads1015.h

ADT746X FAN DRIVER
M:	Colin Leroy <colin@colino.net>
S:	Maintained
F:	drivers/macintosh/therm_adt746x.c

ADT7475 HARDWARE MONITOR DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/adt7475
F:	drivers/hwmon/adt7475.c

ADVANSYS SCSI DRIVER
M:	Matthew Wilcox <matthew@wil.cx>
M:	Hannes Reinecke <hare@suse.com>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	Documentation/scsi/advansys.txt
F:	drivers/scsi/advansys.c

ADXL34X THREE-AXIS DIGITAL ACCELEROMETER DRIVER (ADXL345/ADXL346)
M:	Michael Hennerich <michael.hennerich@analog.com>
W:	http://wiki.analog.com/ADXL345
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	drivers/input/misc/adxl34x.c

AF9013 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/af9013*

AF9033 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/af9033*

AFFS FILE SYSTEM
M:	David Sterba <dsterba@suse.com>
L:	linux-fsdevel@vger.kernel.org
S:	Odd Fixes
F:	Documentation/filesystems/affs.txt
F:	fs/affs/

AFS FILESYSTEM
M:	David Howells <dhowells@redhat.com>
L:	linux-afs@lists.infradead.org
S:	Supported
F:	fs/afs/
F:	include/trace/events/afs.h
F:	Documentation/filesystems/afs.txt
W:	https://www.infradead.org/~dhowells/kafs/

AGPGART DRIVER
M:	David Airlie <airlied@linux.ie>
T:	git git://people.freedesktop.org/~airlied/linux (part of drm maint)
S:	Maintained
F:	drivers/char/agp/
F:	include/linux/agp*
F:	include/uapi/linux/agp*

AHA152X SCSI DRIVER
M:	"Juergen E. Fischer" <fischer@norbit.de>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	drivers/scsi/aha152x*
F:	drivers/scsi/pcmcia/aha152x*

AIC7XXX / AIC79XX SCSI DRIVER
M:	Hannes Reinecke <hare@suse.com>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	drivers/scsi/aic7xxx/

AIMSLAB FM RADIO RECEIVER DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/radio/radio-aimslab*

AIO
M:	Benjamin LaHaise <bcrl@kvack.org>
L:	linux-aio@kvack.org
S:	Supported
F:	fs/aio.c
F:	include/linux/*aio*.h

AIRSPY MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/usb/airspy/

ALACRITECH GIGABIT ETHERNET DRIVER
M:	Lino Sanfilippo <LinoSanfilippo@gmx.de>
S:	Maintained
F:	drivers/net/ethernet/alacritech/*

ALCATEL SPEEDTOUCH USB DRIVER
M:	Duncan Sands <duncan.sands@free.fr>
L:	linux-usb@vger.kernel.org
W:	http://www.linux-usb.org/SpeedTouch/
S:	Maintained
F:	drivers/usb/atm/speedtch.c
F:	drivers/usb/atm/usbatm.c

ALCHEMY AU1XX0 MMC DRIVER
M:	Manuel Lauss <manuel.lauss@gmail.com>
S:	Maintained
F:	drivers/mmc/host/au1xmmc.c

ALI1563 I2C DRIVER
M:	Rudolf Marek <r.marek@assembler.cz>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/i2c/busses/i2c-ali1563
F:	drivers/i2c/busses/i2c-ali1563.c

ALLWINNER SECURITY SYSTEM
M:	Corentin Labbe <clabbe.montjoie@gmail.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	drivers/crypto/sunxi-ss/

ALPHA PORT
M:	Richard Henderson <rth@twiddle.net>
M:	Ivan Kokshaysky <ink@jurassic.park.msu.ru>
M:	Matt Turner <mattst88@gmail.com>
S:	Odd Fixes
L:	linux-alpha@vger.kernel.org
F:	arch/alpha/

ALPS PS/2 TOUCHPAD DRIVER
R:	Pali Rohár <pali.rohar@gmail.com>
F:	drivers/input/mouse/alps.*

ALTERA I2C CONTROLLER DRIVER
M:	Thor Thayer <thor.thayer@linux.intel.com>
S:	Maintained
F:	drivers/i2c/busses/i2c-altera.c

ALTERA MAILBOX DRIVER
M:	Ley Foon Tan <lftan@altera.com>
L:	nios2-dev@lists.rocketboards.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/mailbox/mailbox-altera.c

ALTERA PIO DRIVER
M:	Tien Hock Loh <thloh@altera.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-altera.c

ALTERA SYSTEM RESOURCE DRIVER FOR ARRIA10 DEVKIT
M:	Thor Thayer <thor.thayer@linux.intel.com>
S:	Maintained
F:	drivers/gpio/gpio-altera-a10sr.c
F:	drivers/mfd/altera-a10sr.c
F:	drivers/reset/reset-a10sr.c
F:	include/linux/mfd/altera-a10sr.h
F:	include/dt-bindings/reset/altr,rst-mgr-a10sr.h

ALTERA TRIPLE SPEED ETHERNET DRIVER
M:	Vince Bridgers <vbridger@opensource.altera.com>
L:	netdev@vger.kernel.org
L:	nios2-dev@lists.rocketboards.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/net/ethernet/altera/

ALTERA UART/JTAG UART SERIAL DRIVERS
M:	Tobias Klauser <tklauser@distanz.ch>
L:	linux-serial@vger.kernel.org
L:	nios2-dev@lists.rocketboards.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/tty/serial/altera_uart.c
F:	drivers/tty/serial/altera_jtaguart.c
F:	include/linux/altera_uart.h
F:	include/linux/altera_jtaguart.h

AMAZON ETHERNET DRIVERS
M:	Netanel Belgazal <netanel@amazon.com>
R:	Saeed Bishara <saeedb@amazon.com>
R:	Zorik Machulsky <zorik@amazon.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/ena.txt
F:	drivers/net/ethernet/amazon/

AMD CRYPTOGRAPHIC COPROCESSOR (CCP) DRIVER
M:	Tom Lendacky <thomas.lendacky@amd.com>
M:	Gary Hook <gary.hook@amd.com>
L:	linux-crypto@vger.kernel.org
S:	Supported
F:	drivers/crypto/ccp/
F:	include/linux/ccp.h

AMD FAM15H PROCESSOR POWER MONITORING DRIVER
M:	Huang Rui <ray.huang@amd.com>
L:	linux-hwmon@vger.kernel.org
S:	Supported
F:	Documentation/hwmon/fam15h_power
F:	drivers/hwmon/fam15h_power.c

AMD GEODE CS5536 USB DEVICE CONTROLLER DRIVER
L:	linux-geode@lists.infradead.org (moderated for non-subscribers)
S:	Orphan
F:	drivers/usb/gadget/udc/amd5536udc.*

AMD GEODE PROCESSOR/CHIPSET SUPPORT
P:	Andres Salomon <dilinger@queued.net>
L:	linux-geode@lists.infradead.org (moderated for non-subscribers)
W:	http://www.amd.com/us-en/ConnectivitySolutions/TechnicalResources/0,,50_2334_2452_11363,00.html
S:	Supported
F:	drivers/char/hw_random/geode-rng.c
F:	drivers/crypto/geode*
F:	drivers/video/fbdev/geode/
F:	arch/x86/include/asm/geode.h

AMD IOMMU (AMD-VI)
M:	Joerg Roedel <joro@8bytes.org>
L:	iommu@lists.linux-foundation.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git
S:	Maintained
F:	drivers/iommu/amd_iommu*.[ch]
F:	include/linux/amd-iommu.h

AMD KFD
M:	Oded Gabbay <oded.gabbay@gmail.com>
L:	dri-devel@lists.freedesktop.org
T:	git git://people.freedesktop.org/~gabbayo/linux.git
S:	Supported
F:	drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c
F:	drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h
F:	drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v7.c
F:	drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v8.c
F:	drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.c
F:	drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_fence.c
F:	drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c
F:	drivers/gpu/drm/amd/amdkfd/
F:	drivers/gpu/drm/amd/include/cik_structs.h
F:	drivers/gpu/drm/amd/include/kgd_kfd_interface.h
F:	drivers/gpu/drm/amd/include/vi_structs.h
F:	drivers/gpu/drm/amd/include/v9_structs.h
F:	include/uapi/linux/kfd_ioctl.h

AMD SEATTLE DEVICE TREE SUPPORT
M:	Brijesh Singh <brijeshkumar.singh@amd.com>
M:	Suravee Suthikulpanit <suravee.suthikulpanit@amd.com>
M:	Tom Lendacky <thomas.lendacky@amd.com>
S:	Supported
F:	arch/arm64/boot/dts/amd/

AMD XGBE DRIVER
M:	Tom Lendacky <thomas.lendacky@amd.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/amd/xgbe/
F:	arch/arm64/boot/dts/amd/amd-seattle-xgbe*.dtsi

AMS (Apple Motion Sensor) DRIVER
M:	Michael Hanselmann <linux-kernel@hansmi.ch>
S:	Supported
F:	drivers/macintosh/ams/

ANALOG DEVICES INC AD5686 DRIVER
M:	Stefan Popa <stefan.popa@analog.com>
L:	linux-pm@vger.kernel.org
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	drivers/iio/dac/ad5686*
F:	drivers/iio/dac/ad5696*

ANALOG DEVICES INC AD9389B DRIVER
M:	Hans Verkuil <hans.verkuil@cisco.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/ad9389b*

ANALOG DEVICES INC ADV7180 DRIVER
M:	Lars-Peter Clausen <lars@metafoo.de>
L:	linux-media@vger.kernel.org
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	drivers/media/i2c/adv7180.c

ANALOG DEVICES INC ADV748X DRIVER
M:	Kieran Bingham <kieran.bingham@ideasonboard.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/adv748x/*

ANALOG DEVICES INC ADV7511 DRIVER
M:	Hans Verkuil <hans.verkuil@cisco.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/adv7511*

ANALOG DEVICES INC ADV7604 DRIVER
M:	Hans Verkuil <hans.verkuil@cisco.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/adv7604*

ANALOG DEVICES INC ADV7842 DRIVER
M:	Hans Verkuil <hans.verkuil@cisco.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/adv7842*

ANALOG DEVICES INC ASOC CODEC DRIVERS
M:	Lars-Peter Clausen <lars@metafoo.de>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
W:	http://wiki.analog.com/
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	sound/soc/codecs/adau*
F:	sound/soc/codecs/adav*
F:	sound/soc/codecs/ad1*
F:	sound/soc/codecs/ad7*
F:	sound/soc/codecs/ssm*
F:	sound/soc/codecs/sigmadsp.*

ANALOG DEVICES INC DMA DRIVERS
M:	Lars-Peter Clausen <lars@metafoo.de>
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	drivers/dma/dma-axi-dmac.c

ANALOG DEVICES INC IIO DRIVERS
M:	Lars-Peter Clausen <lars@metafoo.de>
M:	Michael Hennerich <Michael.Hennerich@analog.com>
W:	http://wiki.analog.com/
W:	http://ez.analog.com/community/linux-device-drivers
S:	Supported
F:	Documentation/ABI/testing/sysfs-bus-iio-frequency-ad9523
F:	Documentation/ABI/testing/sysfs-bus-iio-frequency-adf4350
F:	drivers/iio/*/ad*
F:	drivers/iio/adc/ltc2497*
X:	drivers/iio/*/adjd*
F:	drivers/staging/iio/*/ad*

ANDES ARCHITECTURE
M:	Greentime Hu <green.hu@gmail.com>
M:	Vincent Chen <deanbo422@gmail.com>
T:	git https://github.com/andestech/linux.git
S:	Supported
F:	arch/nds32/
F:	Documentation/devicetree/bindings/interrupt-controller/andestech,ativic32.txt
F:	Documentation/devicetree/bindings/nds32/
K:	nds32
N:	nds32

ANDROID CONFIG FRAGMENTS
M:	Rob Herring <robh@kernel.org>
S:	Supported
F:	kernel/configs/android*

ANDROID DRIVERS
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
M:	Arve Hjønnevåg <arve@android.com>
M:	Todd Kjos <tkjos@android.com>
M:	Martijn Coenen <maco@android.com>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging.git
L:	devel@driverdev.osuosl.org
S:	Supported
F:	drivers/android/
F:	drivers/staging/android/

ANDROID GOLDFISH PIC DRIVER
M:	Miodrag Dinic <miodrag.dinic@mips.com>
S:	Supported
F:	Documentation/devicetree/bindings/interrupt-controller/google,goldfish-pic.txt
F:	drivers/irqchip/irq-goldfish-pic.c

ANDROID GOLDFISH RTC DRIVER
M:	Miodrag Dinic <miodrag.dinic@mips.com>
S:	Supported
F:	Documentation/devicetree/bindings/rtc/google,goldfish-rtc.txt
F:	drivers/rtc/rtc-goldfish.c

ANDROID ION DRIVER
M:	Laura Abbott <labbott@redhat.com>
M:	Sumit Semwal <sumit.semwal@linaro.org>
L:	devel@driverdev.osuosl.org
L:	dri-devel@lists.freedesktop.org
L:	linaro-mm-sig@lists.linaro.org (moderated for non-subscribers)
S:	Supported
F:	drivers/staging/android/ion
F:	drivers/staging/android/uapi/ion.h

AOA (Apple Onboard Audio) ALSA DRIVER
M:	Johannes Berg <johannes@sipsolutions.net>
L:	linuxppc-dev@lists.ozlabs.org
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	sound/aoa/

APEX EMBEDDED SYSTEMS STX104 IIO DRIVER
M:	William Breathitt Gray <vilhelm.gray@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	drivers/iio/adc/stx104.c

APM DRIVER
M:	Jiri Kosina <jikos@kernel.org>
S:	Odd fixes
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jikos/apm.git
F:	arch/x86/kernel/apm_32.c
F:	include/linux/apm_bios.h
F:	include/uapi/linux/apm_bios.h
F:	drivers/char/apm-emulation.c

APPARMOR SECURITY MODULE
M:	John Johansen <john.johansen@canonical.com>
L:	apparmor@lists.ubuntu.com (subscribers-only, general discussion)
W:	wiki.apparmor.net
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jj/linux-apparmor
S:	Supported
F:	security/apparmor/
F:	Documentation/admin-guide/LSM/apparmor.rst

APPLE BCM5974 MULTITOUCH DRIVER
M:	Henrik Rydberg <rydberg@bitmath.org>
L:	linux-input@vger.kernel.org
S:	Odd fixes
F:	drivers/input/mouse/bcm5974.c

APPLE SMC DRIVER
M:	Henrik Rydberg <rydberg@bitmath.org>
L:	linux-hwmon@vger.kernel.org
S:	Odd fixes
F:	drivers/hwmon/applesmc.c

APPLETALK NETWORK LAYER
L:	netdev@vger.kernel.org
S:	Odd fixes
F:	drivers/net/appletalk/
F:	net/appletalk/

APPLIED MICRO (APM) X-GENE DEVICE TREE SUPPORT
M:	Duc Dang <dhdang@apm.com>
S:	Supported
F:	arch/arm64/boot/dts/apm/

APPLIED MICRO (APM) X-GENE SOC EDAC
M:	Loc Ho <lho@apm.com>
S:	Supported
F:	drivers/edac/xgene_edac.c
F:	Documentation/devicetree/bindings/edac/apm-xgene-edac.txt

APPLIED MICRO (APM) X-GENE SOC ETHERNET (V2) DRIVER
M:	Iyappan Subramanian <isubramanian@apm.com>
M:	Keyur Chudgar <kchudgar@apm.com>
S:	Supported
F:	drivers/net/ethernet/apm/xgene-v2/

APPLIED MICRO (APM) X-GENE SOC ETHERNET DRIVER
M:	Iyappan Subramanian <isubramanian@apm.com>
M:	Keyur Chudgar <kchudgar@apm.com>
M:	Quan Nguyen <qnguyen@apm.com>
S:	Supported
F:	drivers/net/ethernet/apm/xgene/
F:	drivers/net/phy/mdio-xgene.c
F:	Documentation/devicetree/bindings/net/apm-xgene-enet.txt
F:	Documentation/devicetree/bindings/net/apm-xgene-mdio.txt

APPLIED MICRO (APM) X-GENE SOC PMU
M:	Tai Nguyen <ttnguyen@apm.com>
S:	Supported
F:	drivers/perf/xgene_pmu.c
F:	Documentation/perf/xgene-pmu.txt
F:	Documentation/devicetree/bindings/perf/apm-xgene-pmu.txt

APTINA CAMERA SENSOR PLL
M:	Laurent Pinchart <Laurent.pinchart@ideasonboard.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/aptina-pll.*

ARC FRAMEBUFFER DRIVER
M:	Jaya Kumar <jayalk@intworks.biz>
S:	Maintained
F:	drivers/video/fbdev/arcfb.c
F:	drivers/video/fbdev/core/fb_defio.c

ARC PGU DRM DRIVER
M:	Alexey Brodkin <abrodkin@synopsys.com>
S:	Supported
F:	drivers/gpu/drm/arc/
F:	Documentation/devicetree/bindings/display/snps,arcpgu.txt

ARCNET NETWORK LAYER
M:	Michael Grzeschik <m.grzeschik@pengutronix.de>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/arcnet/
F:	include/uapi/linux/if_arcnet.h

ARM ARCHITECTED TIMER DRIVER
M:	Mark Rutland <mark.rutland@arm.com>
M:	Marc Zyngier <marc.zyngier@arm.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/include/asm/arch_timer.h
F:	arch/arm64/include/asm/arch_timer.h
F:	drivers/clocksource/arm_arch_timer.c

ARM HDLCD DRM DRIVER
M:	Liviu Dudau <liviu.dudau@arm.com>
S:	Supported
F:	drivers/gpu/drm/arm/hdlcd_*
F:	Documentation/devicetree/bindings/display/arm,hdlcd.txt

ARM MALI-DP DRM DRIVER
M:	Liviu Dudau <liviu.dudau@arm.com>
M:	Brian Starkey <brian.starkey@arm.com>
M:	Mali DP Maintainers <malidp@foss.arm.com>
S:	Supported
F:	drivers/gpu/drm/arm/
F:	Documentation/devicetree/bindings/display/arm,malidp.txt

ARM MFM AND FLOPPY DRIVERS
M:	Ian Molton <spyro@f2s.com>
S:	Maintained
F:	arch/arm/lib/floppydma.S
F:	arch/arm/include/asm/floppy.h

ARM PMU PROFILING AND DEBUGGING
M:	Will Deacon <will.deacon@arm.com>
M:	Mark Rutland <mark.rutland@arm.com>
S:	Maintained
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
F:	arch/arm*/kernel/perf_*
F:	arch/arm/oprofile/common.c
F:	arch/arm*/kernel/hw_breakpoint.c
F:	arch/arm*/include/asm/hw_breakpoint.h
F:	arch/arm*/include/asm/perf_event.h
F:	drivers/perf/*
F:	include/linux/perf/arm_pmu.h
F:	Documentation/devicetree/bindings/arm/pmu.txt
F:	Documentation/devicetree/bindings/perf/

ARM PORT
M:	Russell King <linux@armlinux.org.uk>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.armlinux.org.uk/
S:	Odd Fixes
T:	git git://git.armlinux.org.uk/~rmk/linux-arm.git
F:	arch/arm/
X:	arch/arm/boot/dts/

ARM PRIMECELL AACI PL041 DRIVER
M:	Russell King <linux@armlinux.org.uk>
S:	Odd Fixes
F:	sound/arm/aaci.*

ARM PRIMECELL BUS SUPPORT
M:	Russell King <linux@armlinux.org.uk>
S:	Odd Fixes
F:	drivers/amba/
F:	include/linux/amba/bus.h

ARM PRIMECELL CLCD PL110 DRIVER
M:	Russell King <linux@armlinux.org.uk>
S:	Odd Fixes
F:	drivers/video/fbdev/amba-clcd.*

ARM PRIMECELL KMI PL050 DRIVER
M:	Russell King <linux@armlinux.org.uk>
S:	Odd Fixes
F:	drivers/input/serio/ambakmi.*
F:	include/linux/amba/kmi.h

ARM PRIMECELL MMCI PL180/1 DRIVER
M:	Russell King <linux@armlinux.org.uk>
S:	Odd Fixes
F:	drivers/mmc/host/mmci.*
F:	include/linux/amba/mmci.h

ARM PRIMECELL UART PL010 AND PL011 DRIVERS
M:	Russell King <linux@armlinux.org.uk>
S:	Odd Fixes
F:	drivers/tty/serial/amba-pl01*.c
F:	include/linux/amba/serial.h

ARM SMMU DRIVERS
M:	Will Deacon <will.deacon@arm.com>
R:	Robin Murphy <robin.murphy@arm.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/iommu/arm-smmu.c
F:	drivers/iommu/arm-smmu-v3.c
F:	drivers/iommu/io-pgtable-arm.c
F:	drivers/iommu/io-pgtable-arm-v7s.c

ARM SUB-ARCHITECTURES
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-*/
F:	arch/arm/plat-*/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc.git

ARM/ACTIONS SEMI ARCHITECTURE
M:	Andreas Färber <afaerber@suse.de>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
N:	owl
F:	arch/arm/mach-actions/
F:	arch/arm/boot/dts/owl-*
F:	arch/arm64/boot/dts/actions/
F:	drivers/clocksource/owl-*
F:	drivers/pinctrl/actions/*
F:	drivers/soc/actions/
F:	include/dt-bindings/power/owl-*
F:	include/linux/soc/actions/
F:	Documentation/devicetree/bindings/arm/actions.txt
F:	Documentation/devicetree/bindings/pinctrl/actions,s900-pinctrl.txt
F:	Documentation/devicetree/bindings/power/actions,owl-sps.txt
F:	Documentation/devicetree/bindings/timer/actions,owl-timer.txt

ARM/ADS SPHERE MACHINE SUPPORT
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/AFEB9260 MACHINE SUPPORT
M:	Sergey Lapin <slapin@ossfans.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/AJECO 1ARM MACHINE SUPPORT
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/Allwinner SoC Clock Support
M:	Emilio López <emilio@elopez.com.ar>
S:	Maintained
F:	drivers/clk/sunxi/

ARM/Allwinner sunXi SoC support
M:	Maxime Ripard <maxime.ripard@bootlin.com>
M:	Chen-Yu Tsai <wens@csie.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
N:	sun[x456789]i
N:	sun50i
F:	arch/arm/mach-sunxi/
F:	arch/arm64/boot/dts/allwinner/
F:	drivers/clk/sunxi-ng/
F:	drivers/pinctrl/sunxi/
F:	drivers/soc/sunxi/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sunxi/linux.git

ARM/Amlogic Meson SoC CLOCK FRAMEWORK
M:	Neil Armstrong <narmstrong@baylibre.com>
M:	Jerome Brunet <jbrunet@baylibre.com>
L:	linux-amlogic@lists.infradead.org
S:	Maintained
F:	drivers/clk/meson/
F:	include/dt-bindings/clock/meson*
F:	include/dt-bindings/clock/gxbb*
F:	Documentation/devicetree/bindings/clock/amlogic*

ARM/Amlogic Meson SoC support
M:	Carlo Caione <carlo@caione.org>
M:	Kevin Hilman <khilman@baylibre.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-amlogic@lists.infradead.org
W:	http://linux-meson.com/
S:	Maintained
F:	arch/arm/mach-meson/
F:	arch/arm/boot/dts/meson*
F:	arch/arm64/boot/dts/amlogic/
F:	drivers/pinctrl/meson/
F:	drivers/mmc/host/meson*
N:	meson

ARM/Annapurna Labs ALPINE ARCHITECTURE
M:	Tsahee Zidenberg <tsahee@annapurnalabs.com>
M:	Antoine Tenart <antoine.tenart@free-electrons.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-alpine/
F:	arch/arm/boot/dts/alpine*
F:	arch/arm64/boot/dts/al/
F:	drivers/*/*alpine*

ARM/ARTPEC MACHINE SUPPORT
M:	Jesper Nilsson <jesper.nilsson@axis.com>
M:	Lars Persson <lars.persson@axis.com>
S:	Maintained
L:	linux-arm-kernel@axis.com
F:	arch/arm/mach-artpec
F:	arch/arm/boot/dts/artpec6*
F:	drivers/clk/axis
F:	drivers/crypto/axis
F:	drivers/pinctrl/pinctrl-artpec*
F:	Documentation/devicetree/bindings/pinctrl/axis,artpec6-pinctrl.txt

ARM/ASPEED I2C DRIVER
M:	Brendan Higgins <brendanhiggins@google.com>
R:	Benjamin Herrenschmidt <benh@kernel.crashing.org>
R:	Joel Stanley <joel@jms.id.au>
L:	linux-i2c@vger.kernel.org
L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/irqchip/irq-aspeed-i2c-ic.c
F:	drivers/i2c/busses/i2c-aspeed.c
F:	Documentation/devicetree/bindings/interrupt-controller/aspeed,ast2400-i2c-ic.txt
F:	Documentation/devicetree/bindings/i2c/i2c-aspeed.txt

ARM/ASPEED MACHINE SUPPORT
M:	Joel Stanley <joel@jms.id.au>
R:	Andrew Jeffery <andrew@aj.id.au>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-aspeed@lists.ozlabs.org (moderated for non-subscribers)
Q:	https://patchwork.ozlabs.org/project/linux-aspeed/list/
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/joel/aspeed.git
F:	arch/arm/mach-aspeed/
F:	arch/arm/boot/dts/aspeed-*
N:	aspeed

ARM/ATMEL AT91 Clock Support
M:	Boris Brezillon <boris.brezillon@bootlin.com>
S:	Maintained
F:	drivers/clk/at91

ARM/CALXEDA HIGHBANK ARCHITECTURE
M:	Rob Herring <robh@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-highbank/
F:	arch/arm/boot/dts/highbank.dts
F:	arch/arm/boot/dts/ecx-*.dts*

ARM/CAVIUM NETWORKS CNS3XXX MACHINE SUPPORT
M:	Krzysztof Halasa <khalasa@piap.pl>
S:	Maintained
F:	arch/arm/mach-cns3xxx/

ARM/CAVIUM THUNDER NETWORK DRIVER
M:	Sunil Goutham <sgoutham@cavium.com>
M:	Robert Richter <rric@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	drivers/net/ethernet/cavium/thunder/

ARM/CIRRUS LOGIC BK3 MACHINE SUPPORT
M:	Lukasz Majewski <lukma@denx.de>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-ep93xx/ts72xx.c

ARM/CIRRUS LOGIC CLPS711X ARM ARCHITECTURE
M:	Alexander Shiyan <shc_work@mail.ru>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Odd Fixes
N:	clps711x

ARM/CIRRUS LOGIC EDB9315A MACHINE SUPPORT
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/CIRRUS LOGIC EP93XX ARM ARCHITECTURE
M:	Hartley Sweeten <hsweeten@visionengravers.com>
M:	Alexander Sverdlin <alexander.sverdlin@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-ep93xx/
F:	arch/arm/mach-ep93xx/include/mach/

ARM/CLKDEV SUPPORT
M:	Russell King <linux@armlinux.org.uk>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://git.armlinux.org.uk/~rmk/linux-arm.git clkdev
F:	drivers/clk/clkdev.c

ARM/COMPULAB CM-X270/EM-X270 and CM-X300 MACHINE SUPPORT
M:	Mike Rapoport <mike@compulab.co.il>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/CONEXANT DIGICOLOR MACHINE SUPPORT
M:	Baruch Siach <baruch@tkos.co.il>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/boot/dts/cx92755*
N:	digicolor

ARM/CONTEC MICRO9 MACHINE SUPPORT
M:	Hubert Feurstein <hubert.feurstein@contec.at>
S:	Maintained
F:	arch/arm/mach-ep93xx/micro9.c

ARM/CORESIGHT FRAMEWORK AND DRIVERS
M:	Mathieu Poirier <mathieu.poirier@linaro.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/hwtracing/coresight/*
F:	Documentation/trace/coresight.txt
F:	Documentation/trace/coresight-cpu-debug.txt
F:	Documentation/devicetree/bindings/arm/coresight.txt
F:	Documentation/devicetree/bindings/arm/coresight-cpu-debug.txt
F:	Documentation/ABI/testing/sysfs-bus-coresight-devices-*
F:	tools/perf/arch/arm/util/pmu.c
F:	tools/perf/arch/arm/util/auxtrace.c
F:	tools/perf/arch/arm/util/cs-etm.c
F:	tools/perf/arch/arm/util/cs-etm.h
F:	tools/perf/util/cs-etm.*
F:	tools/perf/util/cs-etm-decoder/*

ARM/CORGI MACHINE SUPPORT
M:	Richard Purdie <rpurdie@rpsys.net>
S:	Maintained

ARM/CORTINA SYSTEMS GEMINI ARM ARCHITECTURE
M:	Hans Ulli Kroll <ulli.kroll@googlemail.com>
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://github.com/ulli-kroll/linux.git
S:	Maintained
F:	Documentation/devicetree/bindings/arm/gemini.txt
F:	Documentation/devicetree/bindings/pinctrl/cortina,gemini-pinctrl.txt
F:	Documentation/devicetree/bindings/net/cortina,gemini-ethernet.txt
F:	Documentation/devicetree/bindings/rtc/faraday,ftrtc010.txt
F:	arch/arm/mach-gemini/
F:	drivers/net/ethernet/cortina/
F:	drivers/pinctrl/pinctrl-gemini.c
F:	drivers/rtc/rtc-ftrtc010.c

ARM/CSR SIRFPRIMA2 MACHINE SUPPORT
M:	Barry Song <baohua@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/baohua/linux.git
S:	Maintained
F:	arch/arm/boot/dts/prima2*
F:	arch/arm/mach-prima2/
F:	drivers/clk/sirf/
F:	drivers/clocksource/timer-prima2.c
F:	drivers/clocksource/timer-atlas7.c
N:	[^a-z]sirf

ARM/EBSA110 MACHINE SUPPORT
M:	Russell King <linux@armlinux.org.uk>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.armlinux.org.uk/
S:	Maintained
F:	arch/arm/mach-ebsa110/
F:	drivers/net/ethernet/amd/am79c961a.*

ARM/ENERGY MICRO (SILICON LABS) EFM32 SUPPORT
M:	Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
R:	Pengutronix Kernel Team <kernel@pengutronix.de>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
N:	efm32

ARM/EZX SMARTPHONES (A780, A910, A1200, E680, ROKR E2 and ROKR E6)
M:	Robert Jarzmik <robert.jarzmik@free.fr>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-pxa/ezx.c

ARM/FARADAY FA526 PORT
M:	Hans Ulli Kroll <ulli.kroll@googlemail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://git.berlios.de/gemini-board
F:	arch/arm/mm/*-fa*

ARM/FOOTBRIDGE ARCHITECTURE
M:	Russell King <linux@armlinux.org.uk>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.armlinux.org.uk/
S:	Maintained
F:	arch/arm/include/asm/hardware/dec21285.h
F:	arch/arm/mach-footbridge/

ARM/FREESCALE IMX / MXC ARM ARCHITECTURE
M:	Shawn Guo <shawnguo@kernel.org>
M:	Sascha Hauer <s.hauer@pengutronix.de>
R:	Pengutronix Kernel Team <kernel@pengutronix.de>
R:	Fabio Estevam <fabio.estevam@nxp.com>
R:	NXP Linux Team <linux-imx@nxp.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/shawnguo/linux.git
F:	arch/arm/mach-imx/
F:	arch/arm/mach-mxs/
F:	arch/arm/boot/dts/imx*
F:	arch/arm/configs/imx*_defconfig
F:	drivers/clk/imx/
F:	drivers/soc/imx/
F:	include/soc/imx/

ARM/FREESCALE VYBRID ARM ARCHITECTURE
M:	Shawn Guo <shawnguo@kernel.org>
M:	Sascha Hauer <s.hauer@pengutronix.de>
R:	Pengutronix Kernel Team <kernel@pengutronix.de>
R:	Stefan Agner <stefan@agner.ch>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/shawnguo/linux.git
F:	arch/arm/mach-imx/*vf610*
F:	arch/arm/boot/dts/vf*

ARM/GLOMATION GESBC9312SX MACHINE SUPPORT
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/GUMSTIX MACHINE SUPPORT
M:	Steve Sakoman <sakoman@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/H4700 (HP IPAQ HX4700) MACHINE SUPPORT
M:	Philipp Zabel <philipp.zabel@gmail.com>
M:	Paul Parsons <lost.distance@yahoo.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-pxa/hx4700.c
F:	arch/arm/mach-pxa/include/mach/hx4700.h
F:	sound/soc/pxa/hx4700.c

ARM/HISILICON SOC SUPPORT
M:	Wei Xu <xuwei5@hisilicon.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.hisilicon.com
S:	Supported
T:	git git://github.com/hisilicon/linux-hisi.git
F:	arch/arm/mach-hisi/
F:	arch/arm/boot/dts/hi3*
F:	arch/arm/boot/dts/hip*
F:	arch/arm/boot/dts/hisi*
F:	arch/arm64/boot/dts/hisilicon/

ARM/HP JORNADA 7XX MACHINE SUPPORT
M:	Kristoffer Ericson <kristoffer.ericson@gmail.com>
W:	www.jlime.com
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kristoffer/linux-hpc.git
F:	arch/arm/mach-sa1100/jornada720.c
F:	arch/arm/mach-sa1100/include/mach/jornada720.h

ARM/IGEP MACHINE SUPPORT
M:	Enric Balletbo i Serra <eballetbo@gmail.com>
M:	Javier Martinez Canillas <javier@dowhile0.org>
L:	linux-omap@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/boot/dts/omap3-igep*

ARM/INCOME PXA270 SUPPORT
M:	Marek Vasut <marek.vasut@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-pxa/colibri-pxa270-income.c

ARM/INTEL IOP13XX ARM ARCHITECTURE
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/INTEL IOP32X ARM ARCHITECTURE
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/INTEL IOP33X ARM ARCHITECTURE
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Orphan

ARM/INTEL IQ81342EX MACHINE SUPPORT
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/INTEL IXDP2850 MACHINE SUPPORT
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/INTEL IXP4XX ARM ARCHITECTURE
M:	Imre Kaloz <kaloz@openwrt.org>
M:	Krzysztof Halasa <khalasa@piap.pl>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-ixp4xx/

ARM/INTEL RESEARCH IMOTE/STARGATE 2 MACHINE SUPPORT
M:	Jonathan Cameron <jic23@cam.ac.uk>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-pxa/stargate2.c
F:	drivers/pcmcia/pxa2xx_stargate2.c

ARM/INTEL XSC3 (MANZANO) ARM CORE
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/IP FABRICS DOUBLE ESPRESSO MACHINE SUPPORT
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/LG1K ARCHITECTURE
M:	Chanho Min <chanho.min@lge.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm64/boot/dts/lg/

ARM/LOGICPD PXA270 MACHINE SUPPORT
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/LPC18XX ARCHITECTURE
M:	Joachim Eastwood <manabian@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/boot/dts/lpc43*
F:	drivers/clk/nxp/clk-lpc18xx*
F:	drivers/clocksource/time-lpc32xx.c
F:	drivers/i2c/busses/i2c-lpc2k.c
F:	drivers/memory/pl172.c
F:	drivers/mtd/spi-nor/nxp-spifi.c
F:	drivers/rtc/rtc-lpc24xx.c
N:	lpc18xx

ARM/LPC32XX SOC SUPPORT
M:	Vladimir Zapolskiy <vz@mleia.com>
M:	Sylvain Lemieux <slemieux.tyco@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://github.com/vzapolskiy/linux-lpc32xx.git
S:	Maintained
F:	arch/arm/boot/dts/lpc32*
F:	arch/arm/mach-lpc32xx/
F:	drivers/i2c/busses/i2c-pnx.c
F:	drivers/net/ethernet/nxp/lpc_eth.c
F:	drivers/usb/host/ohci-nxp.c
F:	drivers/watchdog/pnx4008_wdt.c
N:	lpc32xx

ARM/MAGICIAN MACHINE SUPPORT
M:	Philipp Zabel <philipp.zabel@gmail.com>
S:	Maintained

ARM/Marvell Dove/MV78xx0/Orion SOC support
M:	Jason Cooper <jason@lakedaemon.net>
M:	Andrew Lunn <andrew@lunn.ch>
M:	Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
M:	Gregory Clement <gregory.clement@bootlin.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/soc/dove/
F:	arch/arm/mach-dove/
F:	arch/arm/mach-mv78xx0/
F:	arch/arm/mach-orion5x/
F:	arch/arm/plat-orion/
F:	arch/arm/boot/dts/dove*
F:	arch/arm/boot/dts/orion5x*

ARM/Marvell Kirkwood and Armada 370, 375, 38x, 39x, XP, 3700, 7K/8K SOC support
M:	Jason Cooper <jason@lakedaemon.net>
M:	Andrew Lunn <andrew@lunn.ch>
M:	Gregory Clement <gregory.clement@bootlin.com>
M:	Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/boot/dts/armada*
F:	arch/arm/boot/dts/kirkwood*
F:	arch/arm/configs/mvebu_*_defconfig
F:	arch/arm/mach-mvebu/
F:	arch/arm64/boot/dts/marvell/armada*
F:	drivers/cpufreq/armada-37xx-cpufreq.c
F:	drivers/cpufreq/mvebu-cpufreq.c
F:	drivers/irqchip/irq-armada-370-xp.c
F:	drivers/irqchip/irq-mvebu-*
F:	drivers/pinctrl/mvebu/
F:	drivers/rtc/rtc-armada38x.c

ARM/Mediatek RTC DRIVER
M:	Eddie Huang <eddie.huang@mediatek.com>
M:	Sean Wang <sean.wang@mediatek.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/rtc/rtc-mt7622.txt
F:	drivers/rtc/rtc-mt6397.c
F:	drivers/rtc/rtc-mt7622.c

ARM/Mediatek SoC support
M:	Matthias Brugger <matthias.bgg@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/boot/dts/mt6*
F:	arch/arm/boot/dts/mt7*
F:	arch/arm/boot/dts/mt8*
F:	arch/arm/mach-mediatek/
F:	arch/arm64/boot/dts/mediatek/
N:	mtk
K:	mediatek

ARM/Mediatek USB3 PHY DRIVER
M:	Chunfeng Yun <chunfeng.yun@mediatek.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/phy/mediatek/phy-mtk-tphy.c

ARM/MICREL KS8695 ARCHITECTURE
M:	Greg Ungerer <gerg@uclinux.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
F:	arch/arm/mach-ks8695/
S:	Odd Fixes

ARM/Microchip (AT91) SoC support
M:	Nicolas Ferre <nicolas.ferre@microchip.com>
M:	Alexandre Belloni <alexandre.belloni@bootlin.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.linux4sam.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/nferre/linux-at91.git
S:	Supported
N:	at91
N:	atmel
F:	arch/arm/mach-at91/
F:	include/soc/at91/
F:	arch/arm/boot/dts/at91*.dts
F:	arch/arm/boot/dts/at91*.dtsi
F:	arch/arm/boot/dts/sama*.dts
F:	arch/arm/boot/dts/sama*.dtsi
F:	arch/arm/include/debug/at91.S
F:	drivers/memory/atmel*
F:	drivers/watchdog/sama5d4_wdt.c
X:	drivers/input/touchscreen/atmel_mxt_ts.c
X:	drivers/net/wireless/atmel/

ARM/MIOA701 MACHINE SUPPORT
M:	Robert Jarzmik <robert.jarzmik@free.fr>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
F:	arch/arm/mach-pxa/mioa701.c
S:	Maintained

ARM/NEC MOBILEPRO 900/c MACHINE SUPPORT
M:	Michael Petchkovsky <mkpetch@internode.on.net>
S:	Maintained

ARM/NOMADIK/U300/Ux500 ARCHITECTURES
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-nomadik/
F:	arch/arm/mach-u300/
F:	arch/arm/mach-ux500/
F:	arch/arm/boot/dts/ste-*
F:	drivers/clk/clk-nomadik.c
F:	drivers/clk/clk-u300.c
F:	drivers/clocksource/clksrc-dbx500-prcmu.c
F:	drivers/clocksource/timer-u300.c
F:	drivers/dma/coh901318*
F:	drivers/dma/ste_dma40*
F:	drivers/hwspinlock/u8500_hsem.c
F:	drivers/i2c/busses/i2c-nomadik.c
F:	drivers/i2c/busses/i2c-stu300.c
F:	drivers/mfd/ab3100*
F:	drivers/mfd/ab8500*
F:	drivers/mfd/abx500*
F:	drivers/mfd/dbx500*
F:	drivers/mfd/db8500*
F:	drivers/pinctrl/nomadik/
F:	drivers/pinctrl/pinctrl-coh901*
F:	drivers/pinctrl/pinctrl-u300.c
F:	drivers/rtc/rtc-ab3100.c
F:	drivers/rtc/rtc-ab8500.c
F:	drivers/rtc/rtc-coh901331.c
F:	drivers/rtc/rtc-pl031.c
F:	drivers/watchdog/coh901327_wdt.c
F:	Documentation/devicetree/bindings/arm/ste-*
F:	Documentation/devicetree/bindings/arm/ux500/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-nomadik.git

ARM/NUVOTON NPCM ARCHITECTURE
M:	Avi Fishman <avifishman70@gmail.com>
M:	Tomer Maimon <tmaimon77@gmail.com>
R:	Patrick Venture <venture@google.com>
R:	Nancy Yuen <yuenn@google.com>
R:	Brendan Higgins <brendanhiggins@google.com>
L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
S:	Supported
F:	arch/arm/mach-npcm/
F:	arch/arm/boot/dts/nuvoton-npcm*
F:	include/dt-bindings/clock/nuvoton,npcm7xx-clks.h
F:	drivers/*/*npcm*
F:	Documentation/*/*npcm*

ARM/NUVOTON W90X900 ARM ARCHITECTURE
M:	Wan ZongShun <mcuos.com@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.mcuos.com
S:	Maintained
F:	arch/arm/mach-w90x900/
F:	drivers/input/keyboard/w90p910_keypad.c
F:	drivers/input/touchscreen/w90p910_ts.c
F:	drivers/watchdog/nuc900_wdt.c
F:	drivers/net/ethernet/nuvoton/w90p910_ether.c
F:	drivers/mtd/nand/raw/nuc900_nand.c
F:	drivers/rtc/rtc-nuc900.c
F:	drivers/spi/spi-nuc900.c
F:	drivers/usb/host/ehci-w90x900.c
F:	drivers/video/fbdev/nuc900fb.c

ARM/OPENMOKO NEO FREERUNNER (GTA02) MACHINE SUPPORT
M:	Nelson Castillo <arhuaco@freaks-unidos.net>
L:	openmoko-kernel@lists.openmoko.org (subscribers-only)
W:	http://wiki.openmoko.org/wiki/Neo_FreeRunner
S:	Supported

ARM/Orion SoC/Technologic Systems TS-78xx platform support
M:	Alexander Clouter <alex@digriz.org.uk>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.digriz.org.uk/ts78xx/kernel
S:	Maintained
F:	arch/arm/mach-orion5x/ts78xx-*

ARM/OXNAS platform support
M:	Neil Armstrong <narmstrong@baylibre.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-oxnas@groups.io (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-oxnas/
F:	arch/arm/boot/dts/ox8*.dts*
N:	oxnas

ARM/PALM TREO SUPPORT
M:	Tomas Cech <sleep_walker@suse.com>
L:	linux-arm-kernel@lists.infradead.org
W:	http://hackndev.com
S:	Maintained
F:	arch/arm/mach-pxa/palmtreo.*

ARM/PALMTX,PALMT5,PALMLD,PALMTE2,PALMTC SUPPORT
M:	Marek Vasut <marek.vasut@gmail.com>
L:	linux-arm-kernel@lists.infradead.org
W:	http://hackndev.com
S:	Maintained
F:	arch/arm/mach-pxa/include/mach/palmtx.h
F:	arch/arm/mach-pxa/palmtx.c
F:	arch/arm/mach-pxa/palmt5.*
F:	arch/arm/mach-pxa/include/mach/palmld.h
F:	arch/arm/mach-pxa/palmld.c
F:	arch/arm/mach-pxa/palmte2.*
F:	arch/arm/mach-pxa/include/mach/palmtc.h
F:	arch/arm/mach-pxa/palmtc.c

ARM/PALMZ72 SUPPORT
M:	Sergey Lapin <slapin@ossfans.org>
L:	linux-arm-kernel@lists.infradead.org
W:	http://hackndev.com
S:	Maintained
F:	arch/arm/mach-pxa/palmz72.*

ARM/PLEB SUPPORT
M:	Peter Chubb <pleb@gelato.unsw.edu.au>
W:	http://www.disy.cse.unsw.edu.au/Hardware/PLEB
S:	Maintained

ARM/PT DIGITAL BOARD PORT
M:	Stefan Eletzhofer <stefan.eletzhofer@eletztrick.de>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.armlinux.org.uk/
S:	Maintained

ARM/QUALCOMM SUPPORT
M:	Andy Gross <andy.gross@linaro.org>
M:	David Brown <david.brown@linaro.org>
L:	linux-arm-msm@vger.kernel.org
L:	linux-soc@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/soc/qcom/
F:	arch/arm/boot/dts/qcom-*.dts
F:	arch/arm/boot/dts/qcom-*.dtsi
F:	arch/arm/mach-qcom/
F:	arch/arm64/boot/dts/qcom/*
F:	drivers/i2c/busses/i2c-qup.c
F:	drivers/clk/qcom/
F:	drivers/dma/qcom/
F:	drivers/soc/qcom/
F:	drivers/spi/spi-qup.c
F:	drivers/tty/serial/msm_serial.c
F:	drivers/*/pm8???-*
F:	drivers/mfd/ssbi.c
F:	drivers/firmware/qcom_scm*
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/agross/linux.git

ARM/RADISYS ENP2611 MACHINE SUPPORT
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/REALTEK ARCHITECTURE
M:	Andreas Färber <afaerber@suse.de>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm64/boot/dts/realtek/
F:	Documentation/devicetree/bindings/arm/realtek.txt

ARM/RENESAS ARM64 ARCHITECTURE
M:	Simon Horman <horms@verge.net.au>
M:	Magnus Damm <magnus.damm@gmail.com>
L:	linux-renesas-soc@vger.kernel.org
Q:	http://patchwork.kernel.org/project/linux-renesas-soc/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/horms/renesas.git next
S:	Supported
F:	arch/arm64/boot/dts/renesas/
F:	Documentation/devicetree/bindings/arm/shmobile.txt
F:	drivers/soc/renesas/
F:	include/linux/soc/renesas/

ARM/RISCPC ARCHITECTURE
M:	Russell King <linux@armlinux.org.uk>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.armlinux.org.uk/
S:	Maintained
F:	arch/arm/include/asm/hardware/entry-macro-iomd.S
F:	arch/arm/include/asm/hardware/ioc.h
F:	arch/arm/include/asm/hardware/iomd.h
F:	arch/arm/include/asm/hardware/memc.h
F:	arch/arm/mach-rpc/
F:	drivers/net/ethernet/8390/etherh.c
F:	drivers/net/ethernet/i825xx/ether1*
F:	drivers/net/ethernet/seeq/ether3*
F:	drivers/scsi/arm/

ARM/Rockchip SoC support
M:	Heiko Stuebner <heiko@sntech.de>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-rockchip@lists.infradead.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mmind/linux-rockchip.git
S:	Maintained
F:	arch/arm/boot/dts/rk3*
F:	arch/arm/boot/dts/rv1108*
F:	arch/arm/mach-rockchip/
F:	drivers/clk/rockchip/
F:	drivers/i2c/busses/i2c-rk3x.c
F:	drivers/*/*rockchip*
F:	drivers/*/*/*rockchip*
F:	sound/soc/rockchip/
N:	rockchip

ARM/SAMSUNG EXYNOS ARM ARCHITECTURES
M:	Kukjin Kim <kgene@kernel.org>
M:	Krzysztof Kozlowski <krzk@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-samsung-soc@vger.kernel.org (moderated for non-subscribers)
Q:	https://patchwork.kernel.org/project/linux-samsung-soc/list/
S:	Maintained
F:	arch/arm/boot/dts/s3c*
F:	arch/arm/boot/dts/s5p*
F:	arch/arm/boot/dts/exynos*
F:	arch/arm64/boot/dts/exynos/
F:	arch/arm/plat-samsung/
F:	arch/arm/mach-s3c24*/
F:	arch/arm/mach-s3c64xx/
F:	arch/arm/mach-s5p*/
F:	arch/arm/mach-exynos*/
F:	drivers/*/*s3c24*
F:	drivers/*/*/*s3c24*
F:	drivers/*/*s3c64xx*
F:	drivers/*/*s5pv210*
F:	drivers/memory/samsung/*
F:	drivers/soc/samsung/*
F:	Documentation/arm/Samsung/
F:	Documentation/devicetree/bindings/arm/samsung/
F:	Documentation/devicetree/bindings/sram/samsung-sram.txt
F:	Documentation/devicetree/bindings/power/pd-samsung.txt
N:	exynos

ARM/SAMSUNG MOBILE MACHINE SUPPORT
M:	Kyungmin Park <kyungmin.park@samsung.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-s5pv210/

ARM/SAMSUNG S5P SERIES 2D GRAPHICS ACCELERATION (G2D) SUPPORT
M:	Kyungmin Park <kyungmin.park@samsung.com>
M:	Kamil Debski <kamil@wypas.org>
M:	Andrzej Hajda <a.hajda@samsung.com>
L:	linux-arm-kernel@lists.infradead.org
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/platform/s5p-g2d/

ARM/SAMSUNG S5P SERIES HDMI CEC SUBSYSTEM SUPPORT
M:	Marek Szyprowski <m.szyprowski@samsung.com>
L:	linux-samsung-soc@vger.kernel.org (moderated for non-subscribers)
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/platform/s5p-cec/
F:	Documentation/devicetree/bindings/media/s5p-cec.txt

ARM/SAMSUNG S5P SERIES JPEG CODEC SUPPORT
M:	Andrzej Pietrasiewicz <andrzej.p@samsung.com>
M:	Jacek Anaszewski <jacek.anaszewski@gmail.com>
L:	linux-arm-kernel@lists.infradead.org
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/platform/s5p-jpeg/

ARM/SAMSUNG S5P SERIES Multi Format Codec (MFC) SUPPORT
M:	Kyungmin Park <kyungmin.park@samsung.com>
M:	Kamil Debski <kamil@wypas.org>
M:	Jeongtae Park <jtp.park@samsung.com>
M:	Andrzej Hajda <a.hajda@samsung.com>
L:	linux-arm-kernel@lists.infradead.org
L:	linux-media@vger.kernel.org
S:	Maintained
F:	arch/arm/plat-samsung/s5p-dev-mfc.c
F:	drivers/media/platform/s5p-mfc/

ARM/SHMOBILE ARM ARCHITECTURE
M:	Simon Horman <horms@verge.net.au>
M:	Magnus Damm <magnus.damm@gmail.com>
L:	linux-renesas-soc@vger.kernel.org
Q:	http://patchwork.kernel.org/project/linux-renesas-soc/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/horms/renesas.git next
S:	Supported
F:	arch/arm/boot/dts/emev2*
F:	arch/arm/boot/dts/r7s*
F:	arch/arm/boot/dts/r8a*
F:	arch/arm/boot/dts/sh*
F:	arch/arm/configs/shmobile_defconfig
F:	arch/arm/include/debug/renesas-scif.S
F:	arch/arm/mach-shmobile/
F:	Documentation/devicetree/bindings/arm/shmobile.txt
F:	drivers/soc/renesas/
F:	include/linux/soc/renesas/

ARM/SOCFPGA ARCHITECTURE
M:	Dinh Nguyen <dinguyen@kernel.org>
S:	Maintained
F:	arch/arm/mach-socfpga/
F:	arch/arm/boot/dts/socfpga*
F:	arch/arm/configs/socfpga_defconfig
F:	arch/arm64/boot/dts/altera/
W:	http://www.rocketboards.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/dinguyen/linux.git

ARM/SOCFPGA CLOCK FRAMEWORK SUPPORT
M:	Dinh Nguyen <dinguyen@kernel.org>
S:	Maintained
F:	drivers/clk/socfpga/

ARM/SOCFPGA EDAC SUPPORT
M:	Thor Thayer <thor.thayer@linux.intel.com>
S:	Maintained
F:	drivers/edac/altera_edac.

ARM/SPREADTRUM SoC SUPPORT
M:	Orson Zhai <orsonzhai@gmail.com>
M:	Baolin Wang <baolin.wang@linaro.org>
M:	Chunyan Zhang <zhang.lyra@gmail.com>
S:	Maintained
F:	arch/arm64/boot/dts/sprd
N:	sprd

ARM/STI ARCHITECTURE
M:	Patrice Chotard <patrice.chotard@st.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.stlinux.com
S:	Maintained
F:	arch/arm/mach-sti/
F:	arch/arm/boot/dts/sti*
F:	drivers/char/hw_random/st-rng.c
F:	drivers/clocksource/arm_global_timer.c
F:	drivers/clocksource/clksrc_st_lpc.c
F:	drivers/cpufreq/sti-cpufreq.c
F:	drivers/dma/st_fdma*
F:	drivers/i2c/busses/i2c-st.c
F:	drivers/media/rc/st_rc.c
F:	drivers/media/platform/sti/c8sectpfe/
F:	drivers/mmc/host/sdhci-st.c
F:	drivers/phy/st/phy-miphy28lp.c
F:	drivers/phy/st/phy-stih407-usb.c
F:	drivers/pinctrl/pinctrl-st.c
F:	drivers/remoteproc/st_remoteproc.c
F:	drivers/remoteproc/st_slim_rproc.c
F:	drivers/reset/sti/
F:	drivers/rtc/rtc-st-lpc.c
F:	drivers/tty/serial/st-asc.c
F:	drivers/usb/dwc3/dwc3-st.c
F:	drivers/usb/host/ehci-st.c
F:	drivers/usb/host/ohci-st.c
F:	drivers/watchdog/st_lpc_wdt.c
F:	drivers/ata/ahci_st.c
F:	include/linux/remoteproc/st_slim_rproc.h

ARM/STM32 ARCHITECTURE
M:	Maxime Coquelin <mcoquelin.stm32@gmail.com>
M:	Alexandre Torgue <alexandre.torgue@st.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/atorgue/stm32.git stm32-next
N:	stm32
F:	arch/arm/boot/dts/stm32*
F:	arch/arm/mach-stm32/
F:	drivers/clocksource/armv7m_systick.c

ARM/Synaptics Berlin SoC support
M:	Jisheng Zhang <Jisheng.Zhang@synaptics.com>
M:	Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-berlin/
F:	arch/arm/boot/dts/berlin*
F:	arch/arm64/boot/dts/marvell/berlin*

ARM/TANGO ARCHITECTURE
M:	Marc Gonzalez <marc.w.gonzalez@free.fr>
M:	Mans Rullgard <mans@mansr.com>
L:	linux-arm-kernel@lists.infradead.org
S:	Odd Fixes
N:	tango

ARM/TECHNOLOGIC SYSTEMS TS7250 MACHINE SUPPORT
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/TEGRA HDMI CEC SUBSYSTEM SUPPORT
M:	Hans Verkuil <hans.verkuil@cisco.com>
L:	linux-tegra@vger.kernel.org
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/platform/tegra-cec/
F:	Documentation/devicetree/bindings/media/tegra-cec.txt

ARM/TETON BGA MACHINE SUPPORT
M:	"Mark F. Brown" <mark.brown314@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/TEXAS INSTRUMENT AEMIF/EMIF DRIVERS
M:	Santosh Shilimkar <ssantosh@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/memory/*emif*

ARM/TEXAS INSTRUMENT KEYSTONE ARCHITECTURE
M:	Santosh Shilimkar <ssantosh@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-keystone/
F:	arch/arm/boot/dts/keystone-*
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ssantosh/linux-keystone.git

ARM/TEXAS INSTRUMENT KEYSTONE CLOCK FRAMEWORK
M:	Santosh Shilimkar <ssantosh@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/clk/keystone/

ARM/TEXAS INSTRUMENT KEYSTONE ClOCKSOURCE
M:	Santosh Shilimkar <ssantosh@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/clocksource/timer-keystone.c

ARM/TEXAS INSTRUMENT KEYSTONE RESET DRIVER
M:	Santosh Shilimkar <ssantosh@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/power/reset/keystone-reset.c

ARM/THECUS N2100 MACHINE SUPPORT
M:	Lennert Buytenhek <kernel@wantstofly.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained

ARM/TOSA MACHINE SUPPORT
M:	Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
M:	Dirk Opfer <dirk@opfer-online.de>
S:	Maintained

ARM/UNIPHIER ARCHITECTURE
M:	Masahiro Yamada <yamada.masahiro@socionext.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-uniphier.git
S:	Maintained
F:	Documentation/devicetree/bindings/gpio/gpio-uniphier.txt
F:	Documentation/devicetree/bindings/pinctrl/socionext,uniphier-pinctrl.txt
F:	arch/arm/boot/dts/uniphier*
F:	arch/arm/include/asm/hardware/cache-uniphier.h
F:	arch/arm/mach-uniphier/
F:	arch/arm/mm/cache-uniphier.c
F:	arch/arm64/boot/dts/socionext/uniphier*
F:	drivers/bus/uniphier-system-bus.c
F:	drivers/clk/uniphier/
F:	drivers/gpio/gpio-uniphier.c
F:	drivers/i2c/busses/i2c-uniphier*
F:	drivers/irqchip/irq-uniphier-aidet.c
F:	drivers/pinctrl/uniphier/
F:	drivers/reset/reset-uniphier.c
F:	drivers/tty/serial/8250/8250_uniphier.c
N:	uniphier

ARM/Ux500 CLOCK FRAMEWORK SUPPORT
M:	Ulf Hansson <ulf.hansson@linaro.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://git.linaro.org/people/ulfh/clk.git
S:	Maintained
F:	drivers/clk/ux500/

ARM/VERSATILE EXPRESS PLATFORM
M:	Liviu Dudau <liviu.dudau@arm.com>
M:	Sudeep Holla <sudeep.holla@arm.com>
M:	Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/boot/dts/vexpress*
F:	arch/arm64/boot/dts/arm/
F:	arch/arm/mach-vexpress/
F:	*/*/vexpress*
F:	*/*/*/vexpress*
F:	drivers/clk/versatile/clk-vexpress-osc.c
F:	drivers/clocksource/versatile.c
N:	mps2

ARM/VFP SUPPORT
M:	Russell King <linux@armlinux.org.uk>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.armlinux.org.uk/
S:	Maintained
F:	arch/arm/vfp/

ARM/VOIPAC PXA270 SUPPORT
M:	Marek Vasut <marek.vasut@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-pxa/vpac270.c
F:	arch/arm/mach-pxa/include/mach/vpac270.h

ARM/VT8500 ARM ARCHITECTURE
M:	Tony Prisk <linux@prisktech.co.nz>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-vt8500/
F:	drivers/clocksource/vt8500_timer.c
F:	drivers/i2c/busses/i2c-wmt.c
F:	drivers/mmc/host/wmt-sdmmc.c
F:	drivers/pwm/pwm-vt8500.c
F:	drivers/rtc/rtc-vt8500.c
F:	drivers/tty/serial/vt8500_serial.c
F:	drivers/usb/host/ehci-platform.c
F:	drivers/usb/host/uhci-platform.c
F:	drivers/video/fbdev/vt8500lcdfb.*
F:	drivers/video/fbdev/wm8505fb*
F:	drivers/video/fbdev/wmt_ge_rops.*

ARM/ZIPIT Z2 SUPPORT
M:	Marek Vasut <marek.vasut@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/mach-pxa/z2.c
F:	arch/arm/mach-pxa/include/mach/z2.h

ARM/ZTE ARCHITECTURE
M:	Jun Nie <jun.nie@linaro.org>
M:	Baoyou Xie <baoyou.xie@linaro.org>
M:	Shawn Guo <shawnguo@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/boot/dts/zx2967*
F:	arch/arm/mach-zx/
F:	arch/arm64/boot/dts/zte/
F:	drivers/clk/zte/
F:	drivers/dma/zx_dma.c
F:	drivers/gpio/gpio-zx.c
F:	drivers/i2c/busses/i2c-zx2967.c
F:	drivers/mmc/host/dw_mmc-zx.*
F:	drivers/pinctrl/zte/
F:	drivers/soc/zte/
F:	drivers/thermal/zx2967_thermal.c
F:	drivers/watchdog/zx2967_wdt.c
F:	Documentation/devicetree/bindings/arm/zte.txt
F:	Documentation/devicetree/bindings/clock/zx2967*.txt
F:	Documentation/devicetree/bindings/dma/zxdma.txt
F:	Documentation/devicetree/bindings/gpio/zx296702-gpio.txt
F:	Documentation/devicetree/bindings/i2c/i2c-zx2967.txt
F:	Documentation/devicetree/bindings/mmc/zx-dw-mshc.txt
F:	Documentation/devicetree/bindings/pinctrl/pinctrl-zx.txt
F:	Documentation/devicetree/bindings/reset/zte,zx2967-reset.txt
F:	Documentation/devicetree/bindings/soc/zte/
F:	Documentation/devicetree/bindings/sound/zte,*.txt
F:	Documentation/devicetree/bindings/thermal/zx2967-thermal.txt
F:	Documentation/devicetree/bindings/watchdog/zte,zx2967-wdt.txt
F:	include/dt-bindings/clock/zx2967*.h
F:	include/dt-bindings/soc/zte,*.h
F:	sound/soc/codecs/zx_aud96p22.c
F:	sound/soc/zte/

ARM/ZYNQ ARCHITECTURE
M:	Michal Simek <michal.simek@xilinx.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://wiki.xilinx.com
T:	git https://github.com/Xilinx/linux-xlnx.git
S:	Supported
F:	arch/arm/mach-zynq/
F:	drivers/cpuidle/cpuidle-zynq.c
F:	drivers/block/xsysace.c
N:	zynq
N:	xilinx
F:	drivers/clocksource/cadence_ttc_timer.c
F:	drivers/i2c/busses/i2c-cadence.c
F:	drivers/mmc/host/sdhci-of-arasan.c
F:	drivers/edac/synopsys_edac.c

ARM64 PORT (AARCH64 ARCHITECTURE)
M:	Catalin Marinas <catalin.marinas@arm.com>
M:	Will Deacon <will.deacon@arm.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/arm64/linux.git
S:	Maintained
F:	arch/arm64/
F:	Documentation/arm64/

AS3645A LED FLASH CONTROLLER DRIVER
M:	Sakari Ailus <sakari.ailus@iki.fi>
L:	linux-leds@vger.kernel.org
S:	Maintained
F:	drivers/leds/leds-as3645a.c

ASAHI KASEI AK8974 DRIVER
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-iio@vger.kernel.org
W:	http://www.akm.com/
S:	Supported
F:	drivers/iio/magnetometer/ak8974.c

ASC7621 HARDWARE MONITOR DRIVER
M:	George Joseph <george.joseph@fairview5.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/asc7621
F:	drivers/hwmon/asc7621.c

ASUS NOTEBOOKS AND EEEPC ACPI/WMI EXTRAS DRIVERS
M:	Corentin Chary <corentin.chary@gmail.com>
L:	acpi4asus-user@lists.sourceforge.net
L:	platform-driver-x86@vger.kernel.org
W:	http://acpi4asus.sf.net
S:	Maintained
F:	drivers/platform/x86/asus*.c
F:	drivers/platform/x86/eeepc*.c

ASUS WIRELESS RADIO CONTROL DRIVER
M:	João Paulo Rechi Vita <jprvita@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/asus-wireless.c

ASYMMETRIC KEYS
M:	David Howells <dhowells@redhat.com>
L:	keyrings@vger.kernel.org
S:	Maintained
F:	Documentation/crypto/asymmetric-keys.txt
F:	include/linux/verification.h
F:	include/crypto/public_key.h
F:	include/crypto/pkcs7.h
F:	crypto/asymmetric_keys/

ASYNCHRONOUS TRANSFERS/TRANSFORMS (IOAT) API
R:	Dan Williams <dan.j.williams@intel.com>
W:	http://sourceforge.net/projects/xscaleiop
S:	Odd fixes
F:	Documentation/crypto/async-tx-api.txt
F:	crypto/async_tx/
F:	drivers/dma/
F:	include/linux/dmaengine.h
F:	include/linux/async_tx.h

AT24 EEPROM DRIVER
M:	Bartosz Golaszewski <brgl@bgdev.pl>
L:	linux-i2c@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/brgl/linux.git
S:	Maintained
F:	Documentation/devicetree/bindings/eeprom/at24.txt
F:	drivers/misc/eeprom/at24.c
F:	include/linux/platform_data/at24.h

ATA OVER ETHERNET (AOE) DRIVER
M:	"Ed L. Cashin" <ed.cashin@acm.org>
W:	http://www.openaoe.org/
S:	Supported
F:	Documentation/aoe/
F:	drivers/block/aoe/

ATHEROS 71XX/9XXX GPIO DRIVER
M:	Alban Bedel <albeu@free.fr>
W:	https://github.com/AlbanBedel/linux
T:	git git://github.com/AlbanBedel/linux
S:	Maintained
F:	drivers/gpio/gpio-ath79.c
F:	Documentation/devicetree/bindings/gpio/gpio-ath79.txt

ATHEROS 71XX/9XXX USB PHY DRIVER
M:	Alban Bedel <albeu@free.fr>
W:	https://github.com/AlbanBedel/linux
T:	git git://github.com/AlbanBedel/linux
S:	Maintained
F:	drivers/phy/qualcomm/phy-ath79-usb.c
F:	Documentation/devicetree/bindings/phy/phy-ath79-usb.txt

ATHEROS ATH GENERIC UTILITIES
M:	Kalle Valo <kvalo@codeaurora.org>
L:	linux-wireless@vger.kernel.org
S:	Supported
F:	drivers/net/wireless/ath/*

ATHEROS ATH5K WIRELESS DRIVER
M:	Jiri Slaby <jirislaby@gmail.com>
M:	Nick Kossifidis <mickflemm@gmail.com>
M:	"Luis R. Rodriguez" <mcgrof@do-not-panic.com>
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/en/users/Drivers/ath5k
S:	Maintained
F:	drivers/net/wireless/ath/ath5k/

ATHEROS ATH6KL WIRELESS DRIVER
M:	Kalle Valo <kvalo@codeaurora.org>
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/en/users/Drivers/ath6kl
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git
S:	Supported
F:	drivers/net/wireless/ath/ath6kl/

ATI_REMOTE2 DRIVER
M:	Ville Syrjala <syrjala@sci.fi>
S:	Maintained
F:	drivers/input/misc/ati_remote2.c

ATK0110 HWMON DRIVER
M:	Luca Tettamanti <kronos.it@gmail.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/asus_atk0110.c

ATLX ETHERNET DRIVERS
M:	Jay Cliburn <jcliburn@gmail.com>
M:	Chris Snook <chris.snook@gmail.com>
L:	netdev@vger.kernel.org
W:	http://sourceforge.net/projects/atl1
W:	http://atl1.sourceforge.net
S:	Maintained
F:	drivers/net/ethernet/atheros/

ATM
M:	Chas Williams <3chas3@gmail.com>
L:	linux-atm-general@lists.sourceforge.net (moderated for non-subscribers)
L:	netdev@vger.kernel.org
W:	http://linux-atm.sourceforge.net
S:	Maintained
F:	drivers/atm/
F:	include/linux/atm*
F:	include/uapi/linux/atm*

ATMEL AT91 / AT32 MCI DRIVER
M:	Ludovic Desroches <ludovic.desroches@microchip.com>
S:	Maintained
F:	drivers/mmc/host/atmel-mci.c

ATMEL AT91 SAMA5D2-Compatible Shutdown Controller
M:	Nicolas Ferre <nicolas.ferre@microchip.com>
S:	Supported
F:	drivers/power/reset/at91-sama5d2_shdwc.c

ATMEL Audio ALSA driver
M:	Nicolas Ferre <nicolas.ferre@microchip.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Supported
F:	sound/soc/atmel

ATMEL I2C DRIVER
M:	Ludovic Desroches <ludovic.desroches@microchip.com>
L:	linux-i2c@vger.kernel.org
S:	Supported
F:	drivers/i2c/busses/i2c-at91.c

ATMEL ISI DRIVER
M:	Ludovic Desroches <ludovic.desroches@microchip.com>
L:	linux-media@vger.kernel.org
S:	Supported
F:	drivers/media/platform/atmel/atmel-isi.c
F:	include/media/atmel-isi.h

ATMEL LCDFB DRIVER
M:	Nicolas Ferre <nicolas.ferre@microchip.com>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	drivers/video/fbdev/atmel_lcdfb.c
F:	include/video/atmel_lcdc.h

ATMEL MACB ETHERNET DRIVER
M:	Nicolas Ferre <nicolas.ferre@microchip.com>
S:	Supported
F:	drivers/net/ethernet/cadence/

ATMEL MAXTOUCH DRIVER
M:	Nick Dyer <nick@shmanahar.org>
T:	git git://github.com/ndyer/linux.git
S:	Maintained
F:	Documentation/devicetree/bindings/input/atmel,maxtouch.txt
F:	drivers/input/touchscreen/atmel_mxt_ts.c

ATMEL SAMA5D2 ADC DRIVER
M:	Ludovic Desroches <ludovic.desroches@microchip.com>
L:	linux-iio@vger.kernel.org
S:	Supported
F:	drivers/iio/adc/at91-sama5d2_adc.c

ATMEL SDMMC DRIVER
M:	Ludovic Desroches <ludovic.desroches@microchip.com>
L:	linux-mmc@vger.kernel.org
S:	Supported
F:	drivers/mmc/host/sdhci-of-at91.c

ATMEL SPI DRIVER
M:	Nicolas Ferre <nicolas.ferre@microchip.com>
S:	Supported
F:	drivers/spi/spi-atmel.*

ATMEL SSC DRIVER
M:	Nicolas Ferre <nicolas.ferre@microchip.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	drivers/misc/atmel-ssc.c
F:	include/linux/atmel-ssc.h

ATMEL Timer Counter (TC) AND CLOCKSOURCE DRIVERS
M:	Nicolas Ferre <nicolas.ferre@microchip.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	drivers/misc/atmel_tclib.c
F:	drivers/clocksource/tcb_clksrc.c

ATMEL USBA UDC DRIVER
M:	Nicolas Ferre <nicolas.ferre@microchip.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	drivers/usb/gadget/udc/atmel_usba_udc.*

ATMEL WIRELESS DRIVER
M:	Simon Kelley <simon@thekelleys.org.uk>
L:	linux-wireless@vger.kernel.org
W:	http://www.thekelleys.org.uk/atmel
W:	http://atmelwlandriver.sourceforge.net/
S:	Maintained
F:	drivers/net/wireless/atmel/atmel*

ATMEL XDMA DRIVER
M:	Ludovic Desroches <ludovic.desroches@microchip.com>
L:	linux-arm-kernel@lists.infradead.org
L:	dmaengine@vger.kernel.org
S:	Supported
F:	drivers/dma/at_xdmac.c

ATOMIC INFRASTRUCTURE
M:	Will Deacon <will.deacon@arm.com>
M:	Peter Zijlstra <peterz@infradead.org>
R:	Boqun Feng <boqun.feng@gmail.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	arch/*/include/asm/atomic*.h
F:	include/*/atomic*.h

ATTO EXPRESSSAS SAS/SATA RAID SCSI DRIVER
M:	Bradley Grove <linuxdrivers@attotech.com>
L:	linux-scsi@vger.kernel.org
W:	http://www.attotech.com
S:	Supported
F:	drivers/scsi/esas2r

ATUSB IEEE 802.15.4 RADIO DRIVER
M:	Stefan Schmidt <stefan@osg.samsung.com>
L:	linux-wpan@vger.kernel.org
S:	Maintained
F:	drivers/net/ieee802154/atusb.c
F:	drivers/net/ieee802154/atusb.h
F:	drivers/net/ieee802154/at86rf230.h

AUDIT SUBSYSTEM
M:	Paul Moore <paul@paul-moore.com>
M:	Eric Paris <eparis@redhat.com>
L:	linux-audit@redhat.com (moderated for non-subscribers)
W:	https://github.com/linux-audit
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pcmoore/audit.git
S:	Supported
F:	include/linux/audit.h
F:	include/uapi/linux/audit.h
F:	kernel/audit*

AUXILIARY DISPLAY DRIVERS
M:	Miguel Ojeda Sandonis <miguel.ojeda.sandonis@gmail.com>
S:	Maintained
F:	drivers/auxdisplay/
F:	include/linux/cfag12864b.h

AX.25 NETWORK LAYER
M:	Ralf Baechle <ralf@linux-mips.org>
L:	linux-hams@vger.kernel.org
W:	http://www.linux-ax25.org/
S:	Maintained
F:	include/uapi/linux/ax25.h
F:	include/net/ax25.h
F:	net/ax25/

AXENTIA ARM DEVICES
M:	Peter Rosin <peda@axentia.se>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/arm/axentia.txt
F:	arch/arm/boot/dts/at91-linea.dtsi
F:	arch/arm/boot/dts/at91-natte.dtsi
F:	arch/arm/boot/dts/at91-nattis-2-natte-2.dts
F:	arch/arm/boot/dts/at91-tse850-3.dts

AXENTIA ASOC DRIVERS
M:	Peter Rosin <peda@axentia.se>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/sound/axentia,*
F:	sound/soc/atmel/tse850-pcm5142.c

AZ6007 DVB DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/usb/dvb-usb-v2/az6007.c

AZTECH FM RADIO RECEIVER DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/radio/radio-aztech*

B43 WIRELESS DRIVER
L:	linux-wireless@vger.kernel.org
L:	b43-dev@lists.infradead.org
W:	http://wireless.kernel.org/en/users/Drivers/b43
S:	Odd Fixes
F:	drivers/net/wireless/broadcom/b43/

B43LEGACY WIRELESS DRIVER
M:	Larry Finger <Larry.Finger@lwfinger.net>
L:	linux-wireless@vger.kernel.org
L:	b43-dev@lists.infradead.org
W:	http://wireless.kernel.org/en/users/Drivers/b43
S:	Maintained
F:	drivers/net/wireless/broadcom/b43legacy/

BACKLIGHT CLASS/SUBSYSTEM
M:	Lee Jones <lee.jones@linaro.org>
M:	Daniel Thompson <daniel.thompson@linaro.org>
M:	Jingoo Han <jingoohan1@gmail.com>
L:	dri-devel@lists.freedesktop.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lee/backlight.git
S:	Maintained
F:	drivers/video/backlight/
F:	include/linux/backlight.h
F:	include/linux/pwm_backlight.h
F:	Documentation/devicetree/bindings/leds/backlight

BATMAN ADVANCED
M:	Marek Lindner <mareklindner@neomailbox.ch>
M:	Simon Wunderlich <sw@simonwunderlich.de>
M:	Antonio Quartulli <a@unstable.cc>
L:	b.a.t.m.a.n@lists.open-mesh.org (moderated for non-subscribers)
W:	https://www.open-mesh.org/
Q:	https://patchwork.open-mesh.org/project/batman/list/
S:	Maintained
F:	Documentation/ABI/testing/sysfs-class-net-batman-adv
F:	Documentation/ABI/testing/sysfs-class-net-mesh
F:	Documentation/networking/batman-adv.rst
F:	include/uapi/linux/batadv_packet.h
F:	include/uapi/linux/batman_adv.h
F:	net/batman-adv/

BAYCOM/HDLCDRV DRIVERS FOR AX.25
M:	Thomas Sailer <t.sailer@alumni.ethz.ch>
L:	linux-hams@vger.kernel.org
W:	http://www.baycom.org/~tom/ham/ham.html
S:	Maintained
F:	drivers/net/hamradio/baycom*

BCACHE (BLOCK LAYER CACHE)
M:	Coly Li <colyli@suse.de>
M:	Kent Overstreet <kent.overstreet@gmail.com>
L:	linux-bcache@vger.kernel.org
W:	http://bcache.evilpiepirate.org
C:	irc://irc.oftc.net/bcache
S:	Maintained
F:	drivers/md/bcache/

BDISP ST MEDIA DRIVER
M:	Fabien Dessenne <fabien.dessenne@st.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Supported
F:	drivers/media/platform/sti/bdisp

BECKHOFF CX5020 ETHERCAT MASTER DRIVER
M:	Dariusz Marcinkiewicz <reksio@newterm.pl>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/ec_bhf.c

BEFS FILE SYSTEM
M:	Luis de Bethencourt <luisbg@kernel.org>
M:	Salah Triki <salah.triki@gmail.com>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/luisbg/linux-befs.git
F:	Documentation/filesystems/befs.txt
F:	fs/befs/

BFQ I/O SCHEDULER
M:	Paolo Valente <paolo.valente@linaro.org>
M:	Jens Axboe <axboe@kernel.dk>
L:	linux-block@vger.kernel.org
S:	Maintained
F:	block/bfq-*
F:	Documentation/block/bfq-iosched.txt

BFS FILE SYSTEM
M:	"Tigran A. Aivazian" <aivazian.tigran@gmail.com>
S:	Maintained
F:	Documentation/filesystems/bfs.txt
F:	fs/bfs/
F:	include/uapi/linux/bfs_fs.h

BLINKM RGB LED DRIVER
M:	Jan-Simon Moeller <jansimon.moeller@gmx.de>
S:	Maintained
F:	drivers/leds/leds-blinkm.c

BLOCK LAYER
M:	Jens Axboe <axboe@kernel.dk>
L:	linux-block@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git
S:	Maintained
F:	block/
F:	drivers/block/
F:	kernel/trace/blktrace.c
F:	lib/sbitmap.c

BLOCK2MTD DRIVER
M:	Joern Engel <joern@lazybastard.org>
L:	linux-mtd@lists.infradead.org
S:	Maintained
F:	drivers/mtd/devices/block2mtd.c

BLUETOOTH DRIVERS
M:	Marcel Holtmann <marcel@holtmann.org>
M:	Johan Hedberg <johan.hedberg@gmail.com>
L:	linux-bluetooth@vger.kernel.org
W:	http://www.bluez.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git
S:	Maintained
F:	drivers/bluetooth/

BLUETOOTH SUBSYSTEM
M:	Marcel Holtmann <marcel@holtmann.org>
M:	Johan Hedberg <johan.hedberg@gmail.com>
L:	linux-bluetooth@vger.kernel.org
W:	http://www.bluez.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git
S:	Maintained
F:	net/bluetooth/
F:	include/net/bluetooth/

BONDING DRIVER
M:	Jay Vosburgh <j.vosburgh@gmail.com>
M:	Veaceslav Falico <vfalico@gmail.com>
M:	Andy Gospodarek <andy@greyhouse.net>
L:	netdev@vger.kernel.org
W:	http://sourceforge.net/projects/bonding/
S:	Supported
F:	drivers/net/bonding/
F:	include/uapi/linux/if_bonding.h

BPF (Safe dynamic programs and tools)
M:	Alexei Starovoitov <ast@kernel.org>
M:	Daniel Borkmann <daniel@iogearbox.net>
L:	netdev@vger.kernel.org
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git
Q:	https://patchwork.ozlabs.org/project/netdev/list/?delegate=77147
S:	Supported
F:	arch/x86/net/bpf_jit*
F:	Documentation/networking/filter.txt
F:	Documentation/bpf/
F:	include/linux/bpf*
F:	include/linux/filter.h
F:	include/trace/events/xdp.h
F:	include/uapi/linux/bpf*
F:	include/uapi/linux/filter.h
F:	kernel/bpf/
F:	kernel/trace/bpf_trace.c
F:	lib/test_bpf.c
F:	net/bpf/
F:	net/core/filter.c
F:	net/sched/act_bpf.c
F:	net/sched/cls_bpf.c
F:	samples/bpf/
F:	tools/bpf/
F:	tools/lib/bpf/
F:	tools/testing/selftests/bpf/

BROADCOM B44 10/100 ETHERNET DRIVER
M:	Michael Chan <michael.chan@broadcom.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/broadcom/b44.*

BROADCOM B53 ETHERNET SWITCH DRIVER
M:	Florian Fainelli <f.fainelli@gmail.com>
L:	netdev@vger.kernel.org
L:	openwrt-devel@lists.openwrt.org (subscribers-only)
S:	Supported
F:	drivers/net/dsa/b53/*
F:	include/linux/platform_data/b53.h

BROADCOM BCM281XX/BCM11XXX/BCM216XX ARM ARCHITECTURE
M:	Florian Fainelli <f.fainelli@gmail.com>
M:	Ray Jui <rjui@broadcom.com>
M:	Scott Branden <sbranden@broadcom.com>
M:	bcm-kernel-feedback-list@broadcom.com
T:	git git://github.com/broadcom/mach-bcm
S:	Maintained
N:	bcm281*
N:	bcm113*
N:	bcm216*
N:	kona
F:	arch/arm/mach-bcm/

BROADCOM BCM2835 ARM ARCHITECTURE
M:	Eric Anholt <eric@anholt.net>
M:	Stefan Wahren <stefan.wahren@i2se.com>
L:	linux-rpi-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://github.com/anholt/linux
S:	Maintained
N:	bcm2835
F:	drivers/staging/vc04_services

BROADCOM BCM47XX MIPS ARCHITECTURE
M:	Hauke Mehrtens <hauke@hauke-m.de>
M:	Rafał Miłecki <zajec5@gmail.com>
L:	linux-mips@linux-mips.org
S:	Maintained
F:	Documentation/devicetree/bindings/mips/brcm/
F:	arch/mips/bcm47xx/*
F:	arch/mips/include/asm/mach-bcm47xx/*

BROADCOM BCM5301X ARM ARCHITECTURE
M:	Hauke Mehrtens <hauke@hauke-m.de>
M:	Rafał Miłecki <zajec5@gmail.com>
M:	Jon Mason <jonmason@broadcom.com>
M:	bcm-kernel-feedback-list@broadcom.com
L:	linux-arm-kernel@lists.infradead.org
S:	Maintained
F:	arch/arm/mach-bcm/bcm_5301x.c
F:	arch/arm/boot/dts/bcm5301x*.dtsi
F:	arch/arm/boot/dts/bcm470*
F:	arch/arm/boot/dts/bcm953012*

BROADCOM BCM53573 ARM ARCHITECTURE
M:	Rafał Miłecki <rafal@milecki.pl>
L:	linux-arm-kernel@lists.infradead.org
S:	Maintained
F:	arch/arm/boot/dts/bcm53573*
F:	arch/arm/boot/dts/bcm47189*

BROADCOM BCM63XX ARM ARCHITECTURE
M:	Florian Fainelli <f.fainelli@gmail.com>
M:	bcm-kernel-feedback-list@broadcom.com
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://github.com/broadcom/stblinux.git
S:	Maintained
N:	bcm63xx

BROADCOM BCM63XX/BCM33XX UDC DRIVER
M:	Kevin Cernekee <cernekee@gmail.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/gadget/udc/bcm63xx_udc.*

BROADCOM BCM7XXX ARM ARCHITECTURE
M:	Brian Norris <computersforpeace@gmail.com>
M:	Gregory Fong <gregory.0xf0@gmail.com>
M:	Florian Fainelli <f.fainelli@gmail.com>
M:	bcm-kernel-feedback-list@broadcom.com
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://github.com/broadcom/stblinux.git
S:	Maintained
F:	arch/arm/mach-bcm/*brcmstb*
F:	arch/arm/boot/dts/bcm7*.dts*
F:	drivers/bus/brcmstb_gisb.c
F:	arch/arm/mm/cache-b15-rac.c
F:	arch/arm/include/asm/hardware/cache-b15-rac.h
N:	brcmstb

BROADCOM BMIPS CPUFREQ DRIVER
M:	Markus Mayer <mmayer@broadcom.com>
M:	bcm-kernel-feedback-list@broadcom.com
L:	linux-pm@vger.kernel.org
S:	Maintained
F:	drivers/cpufreq/bmips-cpufreq.c

BROADCOM BMIPS MIPS ARCHITECTURE
M:	Kevin Cernekee <cernekee@gmail.com>
M:	Florian Fainelli <f.fainelli@gmail.com>
L:	linux-mips@linux-mips.org
T:	git git://github.com/broadcom/stblinux.git
S:	Maintained
F:	arch/mips/bmips/*
F:	arch/mips/include/asm/mach-bmips/*
F:	arch/mips/kernel/*bmips*
F:	arch/mips/boot/dts/brcm/bcm*.dts*
F:	drivers/irqchip/irq-bcm63*
F:	drivers/irqchip/irq-bcm7*
F:	drivers/irqchip/irq-brcmstb*
F:	include/linux/bcm963xx_nvram.h
F:	include/linux/bcm963xx_tag.h

BROADCOM BNX2 GIGABIT ETHERNET DRIVER
M:	Rasesh Mody <rasesh.mody@cavium.com>
M:	Harish Patil <harish.patil@cavium.com>
M:	Dept-GELinuxNICDev@cavium.com
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/broadcom/bnx2.*
F:	drivers/net/ethernet/broadcom/bnx2_*

BROADCOM BNX2FC 10 GIGABIT FCOE DRIVER
M:	QLogic-Storage-Upstream@qlogic.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/bnx2fc/

BROADCOM BNX2I 1/10 GIGABIT iSCSI DRIVER
M:	QLogic-Storage-Upstream@qlogic.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/bnx2i/

BROADCOM BNX2X 10 GIGABIT ETHERNET DRIVER
M:	Ariel Elior <ariel.elior@cavium.com>
M:	everest-linux-l2@cavium.com
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/broadcom/bnx2x/

BROADCOM BNXT_EN 50 GIGABIT ETHERNET DRIVER
M:	Michael Chan <michael.chan@broadcom.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/broadcom/bnxt/

BROADCOM BRCM80211 IEEE802.11n WIRELESS DRIVER
M:	Arend van Spriel <arend.vanspriel@broadcom.com>
M:	Franky Lin <franky.lin@broadcom.com>
M:	Hante Meuleman <hante.meuleman@broadcom.com>
M:	Chi-Hsien Lin <chi-hsien.lin@cypress.com>
M:	Wright Feng <wright.feng@cypress.com>
L:	linux-wireless@vger.kernel.org
L:	brcm80211-dev-list.pdl@broadcom.com
L:	brcm80211-dev-list@cypress.com
S:	Supported
F:	drivers/net/wireless/broadcom/brcm80211/

BROADCOM BRCMSTB GPIO DRIVER
M:	Gregory Fong <gregory.0xf0@gmail.com>
L:	bcm-kernel-feedback-list@broadcom.com
S:	Supported
F:	drivers/gpio/gpio-brcmstb.c
F:	Documentation/devicetree/bindings/gpio/brcm,brcmstb-gpio.txt

BROADCOM BRCMSTB USB2 and USB3 PHY DRIVER
M:	Al Cooper <alcooperx@gmail.com>
L:	linux-kernel@vger.kernel.org
L:	bcm-kernel-feedback-list@broadcom.com
S:	Maintained
F:	drivers/phy/broadcom/phy-brcm-usb*

BROADCOM GENET ETHERNET DRIVER
M:	Doug Berger <opendmb@gmail.com>
M:	Florian Fainelli <f.fainelli@gmail.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/broadcom/genet/

BROADCOM IPROC ARM ARCHITECTURE
M:	Ray Jui <rjui@broadcom.com>
M:	Scott Branden <sbranden@broadcom.com>
M:	Jon Mason <jonmason@broadcom.com>
M:	bcm-kernel-feedback-list@broadcom.com
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://github.com/broadcom/cygnus-linux.git
S:	Maintained
N:	iproc
N:	cygnus
N:	bcm[-_]nsp
N:	bcm9113*
N:	bcm9583*
N:	bcm9585*
N:	bcm9586*
N:	bcm988312
N:	bcm113*
N:	bcm583*
N:	bcm585*
N:	bcm586*
N:	bcm88312
N:	hr2
F:	arch/arm64/boot/dts/broadcom/ns2*
F:	drivers/clk/bcm/clk-ns*
F:	drivers/pinctrl/bcm/pinctrl-ns*

BROADCOM KONA GPIO DRIVER
M:	Ray Jui <rjui@broadcom.com>
L:	bcm-kernel-feedback-list@broadcom.com
S:	Supported
F:	drivers/gpio/gpio-bcm-kona.c
F:	Documentation/devicetree/bindings/gpio/brcm,kona-gpio.txt

BROADCOM NETXTREME-E ROCE DRIVER
M:	Selvin Xavier <selvin.xavier@broadcom.com>
M:	Devesh Sharma <devesh.sharma@broadcom.com>
M:	Somnath Kotur <somnath.kotur@broadcom.com>
M:	Sriharsha Basavapatna <sriharsha.basavapatna@broadcom.com>
L:	linux-rdma@vger.kernel.org
W:	http://www.broadcom.com
S:	Supported
F:	drivers/infiniband/hw/bnxt_re/
F:	include/uapi/rdma/bnxt_re-abi.h

BROADCOM NVRAM DRIVER
M:	Rafał Miłecki <zajec5@gmail.com>
L:	linux-mips@linux-mips.org
S:	Maintained
F:	drivers/firmware/broadcom/*

BROADCOM SPECIFIC AMBA DRIVER (BCMA)
M:	Rafał Miłecki <zajec5@gmail.com>
L:	linux-wireless@vger.kernel.org
S:	Maintained
F:	drivers/bcma/
F:	include/linux/bcma/

BROADCOM STB AVS CPUFREQ DRIVER
M:	Markus Mayer <mmayer@broadcom.com>
M:	bcm-kernel-feedback-list@broadcom.com
L:	linux-pm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/cpufreq/brcm,stb-avs-cpu-freq.txt
F:	drivers/cpufreq/brcmstb*

BROADCOM STB AVS TMON DRIVER
M:	Markus Mayer <mmayer@broadcom.com>
M:	bcm-kernel-feedback-list@broadcom.com
L:	linux-pm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/thermal/brcm,avs-tmon.txt
F:	drivers/thermal/broadcom/brcmstb*

BROADCOM STB NAND FLASH DRIVER
M:	Brian Norris <computersforpeace@gmail.com>
M:	Kamal Dasu <kdasu.kdev@gmail.com>
L:	linux-mtd@lists.infradead.org
L:	bcm-kernel-feedback-list@broadcom.com
S:	Maintained
F:	drivers/mtd/nand/raw/brcmnand/

BROADCOM STB DPFE DRIVER
M:	Markus Mayer <mmayer@broadcom.com>
M:	bcm-kernel-feedback-list@broadcom.com
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/memory-controllers/brcm,dpfe-cpu.txt
F:	drivers/memory/brcmstb_dpfe.c

BROADCOM SYSTEMPORT ETHERNET DRIVER
M:	Florian Fainelli <f.fainelli@gmail.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/broadcom/bcmsysport.*

BROADCOM TG3 GIGABIT ETHERNET DRIVER
M:	Siva Reddy Kallam <siva.kallam@broadcom.com>
M:	Prashant Sreedharan <prashant@broadcom.com>
M:	Michael Chan <mchan@broadcom.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/broadcom/tg3.*

BROCADE BFA FC SCSI DRIVER
M:	Anil Gurumurthy <anil.gurumurthy@qlogic.com>
M:	Sudarsana Kalluru <sudarsana.kalluru@qlogic.com>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/bfa/

BROCADE BNA 10 GIGABIT ETHERNET DRIVER
M:	Rasesh Mody <rasesh.mody@cavium.com>
M:	Sudarsana Kalluru <sudarsana.kalluru@cavium.com>
M:	Dept-GELinuxNICDev@cavium.com
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/brocade/bna/

BSG (block layer generic sg v4 driver)
M:	FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	block/bsg.c
F:	include/linux/bsg.h
F:	include/uapi/linux/bsg.h

BT87X AUDIO DRIVER
M:	Clemens Ladisch <clemens@ladisch.de>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
T:	git git://git.alsa-project.org/alsa-kernel.git
S:	Maintained
F:	Documentation/sound/alsa/Bt87x.txt
F:	sound/pci/bt87x.c

BT8XXGPIO DRIVER
M:	Michael Buesch <m@bues.ch>
W:	http://bu3sch.de/btgpio.php
S:	Maintained
F:	drivers/gpio/gpio-bt8xx.c

BTRFS FILE SYSTEM
M:	Chris Mason <clm@fb.com>
M:	Josef Bacik <jbacik@fb.com>
M:	David Sterba <dsterba@suse.com>
L:	linux-btrfs@vger.kernel.org
W:	http://btrfs.wiki.kernel.org/
Q:	http://patchwork.kernel.org/project/linux-btrfs/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs.git
S:	Maintained
F:	Documentation/filesystems/btrfs.txt
F:	fs/btrfs/
F:	include/linux/btrfs*
F:	include/uapi/linux/btrfs*

BTTV VIDEO4LINUX DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Odd fixes
F:	Documentation/media/v4l-drivers/bttv*
F:	drivers/media/pci/bt8xx/bttv*

BUS FREQUENCY DRIVER FOR SAMSUNG EXYNOS
M:	Chanwoo Choi <cw00.choi@samsung.com>
L:	linux-pm@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mzx/devfreq.git
S:	Maintained
F:	drivers/devfreq/exynos-bus.c
F:	Documentation/devicetree/bindings/devfreq/exynos-bus.txt

BUSLOGIC SCSI DRIVER
M:	Khalid Aziz <khalid@gonehiking.org>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	drivers/scsi/BusLogic.*
F:	drivers/scsi/FlashPoint.*

C-MEDIA CMI8788 DRIVER
M:	Clemens Ladisch <clemens@ladisch.de>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
T:	git git://git.alsa-project.org/alsa-kernel.git
S:	Maintained
F:	sound/pci/oxygen/

C6X ARCHITECTURE
M:	Mark Salter <msalter@redhat.com>
M:	Aurelien Jacquiot <jacquiot.aurelien@gmail.com>
L:	linux-c6x-dev@linux-c6x.org
W:	http://www.linux-c6x.org/wiki/index.php/Main_Page
S:	Maintained
F:	arch/c6x/

CA8210 IEEE-802.15.4 RADIO DRIVER
M:	Harry Morris <h.morris@cascoda.com>
L:	linux-wpan@vger.kernel.org
W:	https://github.com/Cascoda/ca8210-linux.git
S:	Maintained
F:	drivers/net/ieee802154/ca8210.c
F:	Documentation/devicetree/bindings/net/ieee802154/ca8210.txt

CACHEFILES: FS-CACHE BACKEND FOR CACHING ON MOUNTED FILESYSTEMS
M:	David Howells <dhowells@redhat.com>
L:	linux-cachefs@redhat.com (moderated for non-subscribers)
S:	Supported
F:	Documentation/filesystems/caching/cachefiles.txt
F:	fs/cachefiles/

CADENCE MIPI-CSI2 BRIDGES
M:	Maxime Ripard <maxime.ripard@bootlin.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/cdns,*.txt
F:	drivers/media/platform/cadence/cdns-csi2*

CADET FM/AM RADIO RECEIVER DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/radio/radio-cadet*

CAFE CMOS INTEGRATED CAMERA CONTROLLER DRIVER
M:	Jonathan Corbet <corbet@lwn.net>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	Documentation/media/v4l-drivers/cafe_ccic*
F:	drivers/media/platform/marvell-ccic/

CAIF NETWORK LAYER
M:	Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/caif/
F:	drivers/net/caif/
F:	include/uapi/linux/caif/
F:	include/net/caif/
F:	net/caif/

CALGARY x86-64 IOMMU
M:	Muli Ben-Yehuda <mulix@mulix.org>
M:	Jon Mason <jdmason@kudzu.us>
L:	iommu@lists.linux-foundation.org
S:	Maintained
F:	arch/x86/kernel/pci-calgary_64.c
F:	arch/x86/kernel/tce_64.c
F:	arch/x86/include/asm/calgary.h
F:	arch/x86/include/asm/tce.h

CAN NETWORK DRIVERS
M:	Wolfgang Grandegger <wg@grandegger.com>
M:	Marc Kleine-Budde <mkl@pengutronix.de>
L:	linux-can@vger.kernel.org
W:	https://github.com/linux-can
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can-next.git
S:	Maintained
F:	Documentation/devicetree/bindings/net/can/
F:	drivers/net/can/
F:	include/linux/can/dev.h
F:	include/linux/can/platform/
F:	include/uapi/linux/can/error.h
F:	include/uapi/linux/can/netlink.h

CAN NETWORK LAYER
M:	Oliver Hartkopp <socketcan@hartkopp.net>
M:	Marc Kleine-Budde <mkl@pengutronix.de>
L:	linux-can@vger.kernel.org
W:	https://github.com/linux-can
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can-next.git
S:	Maintained
F:	Documentation/networking/can.rst
F:	net/can/
F:	include/linux/can/core.h
F:	include/uapi/linux/can.h
F:	include/uapi/linux/can/bcm.h
F:	include/uapi/linux/can/raw.h
F:	include/uapi/linux/can/gw.h

CAPABILITIES
M:	Serge Hallyn <serge@hallyn.com>
L:	linux-security-module@vger.kernel.org
S:	Supported
F:	include/linux/capability.h
F:	include/uapi/linux/capability.h
F:	security/commoncap.c
F:	kernel/capability.c

CAPELLA MICROSYSTEMS LIGHT SENSOR DRIVER
M:	Kevin Tsai <ktsai@capellamicro.com>
S:	Maintained
F:	drivers/iio/light/cm*

CARL9170 LINUX COMMUNITY WIRELESS DRIVER
M:	Christian Lamparter <chunkeey@googlemail.com>
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/en/users/Drivers/carl9170
S:	Maintained
F:	drivers/net/wireless/ath/carl9170/

CAVIUM I2C DRIVER
M:	Jan Glauber <jglauber@cavium.com>
M:	David Daney <david.daney@cavium.com>
W:	http://www.cavium.com
S:	Supported
F:	drivers/i2c/busses/i2c-octeon*
F:	drivers/i2c/busses/i2c-thunderx*

CAVIUM LIQUIDIO NETWORK DRIVER
M:	Derek Chickles <derek.chickles@caviumnetworks.com>
M:	Satanand Burla <satananda.burla@caviumnetworks.com>
M:	Felix Manlunas <felix.manlunas@caviumnetworks.com>
M:	Raghu Vatsavayi <raghu.vatsavayi@caviumnetworks.com>
L:	netdev@vger.kernel.org
W:	http://www.cavium.com
S:	Supported
F:	drivers/net/ethernet/cavium/liquidio/

CAVIUM MMC DRIVER
M:	Jan Glauber <jglauber@cavium.com>
M:	David Daney <david.daney@cavium.com>
M:	Steven J. Hill <Steven.Hill@cavium.com>
W:	http://www.cavium.com
S:	Supported
F:	drivers/mmc/host/cavium*

CAVIUM OCTEON-TX CRYPTO DRIVER
M:	George Cherian <george.cherian@cavium.com>
L:	linux-crypto@vger.kernel.org
W:	http://www.cavium.com
S:	Supported
F:	drivers/crypto/cavium/cpt/

CAVIUM THUNDERX2 ARM64 SOC
M:	Robert Richter <rrichter@cavium.com>
M:	Jayachandran C <jnair@caviumnetworks.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm64/boot/dts/cavium/thunder2-99xx*
F:	Documentation/devicetree/bindings/arm/cavium-thunder2.txt

CC2520 IEEE-802.15.4 RADIO DRIVER
M:	Varka Bhadram <varkabhadram@gmail.com>
L:	linux-wpan@vger.kernel.org
S:	Maintained
F:	drivers/net/ieee802154/cc2520.c
F:	include/linux/spi/cc2520.h
F:	Documentation/devicetree/bindings/net/ieee802154/cc2520.txt

CCREE ARM TRUSTZONE CRYPTOCELL REE DRIVER
M:	Gilad Ben-Yossef <gilad@benyossef.com>
L:	linux-crypto@vger.kernel.org
S:	Supported
F:	drivers/crypto/ccree/
W:	https://developer.arm.com/products/system-ip/trustzone-cryptocell/cryptocell-700-family

CEC FRAMEWORK
M:	Hans Verkuil <hans.verkuil@cisco.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	http://linuxtv.org
S:	Supported
F:	Documentation/media/kapi/cec-core.rst
F:	Documentation/media/uapi/cec
F:	drivers/media/cec/
F:	drivers/media/rc/keymaps/rc-cec.c
F:	include/media/cec.h
F:	include/media/cec-notifier.h
F:	include/uapi/linux/cec.h
F:	include/uapi/linux/cec-funcs.h
F:	Documentation/devicetree/bindings/media/cec.txt
F:	Documentation/ABI/testing/debugfs-cec-error-inj

CEC GPIO DRIVER
M:	Hans Verkuil <hans.verkuil@cisco.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	http://linuxtv.org
S:	Supported
F:	drivers/media/platform/cec-gpio/
F:	Documentation/devicetree/bindings/media/cec-gpio.txt

CELL BROADBAND ENGINE ARCHITECTURE
M:	Arnd Bergmann <arnd@arndb.de>
L:	linuxppc-dev@lists.ozlabs.org
W:	http://www.ibm.com/developerworks/power/cell/
S:	Supported
F:	arch/powerpc/include/asm/cell*.h
F:	arch/powerpc/include/asm/spu*.h
F:	arch/powerpc/include/uapi/asm/spu*.h
F:	arch/powerpc/oprofile/*cell*
F:	arch/powerpc/platforms/cell/

CEPH COMMON CODE (LIBCEPH)
M:	Ilya Dryomov <idryomov@gmail.com>
M:	"Yan, Zheng" <zyan@redhat.com>
M:	Sage Weil <sage@redhat.com>
L:	ceph-devel@vger.kernel.org
W:	http://ceph.com/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client.git
T:	git git://github.com/ceph/ceph-client.git
S:	Supported
F:	net/ceph/
F:	include/linux/ceph/
F:	include/linux/crush/

CEPH DISTRIBUTED FILE SYSTEM CLIENT (CEPH)
M:	"Yan, Zheng" <zyan@redhat.com>
M:	Sage Weil <sage@redhat.com>
M:	Ilya Dryomov <idryomov@gmail.com>
L:	ceph-devel@vger.kernel.org
W:	http://ceph.com/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client.git
T:	git git://github.com/ceph/ceph-client.git
S:	Supported
F:	Documentation/filesystems/ceph.txt
F:	fs/ceph/

CERTIFICATE HANDLING:
M:	David Howells <dhowells@redhat.com>
M:	David Woodhouse <dwmw2@infradead.org>
L:	keyrings@vger.kernel.org
S:	Maintained
F:	Documentation/module-signing.txt
F:	certs/
F:	scripts/sign-file.c
F:	scripts/extract-cert.c

CERTIFIED WIRELESS USB (WUSB) SUBSYSTEM:
L:	linux-usb@vger.kernel.org
S:	Orphan
F:	Documentation/usb/WUSB-Design-overview.txt
F:	Documentation/usb/wusb-cbaf
F:	drivers/usb/host/hwa-hc.c
F:	drivers/usb/host/whci/
F:	drivers/usb/wusbcore/
F:	include/linux/usb/wusb*

CFAG12864B LCD DRIVER
M:	Miguel Ojeda Sandonis <miguel.ojeda.sandonis@gmail.com>
S:	Maintained
F:	drivers/auxdisplay/cfag12864b.c
F:	include/linux/cfag12864b.h

CFAG12864BFB LCD FRAMEBUFFER DRIVER
M:	Miguel Ojeda Sandonis <miguel.ojeda.sandonis@gmail.com>
S:	Maintained
F:	drivers/auxdisplay/cfag12864bfb.c
F:	include/linux/cfag12864b.h

802.11 (including CFG80211/NL80211)
M:	Johannes Berg <johannes@sipsolutions.net>
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jberg/mac80211.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jberg/mac80211-next.git
S:	Maintained
F:	net/wireless/
F:	include/uapi/linux/nl80211.h
F:	include/linux/ieee80211.h
F:	include/net/wext.h
F:	include/net/cfg80211.h
F:	include/net/iw_handler.h
F:	include/net/ieee80211_radiotap.h
F:	Documentation/driver-api/80211/cfg80211.rst
F:	Documentation/networking/regulatory.txt

CHAR and MISC DRIVERS
M:	Arnd Bergmann <arnd@arndb.de>
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc.git
S:	Supported
F:	drivers/char/
F:	drivers/misc/
F:	include/linux/miscdevice.h

CHECKPATCH
M:	Andy Whitcroft <apw@canonical.com>
M:	Joe Perches <joe@perches.com>
S:	Maintained
F:	scripts/checkpatch.pl

CHINESE DOCUMENTATION
M:	Harry Wei <harryxiyou@gmail.com>
L:	xiyoulinuxkernelgroup@googlegroups.com (subscribers-only)
L:	linux-kernel@zh-kernel.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/translations/zh_CN/

CHIPIDEA USB HIGH SPEED DUAL ROLE CONTROLLER
M:	Peter Chen <Peter.Chen@nxp.com>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/peter.chen/usb.git
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/chipidea/

CHIPONE ICN8318 I2C TOUCHSCREEN DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/input/touchscreen/chipone_icn8318.txt
F:	drivers/input/touchscreen/chipone_icn8318.c

CHIPONE ICN8505 I2C TOUCHSCREEN DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/input/touchscreen/chipone_icn8505.c

CHROME HARDWARE PLATFORM SUPPORT
M:	Benson Leung <bleung@chromium.org>
M:	Olof Johansson <olof@lixom.net>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/bleung/chrome-platform.git
F:	drivers/platform/chrome/

CIRRUS LOGIC AUDIO CODEC DRIVERS
M:	Brian Austin <brian.austin@cirrus.com>
M:	Paul Handrigan <Paul.Handrigan@cirrus.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	sound/soc/codecs/cs*

CIRRUS LOGIC EP93XX ETHERNET DRIVER
M:	Hartley Sweeten <hsweeten@visionengravers.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/cirrus/ep93xx_eth.c

CISCO FCOE HBA DRIVER
M:	Satish Kharat <satishkh@cisco.com>
M:	Sesidhar Baddela <sebaddel@cisco.com>
M:	Karan Tilak Kumar <kartilak@cisco.com>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/fnic/

CISCO SCSI HBA DRIVER
M:	Karan Tilak Kumar <kartilak@cisco.com>
M:	Sesidhar Baddela <sebaddel@cisco.com>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/snic/

CISCO VIC ETHERNET NIC DRIVER
M:	Christian Benvenuti <benve@cisco.com>
M:	Govindarajulu Varadarajan <_govind@gmx.com>
M:	Parvi Kaustubhi <pkaustub@cisco.com>
S:	Supported
F:	drivers/net/ethernet/cisco/enic/

CISCO VIC LOW LATENCY NIC DRIVER
M:	Christian Benvenuti <benve@cisco.com>
M:	Dave Goodell <dgoodell@cisco.com>
S:	Supported
F:	drivers/infiniband/hw/usnic/

CLEANCACHE API
M:	Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	mm/cleancache.c
F:	include/linux/cleancache.h

CLK API
M:	Russell King <linux@armlinux.org.uk>
L:	linux-clk@vger.kernel.org
S:	Maintained
F:	include/linux/clk.h

CLOCKSOURCE, CLOCKEVENT DRIVERS
M:	Daniel Lezcano <daniel.lezcano@linaro.org>
M:	Thomas Gleixner <tglx@linutronix.de>
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/core
S:	Supported
F:	drivers/clocksource/
F:	Documentation/devicetree/bindings/timer/

CMPC ACPI DRIVER
M:	Thadeu Lima de Souza Cascardo <cascardo@holoscopio.com>
M:	Daniel Oliveira Nascimento <don@syst.com.br>
L:	platform-driver-x86@vger.kernel.org
S:	Supported
F:	drivers/platform/x86/classmate-laptop.c

COBALT MEDIA DRIVER
M:	Hans Verkuil <hans.verkuil@cisco.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Supported
F:	drivers/media/pci/cobalt/

COCCINELLE/Semantic Patches (SmPL)
M:	Julia Lawall <Julia.Lawall@lip6.fr>
M:	Gilles Muller <Gilles.Muller@lip6.fr>
M:	Nicolas Palix <nicolas.palix@imag.fr>
M:	Michal Marek <michal.lkml@markovi.net>
L:	cocci@systeme.lip6.fr (moderated for non-subscribers)
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mmarek/kbuild.git misc
W:	http://coccinelle.lip6.fr/
S:	Supported
F:	Documentation/dev-tools/coccinelle.rst
F:	scripts/coccinelle/
F:	scripts/coccicheck

CODA FILE SYSTEM
M:	Jan Harkes <jaharkes@cs.cmu.edu>
M:	coda@cs.cmu.edu
L:	codalist@coda.cs.cmu.edu
W:	http://www.coda.cs.cmu.edu/
S:	Maintained
F:	Documentation/filesystems/coda.txt
F:	fs/coda/
F:	include/linux/coda*.h
F:	include/uapi/linux/coda*.h

CODA V4L2 MEM2MEM DRIVER
M:	Philipp Zabel <p.zabel@pengutronix.de>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/coda.txt
F:	drivers/media/platform/coda/

COMMON CLK FRAMEWORK
M:	Michael Turquette <mturquette@baylibre.com>
M:	Stephen Boyd <sboyd@kernel.org>
L:	linux-clk@vger.kernel.org
Q:	http://patchwork.kernel.org/project/linux-clk/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/clk/linux.git
S:	Maintained
F:	Documentation/devicetree/bindings/clock/
F:	drivers/clk/
X:	drivers/clk/clkdev.c
F:	include/linux/clk-pr*
F:	include/linux/clk/
F:	include/linux/of_clk.h

COMMON INTERNET FILE SYSTEM (CIFS)
M:	Steve French <sfrench@samba.org>
L:	linux-cifs@vger.kernel.org
L:	samba-technical@lists.samba.org (moderated for non-subscribers)
W:	http://linux-cifs.samba.org/
T:	git git://git.samba.org/sfrench/cifs-2.6.git
S:	Supported
F:	Documentation/filesystems/cifs/
F:	fs/cifs/

COMPACTPCI HOTPLUG CORE
M:	Scott Murray <scott@spiteful.org>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	drivers/pci/hotplug/cpci_hotplug*

COMPACTPCI HOTPLUG GENERIC DRIVER
M:	Scott Murray <scott@spiteful.org>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	drivers/pci/hotplug/cpcihp_generic.c

COMPACTPCI HOTPLUG ZIATECH ZT5550 DRIVER
M:	Scott Murray <scott@spiteful.org>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	drivers/pci/hotplug/cpcihp_zt5550.*

COMPAL LAPTOP SUPPORT
M:	Cezary Jackiewicz <cezary.jackiewicz@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/compal-laptop.c

CONEXANT ACCESSRUNNER USB DRIVER
L:	accessrunner-general@lists.sourceforge.net
W:	http://accessrunner.sourceforge.net/
S:	Orphan
F:	drivers/usb/atm/cxacru.c

CONFIGFS
M:	Joel Becker <jlbec@evilplan.org>
M:	Christoph Hellwig <hch@lst.de>
T:	git git://git.infradead.org/users/hch/configfs.git
S:	Supported
F:	fs/configfs/
F:	include/linux/configfs.h

CONNECTOR
M:	Evgeniy Polyakov <zbr@ioremap.net>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/connector/

CONTROL GROUP (CGROUP)
M:	Tejun Heo <tj@kernel.org>
M:	Li Zefan <lizefan@huawei.com>
M:	Johannes Weiner <hannes@cmpxchg.org>
L:	cgroups@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tj/cgroup.git
S:	Maintained
F:	Documentation/cgroup*
F:	include/linux/cgroup*
F:	kernel/cgroup*

CONTROL GROUP - CPUSET
M:	Li Zefan <lizefan@huawei.com>
L:	cgroups@vger.kernel.org
W:	http://www.bullopensource.org/cpuset/
W:	http://oss.sgi.com/projects/cpusets/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tj/cgroup.git
S:	Maintained
F:	Documentation/cgroup-v1/cpusets.txt
F:	include/linux/cpuset.h
F:	kernel/cgroup/cpuset.c

CONTROL GROUP - MEMORY RESOURCE CONTROLLER (MEMCG)
M:	Johannes Weiner <hannes@cmpxchg.org>
M:	Michal Hocko <mhocko@kernel.org>
M:	Vladimir Davydov <vdavydov.dev@gmail.com>
L:	cgroups@vger.kernel.org
L:	linux-mm@kvack.org
S:	Maintained
F:	mm/memcontrol.c
F:	mm/swap_cgroup.c

CORETEMP HARDWARE MONITORING DRIVER
M:	Fenghua Yu <fenghua.yu@intel.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/coretemp
F:	drivers/hwmon/coretemp.c

COSA/SRP SYNC SERIAL DRIVER
M:	Jan "Yenya" Kasprzak <kas@fi.muni.cz>
W:	http://www.fi.muni.cz/~kas/cosa/
S:	Maintained
F:	drivers/net/wan/cosa*

CPMAC ETHERNET DRIVER
M:	Florian Fainelli <f.fainelli@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/ti/cpmac.c

CPU FREQUENCY DRIVERS
M:	"Rafael J. Wysocki" <rjw@rjwysocki.net>
M:	Viresh Kumar <viresh.kumar@linaro.org>
L:	linux-pm@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm.git
T:	git git://git.linaro.org/people/vireshk/linux.git (For ARM Updates)
B:	https://bugzilla.kernel.org
F:	Documentation/cpu-freq/
F:	Documentation/devicetree/bindings/cpufreq/
F:	drivers/cpufreq/
F:	include/linux/cpufreq.h
F:	tools/testing/selftests/cpufreq/

CPU FREQUENCY DRIVERS - ARM BIG LITTLE
M:	Viresh Kumar <viresh.kumar@linaro.org>
M:	Sudeep Holla <sudeep.holla@arm.com>
L:	linux-pm@vger.kernel.org
W:	http://www.arm.com/products/processors/technologies/biglittleprocessing.php
S:	Maintained
F:	drivers/cpufreq/arm_big_little.h
F:	drivers/cpufreq/arm_big_little.c
F:	drivers/cpufreq/arm_big_little_dt.c

CPU POWER MONITORING SUBSYSTEM
M:	Thomas Renninger <trenn@suse.com>
M:	Shuah Khan <shuah@kernel.org>
L:	linux-pm@vger.kernel.org
S:	Maintained
F:	tools/power/cpupower/

CPUID/MSR DRIVER
M:	"H. Peter Anvin" <hpa@zytor.com>
S:	Maintained
F:	arch/x86/kernel/cpuid.c
F:	arch/x86/kernel/msr.c

CPUIDLE DRIVER - ARM BIG LITTLE
M:	Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
M:	Daniel Lezcano <daniel.lezcano@linaro.org>
L:	linux-pm@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm.git
S:	Maintained
F:	drivers/cpuidle/cpuidle-big_little.c

CPUIDLE DRIVER - ARM EXYNOS
M:	Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
M:	Daniel Lezcano <daniel.lezcano@linaro.org>
M:	Kukjin Kim <kgene@kernel.org>
L:	linux-pm@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org
S:	Supported
F:	drivers/cpuidle/cpuidle-exynos.c
F:	arch/arm/mach-exynos/pm.c

CPUIDLE DRIVERS
M:	"Rafael J. Wysocki" <rjw@rjwysocki.net>
M:	Daniel Lezcano <daniel.lezcano@linaro.org>
L:	linux-pm@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm.git
B:	https://bugzilla.kernel.org
F:	drivers/cpuidle/*
F:	include/linux/cpuidle.h

CRAMFS FILESYSTEM
M:	Nicolas Pitre <nico@linaro.org>
S:	Maintained
F:	Documentation/filesystems/cramfs.txt
F:	fs/cramfs/

CRYPTO API
M:	Herbert Xu <herbert@gondor.apana.org.au>
M:	"David S. Miller" <davem@davemloft.net>
L:	linux-crypto@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/herbert/cryptodev-2.6.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6.git
S:	Maintained
F:	Documentation/crypto/
F:	Documentation/devicetree/bindings/crypto/
F:	arch/*/crypto/
F:	crypto/
F:	drivers/crypto/
F:	include/crypto/
F:	include/linux/crypto*

CRYPTOGRAPHIC RANDOM NUMBER GENERATOR
M:	Neil Horman <nhorman@tuxdriver.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	crypto/ansi_cprng.c
F:	crypto/rng.c

CS3308 MEDIA DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	http://linuxtv.org
S:	Odd Fixes
F:	drivers/media/i2c/cs3308.c
F:	drivers/media/i2c/cs3308.h

CS5535 Audio ALSA driver
M:	Jaya Kumar <jayakumar.alsa@gmail.com>
S:	Maintained
F:	sound/pci/cs5535audio/

CW1200 WLAN driver
M:	Solomon Peachy <pizza@shaftnet.org>
S:	Maintained
F:	drivers/net/wireless/st/cw1200/

CX18 VIDEO4LINUX DRIVER
M:	Andy Walls <awalls@md.metrocast.net>
L:	ivtv-devel@ivtvdriver.org (subscribers-only)
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
W:	http://www.ivtvdriver.org/index.php/Cx18
S:	Maintained
F:	Documentation/media/v4l-drivers/cx18*
F:	drivers/media/pci/cx18/
F:	include/uapi/linux/ivtv*

CX2341X MPEG ENCODER HELPER MODULE
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/common/cx2341x*
F:	include/media/cx2341x*

CX24120 MEDIA DRIVER
M:	Jemma Denson <jdenson@gmail.com>
M:	Patrick Boettcher <patrick.boettcher@posteo.de>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
S:	Maintained
F:	drivers/media/dvb-frontends/cx24120*

CX88 VIDEO4LINUX DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Odd fixes
F:	Documentation/media/v4l-drivers/cx88*
F:	drivers/media/pci/cx88/

CXD2820R MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/cxd2820r*

CXGB3 ETHERNET DRIVER (CXGB3)
M:	Santosh Raspatur <santosh@chelsio.com>
L:	netdev@vger.kernel.org
W:	http://www.chelsio.com
S:	Supported
F:	drivers/net/ethernet/chelsio/cxgb3/

CXGB3 ISCSI DRIVER (CXGB3I)
M:	Karen Xie <kxie@chelsio.com>
L:	linux-scsi@vger.kernel.org
W:	http://www.chelsio.com
S:	Supported
F:	drivers/scsi/cxgbi/cxgb3i

CXGB3 IWARP RNIC DRIVER (IW_CXGB3)
M:	Steve Wise <swise@chelsio.com>
L:	linux-rdma@vger.kernel.org
W:	http://www.openfabrics.org
S:	Supported
F:	drivers/infiniband/hw/cxgb3/
F:	include/uapi/rdma/cxgb3-abi.h

CXGB4 CRYPTO DRIVER (chcr)
M:	Harsh Jain <harsh@chelsio.com>
L:	linux-crypto@vger.kernel.org
W:	http://www.chelsio.com
S:	Supported
F:	drivers/crypto/chelsio

CXGB4 ETHERNET DRIVER (CXGB4)
M:	Ganesh Goudar <ganeshgr@chelsio.com>
L:	netdev@vger.kernel.org
W:	http://www.chelsio.com
S:	Supported
F:	drivers/net/ethernet/chelsio/cxgb4/

CXGB4 ISCSI DRIVER (CXGB4I)
M:	Karen Xie <kxie@chelsio.com>
L:	linux-scsi@vger.kernel.org
W:	http://www.chelsio.com
S:	Supported
F:	drivers/scsi/cxgbi/cxgb4i

CXGB4 IWARP RNIC DRIVER (IW_CXGB4)
M:	Steve Wise <swise@chelsio.com>
L:	linux-rdma@vger.kernel.org
W:	http://www.openfabrics.org
S:	Supported
F:	drivers/infiniband/hw/cxgb4/
F:	include/uapi/rdma/cxgb4-abi.h

CXGB4VF ETHERNET DRIVER (CXGB4VF)
M:	Casey Leedom <leedom@chelsio.com>
L:	netdev@vger.kernel.org
W:	http://www.chelsio.com
S:	Supported
F:	drivers/net/ethernet/chelsio/cxgb4vf/

CXL (IBM Coherent Accelerator Processor Interface CAPI) DRIVER
M:	Frederic Barrat <fbarrat@linux.vnet.ibm.com>
M:	Andrew Donnellan <andrew.donnellan@au1.ibm.com>
L:	linuxppc-dev@lists.ozlabs.org
S:	Supported
F:	arch/powerpc/platforms/powernv/pci-cxl.c
F:	drivers/misc/cxl/
F:	include/misc/cxl*
F:	include/uapi/misc/cxl.h
F:	Documentation/powerpc/cxl.txt
F:	Documentation/ABI/testing/sysfs-class-cxl

CXLFLASH (IBM Coherent Accelerator Processor Interface CAPI Flash) SCSI DRIVER
M:	Manoj N. Kumar <manoj@linux.vnet.ibm.com>
M:	Matthew R. Ochs <mrochs@linux.vnet.ibm.com>
M:	Uma Krishnan <ukrishn@linux.vnet.ibm.com>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/cxlflash/
F:	include/uapi/scsi/cxlflash_ioctls.h
F:	Documentation/powerpc/cxlflash.txt

CYBERPRO FB DRIVER
M:	Russell King <linux@armlinux.org.uk>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.armlinux.org.uk/
S:	Maintained
F:	drivers/video/fbdev/cyber2000fb.*

CYCLADES ASYNC MUX DRIVER
W:	http://www.cyclades.com/
S:	Orphan
F:	drivers/tty/cyclades.c
F:	include/linux/cyclades.h
F:	include/uapi/linux/cyclades.h

CYCLADES PC300 DRIVER
W:	http://www.cyclades.com/
S:	Orphan
F:	drivers/net/wan/pc300*

CYPRESS_FIRMWARE MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/common/cypress_firmware*

CYTTSP TOUCHSCREEN DRIVER
M:	Ferruh Yigit <fery@cypress.com>
L:	linux-input@vger.kernel.org
S:	Supported
F:	drivers/input/touchscreen/cyttsp*
F:	include/linux/input/cyttsp.h

D-LINK DIR-685 TOUCHKEYS DRIVER
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-input@vger.kernel.org
S:	Supported
F:	drivers/input/dlink-dir685-touchkeys.c

DALLAS/MAXIM DS1685-FAMILY REAL TIME CLOCK
M:	Joshua Kinard <kumba@gentoo.org>
S:	Maintained
F:	drivers/rtc/rtc-ds1685.c
F:	include/linux/rtc/ds1685.h

DAMA SLAVE for AX.25
M:	Joerg Reuter <jreuter@yaina.de>
W:	http://yaina.de/jreuter/
W:	http://www.qsl.net/dl1bke/
L:	linux-hams@vger.kernel.org
S:	Maintained
F:	net/ax25/af_ax25.c
F:	net/ax25/ax25_dev.c
F:	net/ax25/ax25_ds_*
F:	net/ax25/ax25_in.c
F:	net/ax25/ax25_out.c
F:	net/ax25/ax25_timer.c
F:	net/ax25/sysctl_net_ax25.c

DAVICOM FAST ETHERNET (DMFE) NETWORK DRIVER
L:	netdev@vger.kernel.org
S:	Orphan
F:	Documentation/networking/dmfe.txt
F:	drivers/net/ethernet/dec/tulip/dmfe.c

DC390/AM53C974 SCSI driver
M:	Hannes Reinecke <hare@suse.com>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	drivers/scsi/am53c974.c

DC395x SCSI driver
M:	Oliver Neukum <oliver@neukum.org>
M:	Ali Akcaagac <aliakc@web.de>
M:	Jamie Lenehan <lenehan@twibble.org>
L:	dc395x@twibble.org
W:	http://twibble.org/dist/dc395x/
W:	http://lists.twibble.org/mailman/listinfo/dc395x/
S:	Maintained
F:	Documentation/scsi/dc395x.txt
F:	drivers/scsi/dc395x.*

DCCP PROTOCOL
M:	Gerrit Renker <gerrit@erg.abdn.ac.uk>
L:	dccp@vger.kernel.org
W:	http://www.linuxfoundation.org/collaborate/workgroups/networking/dccp
S:	Maintained
F:	include/linux/dccp.h
F:	include/uapi/linux/dccp.h
F:	include/linux/tfrc.h
F:	net/dccp/

DECnet NETWORK LAYER
W:	http://linux-decnet.sourceforge.net
L:	linux-decnet-user@lists.sourceforge.net
S:	Orphan
F:	Documentation/networking/decnet.txt
F:	net/decnet/

DECSTATION PLATFORM SUPPORT
M:	"Maciej W. Rozycki" <macro@linux-mips.org>
L:	linux-mips@linux-mips.org
W:	http://www.linux-mips.org/wiki/DECstation
S:	Maintained
F:	arch/mips/dec/
F:	arch/mips/include/asm/dec/
F:	arch/mips/include/asm/mach-dec/

DEFXX FDDI NETWORK DRIVER
M:	"Maciej W. Rozycki" <macro@linux-mips.org>
S:	Maintained
F:	drivers/net/fddi/defxx.*

DELL SMBIOS DRIVER
M:	Pali Rohár <pali.rohar@gmail.com>
M:	Mario Limonciello <mario.limonciello@dell.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/dell-smbios.*

DELL SMBIOS SMM DRIVER
M:	Mario Limonciello <mario.limonciello@dell.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/dell-smbios-smm.c

DELL SMBIOS WMI DRIVER
M:	Mario Limonciello <mario.limonciello@dell.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/dell-smbios-wmi.c
F:	tools/wmi/dell-smbios-example.c

DELL LAPTOP DRIVER
M:	Matthew Garrett <mjg59@srcf.ucam.org>
M:	Pali Rohár <pali.rohar@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/dell-laptop.c

DELL LAPTOP FREEFALL DRIVER
M:	Pali Rohár <pali.rohar@gmail.com>
S:	Maintained
F:	drivers/platform/x86/dell-smo8800.c

DELL LAPTOP RBTN DRIVER
M:	Pali Rohár <pali.rohar@gmail.com>
S:	Maintained
F:	drivers/platform/x86/dell-rbtn.*

DELL LAPTOP SMM DRIVER
M:	Pali Rohár <pali.rohar@gmail.com>
S:	Maintained
F:	drivers/hwmon/dell-smm-hwmon.c
F:	include/uapi/linux/i8k.h

DELL SYSTEMS MANAGEMENT BASE DRIVER (dcdbas)
M:	Doug Warzecha <Douglas_Warzecha@dell.com>
S:	Maintained
F:	Documentation/dcdbas.txt
F:	drivers/firmware/dcdbas.*

DELL WMI NOTIFICATIONS DRIVER
M:	Matthew Garrett <mjg59@srcf.ucam.org>
M:	Pali Rohár <pali.rohar@gmail.com>
S:	Maintained
F:	drivers/platform/x86/dell-wmi.c

DELL WMI DESCRIPTOR DRIVER
M:	Mario Limonciello <mario.limonciello@dell.com>
S:	Maintained
F:	drivers/platform/x86/dell-wmi-descriptor.c

DELTA ST MEDIA DRIVER
M:	Hugues Fruchet <hugues.fruchet@st.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Supported
F:	drivers/media/platform/sti/delta

DENALI NAND DRIVER
M:	Masahiro Yamada <yamada.masahiro@socionext.com>
L:	linux-mtd@lists.infradead.org
S:	Supported
F:	drivers/mtd/nand/raw/denali*

DESIGNWARE USB2 DRD IP DRIVER
M:	Minas Harutyunyan <hminas@synopsys.com>
L:	linux-usb@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb.git
S:	Maintained
F:	drivers/usb/dwc2/

DESIGNWARE USB3 DRD IP DRIVER
M:	Felipe Balbi <balbi@kernel.org>
L:	linux-usb@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb.git
S:	Maintained
F:	drivers/usb/dwc3/

DEVANTECH SRF ULTRASONIC RANGER IIO DRIVER
M:	Andreas Klinger <ak@it-klinger.de>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-iio-distance-srf08
F:	drivers/iio/proximity/srf*.c

DEVICE COREDUMP (DEV_COREDUMP)
M:	Johannes Berg <johannes@sipsolutions.net>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/base/devcoredump.c
F:	include/linux/devcoredump.h

DEVICE FREQUENCY (DEVFREQ)
M:	MyungJoo Ham <myungjoo.ham@samsung.com>
M:	Kyungmin Park <kyungmin.park@samsung.com>
R:	Chanwoo Choi <cw00.choi@samsung.com>
L:	linux-pm@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mzx/devfreq.git
S:	Maintained
F:	drivers/devfreq/
F:	include/linux/devfreq.h
F:	Documentation/devicetree/bindings/devfreq/

DEVICE FREQUENCY EVENT (DEVFREQ-EVENT)
M:	Chanwoo Choi <cw00.choi@samsung.com>
L:	linux-pm@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mzx/devfreq.git
S:	Supported
F:	drivers/devfreq/event/
F:	drivers/devfreq/devfreq-event.c
F:	include/linux/devfreq-event.h
F:	Documentation/devicetree/bindings/devfreq/event/

DEVICE NUMBER REGISTRY
M:	Torben Mathiasen <device@lanana.org>
W:	http://lanana.org/docs/device-list/index.html
S:	Maintained

DEVICE-MAPPER  (LVM)
M:	Alasdair Kergon <agk@redhat.com>
M:	Mike Snitzer <snitzer@redhat.com>
M:	dm-devel@redhat.com
L:	dm-devel@redhat.com
W:	http://sources.redhat.com/dm
Q:	http://patchwork.kernel.org/project/dm-devel/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git
T:	quilt http://people.redhat.com/agk/patches/linux/editing/
S:	Maintained
F:	Documentation/device-mapper/
F:	drivers/md/Makefile
F:	drivers/md/Kconfig
F:	drivers/md/dm*
F:	drivers/md/persistent-data/
F:	include/linux/device-mapper.h
F:	include/linux/dm-*.h
F:	include/uapi/linux/dm-*.h

DEVLINK
M:	Jiri Pirko <jiri@mellanox.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	net/core/devlink.c
F:	include/net/devlink.h
F:	include/uapi/linux/devlink.h

DIALOG SEMICONDUCTOR DRIVERS
M:	Support Opensource <support.opensource@diasemi.com>
W:	http://www.dialog-semiconductor.com/products
S:	Supported
F:	Documentation/hwmon/da90??
F:	Documentation/devicetree/bindings/mfd/da90*.txt
F:	Documentation/devicetree/bindings/input/da90??-onkey.txt
F:	Documentation/devicetree/bindings/thermal/da90??-thermal.txt
F:	Documentation/devicetree/bindings/regulator/da92*.txt
F:	Documentation/devicetree/bindings/watchdog/da90??-wdt.txt
F:	Documentation/devicetree/bindings/sound/da[79]*.txt
F:	drivers/gpio/gpio-da90??.c
F:	drivers/hwmon/da90??-hwmon.c
F:	drivers/iio/adc/da91??-*.c
F:	drivers/input/misc/da90??_onkey.c
F:	drivers/input/touchscreen/da9052_tsi.c
F:	drivers/leds/leds-da90??.c
F:	drivers/mfd/da903x.c
F:	drivers/mfd/da90??-*.c
F:	drivers/mfd/da91??-*.c
F:	drivers/power/supply/da9052-battery.c
F:	drivers/power/supply/da91??-*.c
F:	drivers/regulator/da903x.c
F:	drivers/regulator/da9???-regulator.[ch]
F:	drivers/thermal/da90??-thermal.c
F:	drivers/rtc/rtc-da90??.c
F:	drivers/video/backlight/da90??_bl.c
F:	drivers/watchdog/da90??_wdt.c
F:	include/linux/mfd/da903x.h
F:	include/linux/mfd/da9052/
F:	include/linux/mfd/da9055/
F:	include/linux/mfd/da9062/
F:	include/linux/mfd/da9063/
F:	include/linux/mfd/da9150/
F:	include/linux/regulator/da9211.h
F:	include/sound/da[79]*.h
F:	sound/soc/codecs/da[79]*.[ch]

DIAMOND SYSTEMS GPIO-MM GPIO DRIVER
M:	William Breathitt Gray <vilhelm.gray@gmail.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-gpio-mm.c

DIGI NEO AND CLASSIC PCI PRODUCTS
M:	Lidza Louina <lidza.louina@gmail.com>
M:	Mark Hounschell <markh@compro.net>
L:	driverdev-devel@linuxdriverproject.org
S:	Maintained
F:	drivers/staging/dgnc/

DIOLAN U2C-12 I2C DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	drivers/i2c/busses/i2c-diolan-u2c.c

FILESYSTEM DIRECT ACCESS (DAX)
M:	Matthew Wilcox <mawilcox@microsoft.com>
M:	Ross Zwisler <ross.zwisler@linux.intel.com>
L:	linux-fsdevel@vger.kernel.org
S:	Supported
F:	fs/dax.c
F:	include/linux/dax.h
F:	include/trace/events/fs_dax.h

DEVICE DIRECT ACCESS (DAX)
M:	Dan Williams <dan.j.williams@intel.com>
M:	Dave Jiang <dave.jiang@intel.com>
M:	Ross Zwisler <ross.zwisler@linux.intel.com>
M:	Vishal Verma <vishal.l.verma@intel.com>
L:	linux-nvdimm@lists.01.org
S:	Supported
F:	drivers/dax/

DIRECTORY NOTIFICATION (DNOTIFY)
M:	Jan Kara <jack@suse.cz>
R:	Amir Goldstein <amir73il@gmail.com>
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
F:	Documentation/filesystems/dnotify.txt
F:	fs/notify/dnotify/
F:	include/linux/dnotify.h

DISK GEOMETRY AND PARTITION HANDLING
M:	Andries Brouwer <aeb@cwi.nl>
W:	http://www.win.tue.nl/~aeb/linux/Large-Disk.html
W:	http://www.win.tue.nl/~aeb/linux/zip/zip-1.html
W:	http://www.win.tue.nl/~aeb/partitions/partition_types-1.html
S:	Maintained

DISKQUOTA
M:	Jan Kara <jack@suse.com>
S:	Maintained
F:	Documentation/filesystems/quota.txt
F:	fs/quota/
F:	include/linux/quota*.h
F:	include/uapi/linux/quota*.h

DISPLAYLINK USB 2.0 FRAMEBUFFER DRIVER (UDLFB)
M:	Bernie Thompson <bernie@plugable.com>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
W:	http://plugable.com/category/projects/udlfb/
F:	drivers/video/fbdev/udlfb.c
F:	include/video/udlfb.h
F:	Documentation/fb/udlfb.txt

DISTRIBUTED LOCK MANAGER (DLM)
M:	Christine Caulfield <ccaulfie@redhat.com>
M:	David Teigland <teigland@redhat.com>
L:	cluster-devel@redhat.com
W:	http://sources.redhat.com/cluster/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/teigland/linux-dlm.git
S:	Supported
F:	fs/dlm/

DMA BUFFER SHARING FRAMEWORK
M:	Sumit Semwal <sumit.semwal@linaro.org>
S:	Maintained
L:	linux-media@vger.kernel.org
L:	dri-devel@lists.freedesktop.org
L:	linaro-mm-sig@lists.linaro.org (moderated for non-subscribers)
F:	drivers/dma-buf/
F:	include/linux/dma-buf*
F:	include/linux/reservation.h
F:	include/linux/*fence.h
F:	Documentation/driver-api/dma-buf.rst
T:	git git://anongit.freedesktop.org/drm/drm-misc

DMA GENERIC OFFLOAD ENGINE SUBSYSTEM
M:	Vinod Koul <vkoul@kernel.org>
L:	dmaengine@vger.kernel.org
Q:	https://patchwork.kernel.org/project/linux-dmaengine/list/
S:	Maintained
F:	drivers/dma/
F:	include/linux/dmaengine.h
F:	include/linux/of_dma.h
F:	Documentation/devicetree/bindings/dma/
F:	Documentation/driver-api/dmaengine/
T:	git git://git.infradead.org/users/vkoul/slave-dma.git

DMA MAPPING HELPERS
M:	Christoph Hellwig <hch@lst.de>
M:	Marek Szyprowski <m.szyprowski@samsung.com>
R:	Robin Murphy <robin.murphy@arm.com>
L:	iommu@lists.linux-foundation.org
T:	git git://git.infradead.org/users/hch/dma-mapping.git
W:	http://git.infradead.org/users/hch/dma-mapping.git
S:	Supported
F:	lib/dma-debug.c
F:	lib/dma-direct.c
F:	lib/dma-noncoherent.c
F:	lib/dma-virt.c
F:	drivers/base/dma-mapping.c
F:	drivers/base/dma-coherent.c
F:	include/asm-generic/dma-mapping.h
F:	include/linux/dma-direct.h
F:	include/linux/dma-mapping.h
F:	include/linux/dma-noncoherent.h

DME1737 HARDWARE MONITOR DRIVER
M:	Juerg Haefliger <juergh@gmail.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/dme1737
F:	drivers/hwmon/dme1737.c

DMI/SMBIOS SUPPORT
M:	Jean Delvare <jdelvare@suse.com>
S:	Maintained
T:	quilt http://jdelvare.nerim.net/devel/linux/jdelvare-dmi/
F:	Documentation/ABI/testing/sysfs-firmware-dmi-tables
F:	drivers/firmware/dmi-id.c
F:	drivers/firmware/dmi_scan.c
F:	include/linux/dmi.h

DOCUMENTATION
M:	Jonathan Corbet <corbet@lwn.net>
L:	linux-doc@vger.kernel.org
S:	Maintained
F:	Documentation/
F:	scripts/kernel-doc
X:	Documentation/ABI/
X:	Documentation/devicetree/
X:	Documentation/acpi
X:	Documentation/power
X:	Documentation/spi
X:	Documentation/media
T:	git git://git.lwn.net/linux.git docs-next

DONGWOON DW9714 LENS VOICE COIL DRIVER
M:	Sakari Ailus <sakari.ailus@linux.intel.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/dw9714.c

DOUBLETALK DRIVER
M:	"James R. Van Zandt" <jrv@vanzandt.mv.com>
L:	blinux-list@redhat.com
S:	Maintained
F:	drivers/char/dtlk.c
F:	include/linux/dtlk.h

DPAA2 DATAPATH I/O (DPIO) DRIVER
M:	Roy Pledge <Roy.Pledge@nxp.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/staging/fsl-mc/bus/dpio

DPAA2 ETHERNET DRIVER
M:	Ioana Radulescu <ruxandra.radulescu@nxp.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/staging/fsl-dpaa2/ethernet

DPAA2 ETHERNET SWITCH DRIVER
M:	Razvan Stefanescu <razvan.stefanescu@nxp.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/staging/fsl-dpaa2/ethsw

DPAA2 PTP CLOCK DRIVER
M:	Yangbo Lu <yangbo.lu@nxp.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/staging/fsl-dpaa2/rtc

DPT_I2O SCSI RAID DRIVER
M:	Adaptec OEM Raid Solutions <aacraid@microsemi.com>
L:	linux-scsi@vger.kernel.org
W:	http://www.adaptec.com/
S:	Maintained
F:	drivers/scsi/dpt*
F:	drivers/scsi/dpt/

DRBD DRIVER
M:	Philipp Reisner <philipp.reisner@linbit.com>
M:	Lars Ellenberg <lars.ellenberg@linbit.com>
L:	drbd-dev@lists.linbit.com
W:	http://www.drbd.org
T:	git git://git.linbit.com/linux-drbd.git
T:	git git://git.linbit.com/drbd-8.4.git
S:	Supported
F:	drivers/block/drbd/
F:	lib/lru_cache.c
F:	Documentation/blockdev/drbd/

DRIVER CORE, KOBJECTS, DEBUGFS AND SYSFS
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core.git
S:	Supported
F:	Documentation/kobject.txt
F:	drivers/base/
F:	fs/debugfs/
F:	fs/sysfs/
F:	include/linux/debugfs.h
F:	include/linux/kobj*
F:	lib/kobj*

DRIVERS FOR ADAPTIVE VOLTAGE SCALING (AVS)
M:	Kevin Hilman <khilman@kernel.org>
M:	Nishanth Menon <nm@ti.com>
S:	Maintained
F:	drivers/power/avs/
F:	include/linux/power/smartreflex.h
L:	linux-pm@vger.kernel.org

DRM DRIVER FOR ARM PL111 CLCD
M:	Eric Anholt <eric@anholt.net>
T:	git git://anongit.freedesktop.org/drm/drm-misc
S:	Supported
F:	drivers/gpu/drm/pl111/

DRM DRIVER FOR ARM VERSATILE TFT PANELS
M:	Linus Walleij <linus.walleij@linaro.org>
T:	git git://anongit.freedesktop.org/drm/drm-misc
S:	Maintained
F:	drivers/gpu/drm/panel/panel-arm-versatile.c
F:	Documentation/devicetree/bindings/display/panel/arm,versatile-tft-panel.txt

DRM DRIVER FOR AST SERVER GRAPHICS CHIPS
M:	Dave Airlie <airlied@redhat.com>
S:	Odd Fixes
F:	drivers/gpu/drm/ast/

DRM DRIVER FOR BOCHS VIRTUAL GPU
M:	Gerd Hoffmann <kraxel@redhat.com>
L:	virtualization@lists.linux-foundation.org
T:	git git://anongit.freedesktop.org/drm/drm-misc
S:	Maintained
F:	drivers/gpu/drm/bochs/

DRM DRIVER FOR FARADAY TVE200 TV ENCODER
M:	Linus Walleij <linus.walleij@linaro.org>
T:	git git://anongit.freedesktop.org/drm/drm-misc
S:	Maintained
F:	drivers/gpu/drm/tve200/

DRM DRIVER FOR ILITEK ILI9225 PANELS
M:	David Lechner <david@lechnology.com>
S:	Maintained
F:	drivers/gpu/drm/tinydrm/ili9225.c
F:	Documentation/devicetree/bindings/display/ili9225.txt

DRM DRIVER FOR INTEL I810 VIDEO CARDS
S:	Orphan / Obsolete
F:	drivers/gpu/drm/i810/
F:	include/uapi/drm/i810_drm.h

DRM DRIVER FOR MATROX G200/G400 GRAPHICS CARDS
S:	Orphan / Obsolete
F:	drivers/gpu/drm/mga/
F:	include/uapi/drm/mga_drm.h

DRM DRIVER FOR MGA G200 SERVER GRAPHICS CHIPS
M:	Dave Airlie <airlied@redhat.com>
S:	Odd Fixes
F:	drivers/gpu/drm/mgag200/

DRM DRIVER FOR MI0283QT
M:	Noralf Trønnes <noralf@tronnes.org>
S:	Maintained
F:	drivers/gpu/drm/tinydrm/mi0283qt.c
F:	Documentation/devicetree/bindings/display/multi-inno,mi0283qt.txt

DRM DRIVER FOR MSM ADRENO GPU
M:	Rob Clark <robdclark@gmail.com>
L:	linux-arm-msm@vger.kernel.org
L:	dri-devel@lists.freedesktop.org
L:	freedreno@lists.freedesktop.org
T:	git git://people.freedesktop.org/~robclark/linux
S:	Maintained
F:	drivers/gpu/drm/msm/
F:	include/uapi/drm/msm_drm.h
F:	Documentation/devicetree/bindings/display/msm/

DRM DRIVER FOR NVIDIA GEFORCE/QUADRO GPUS
M:	Ben Skeggs <bskeggs@redhat.com>
L:	dri-devel@lists.freedesktop.org
L:	nouveau@lists.freedesktop.org
T:	git git://github.com/skeggsb/linux
S:	Supported
F:	drivers/gpu/drm/nouveau/
F:	include/uapi/drm/nouveau_drm.h

DRM DRIVER FOR PERVASIVE DISPLAYS REPAPER PANELS
M:	Noralf Trønnes <noralf@tronnes.org>
S:	Maintained
F:	drivers/gpu/drm/tinydrm/repaper.c
F:	Documentation/devicetree/bindings/display/repaper.txt

DRM DRIVER FOR QEMU'S CIRRUS DEVICE
M:	Dave Airlie <airlied@redhat.com>
M:	Gerd Hoffmann <kraxel@redhat.com>
L:	virtualization@lists.linux-foundation.org
T:	git git://anongit.freedesktop.org/drm/drm-misc
S:	Obsolete
W:	https://www.kraxel.org/blog/2014/10/qemu-using-cirrus-considered-harmful/
F:	drivers/gpu/drm/cirrus/

DRM DRIVER FOR QXL VIRTUAL GPU
M:	Dave Airlie <airlied@redhat.com>
M:	Gerd Hoffmann <kraxel@redhat.com>
L:	virtualization@lists.linux-foundation.org
T:	git git://anongit.freedesktop.org/drm/drm-misc
S:	Maintained
F:	drivers/gpu/drm/qxl/
F:	include/uapi/drm/qxl_drm.h

DRM DRIVER FOR RAGE 128 VIDEO CARDS
S:	Orphan / Obsolete
F:	drivers/gpu/drm/r128/
F:	include/uapi/drm/r128_drm.h

DRM DRIVER FOR SAVAGE VIDEO CARDS
S:	Orphan / Obsolete
F:	drivers/gpu/drm/savage/
F:	include/uapi/drm/savage_drm.h

DRM DRIVER FOR SIS VIDEO CARDS
S:	Orphan / Obsolete
F:	drivers/gpu/drm/sis/
F:	include/uapi/drm/sis_drm.h

DRM DRIVER FOR SITRONIX ST7586 PANELS
M:	David Lechner <david@lechnology.com>
S:	Maintained
F:	drivers/gpu/drm/tinydrm/st7586.c
F:	Documentation/devicetree/bindings/display/st7586.txt

DRM DRIVER FOR SITRONIX ST7735R PANELS
M:	David Lechner <david@lechnology.com>
S:	Maintained
F:	drivers/gpu/drm/tinydrm/st7735r.c
F:	Documentation/devicetree/bindings/display/st7735r.txt

DRM DRIVER FOR TDFX VIDEO CARDS
S:	Orphan / Obsolete
F:	drivers/gpu/drm/tdfx/

DRM DRIVER FOR USB DISPLAYLINK VIDEO ADAPTERS
M:	Dave Airlie <airlied@redhat.com>
S:	Odd Fixes
F:	drivers/gpu/drm/udl/

DRM DRIVER FOR VMWARE VIRTUAL GPU
M:	"VMware Graphics" <linux-graphics-maintainer@vmware.com>
M:	Sinclair Yeh <syeh@vmware.com>
M:	Thomas Hellstrom <thellstrom@vmware.com>
L:	dri-devel@lists.freedesktop.org
T:	git git://people.freedesktop.org/~syeh/repos_linux
T:	git git://people.freedesktop.org/~thomash/linux
S:	Supported
F:	drivers/gpu/drm/vmwgfx/
F:	include/uapi/drm/vmwgfx_drm.h

DRM DRIVERS
M:	David Airlie <airlied@linux.ie>
L:	dri-devel@lists.freedesktop.org
T:	git git://people.freedesktop.org/~airlied/linux
B:	https://bugs.freedesktop.org/
C:	irc://chat.freenode.net/dri-devel
S:	Maintained
F:	drivers/gpu/drm/
F:	drivers/gpu/vga/
F:	Documentation/devicetree/bindings/display/
F:	Documentation/devicetree/bindings/gpu/
F:	Documentation/devicetree/bindings/video/
F:	Documentation/gpu/
F:	include/drm/
F:	include/uapi/drm/
F:	include/linux/vga*

DRM DRIVERS AND MISC GPU PATCHES
M:	Gustavo Padovan <gustavo@padovan.org>
M:	Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
M:	Sean Paul <seanpaul@chromium.org>
W:	https://01.org/linuxgraphics/gfx-docs/maintainer-tools/drm-misc.html
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/gpu/
F:	drivers/gpu/vga/
F:	drivers/gpu/drm/*
F:	include/drm/drm*
F:	include/uapi/drm/drm*
F:	include/linux/vga*

DRM DRIVERS FOR ALLWINNER A10
M:	Maxime Ripard  <maxime.ripard@bootlin.com>
L:	dri-devel@lists.freedesktop.org
S:	Supported
F:	drivers/gpu/drm/sun4i/
F:	Documentation/devicetree/bindings/display/sunxi/sun4i-drm.txt
T:	git git://anongit.freedesktop.org/drm/drm-misc

DRM DRIVERS FOR AMLOGIC SOCS
M:	Neil Armstrong <narmstrong@baylibre.com>
L:	dri-devel@lists.freedesktop.org
L:	linux-amlogic@lists.infradead.org
W:	http://linux-meson.com/
S:	Supported
F:	drivers/gpu/drm/meson/
F:	Documentation/devicetree/bindings/display/amlogic,meson-vpu.txt
F:	Documentation/devicetree/bindings/display/amlogic,meson-dw-hdmi.txt
F:	Documentation/gpu/meson.rst
T:	git git://anongit.freedesktop.org/drm/drm-misc

DRM DRIVERS FOR ATMEL HLCDC
M:	Boris Brezillon <boris.brezillon@bootlin.com>
L:	dri-devel@lists.freedesktop.org
S:	Supported
F:	drivers/gpu/drm/atmel-hlcdc/
F:	Documentation/devicetree/bindings/drm/atmel/
T:	git git://anongit.freedesktop.org/drm/drm-misc

DRM DRIVERS FOR BRIDGE CHIPS
M:	Archit Taneja <architt@codeaurora.org>
M:	Andrzej Hajda <a.hajda@samsung.com>
R:	Laurent Pinchart <Laurent.pinchart@ideasonboard.com>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/bridge/

DRM DRIVERS FOR EXYNOS
M:	Inki Dae <inki.dae@samsung.com>
M:	Joonyoung Shim <jy0922.shim@samsung.com>
M:	Seung-Woo Kim <sw0312.kim@samsung.com>
M:	Kyungmin Park <kyungmin.park@samsung.com>
L:	dri-devel@lists.freedesktop.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/daeinki/drm-exynos.git
S:	Supported
F:	drivers/gpu/drm/exynos/
F:	include/uapi/drm/exynos_drm.h
F:	Documentation/devicetree/bindings/display/exynos/

DRM DRIVERS FOR FREESCALE DCU
M:	Stefan Agner <stefan@agner.ch>
M:	Alison Wang <alison.wang@nxp.com>
L:	dri-devel@lists.freedesktop.org
S:	Supported
F:	drivers/gpu/drm/fsl-dcu/
F:	Documentation/devicetree/bindings/display/fsl,dcu.txt
F:	Documentation/devicetree/bindings/display/fsl,tcon.txt
F:	Documentation/devicetree/bindings/display/panel/nec,nl4827hc19_05b.txt

DRM DRIVERS FOR FREESCALE IMX
M:	Philipp Zabel <p.zabel@pengutronix.de>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
F:	drivers/gpu/drm/imx/
F:	drivers/gpu/ipu-v3/
F:	Documentation/devicetree/bindings/display/imx/

DRM DRIVERS FOR GMA500 (Poulsbo, Moorestown and derivative chipsets)
M:	Patrik Jakobsson <patrik.r.jakobsson@gmail.com>
L:	dri-devel@lists.freedesktop.org
T:	git git://github.com/patjak/drm-gma500
S:	Maintained
F:	drivers/gpu/drm/gma500/

DRM DRIVERS FOR HISILICON
M:	Xinliang Liu <z.liuxinliang@hisilicon.com>
M:	Rongrong Zou <zourongrong@gmail.com>
R:	Xinwei Kong <kong.kongxinwei@hisilicon.com>
R:	Chen Feng <puck.chen@hisilicon.com>
L:	dri-devel@lists.freedesktop.org
T:	git git://github.com/xin3liang/linux.git
S:	Maintained
F:	drivers/gpu/drm/hisilicon/
F:	Documentation/devicetree/bindings/display/hisilicon/

DRM DRIVERS FOR MEDIATEK
M:	CK Hu <ck.hu@mediatek.com>
M:	Philipp Zabel <p.zabel@pengutronix.de>
L:	dri-devel@lists.freedesktop.org
S:	Supported
F:	drivers/gpu/drm/mediatek/
F:	Documentation/devicetree/bindings/display/mediatek/

DRM DRIVERS FOR NVIDIA TEGRA
M:	Thierry Reding <thierry.reding@gmail.com>
L:	dri-devel@lists.freedesktop.org
L:	linux-tegra@vger.kernel.org
T:	git git://anongit.freedesktop.org/tegra/linux.git
S:	Supported
F:	drivers/gpu/drm/tegra/
F:	drivers/gpu/host1x/
F:	include/linux/host1x.h
F:	include/uapi/drm/tegra_drm.h
F:	Documentation/devicetree/bindings/display/tegra/nvidia,tegra20-host1x.txt

DRM DRIVERS FOR RENESAS
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	dri-devel@lists.freedesktop.org
L:	linux-renesas-soc@vger.kernel.org
T:	git git://linuxtv.org/pinchartl/fbdev
S:	Supported
F:	drivers/gpu/drm/rcar-du/
F:	drivers/gpu/drm/shmobile/
F:	include/linux/platform_data/shmob_drm.h
F:	Documentation/devicetree/bindings/display/bridge/renesas,dw-hdmi.txt
F:	Documentation/devicetree/bindings/display/bridge/renesas,lvds.txt
F:	Documentation/devicetree/bindings/display/renesas,du.txt

DRM DRIVERS FOR ROCKCHIP
M:	Sandy Huang <hjc@rock-chips.com>
M:	Heiko Stübner <heiko@sntech.de>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
F:	drivers/gpu/drm/rockchip/
F:	Documentation/devicetree/bindings/display/rockchip/
T:	git git://anongit.freedesktop.org/drm/drm-misc

DRM DRIVERS FOR STI
M:	Benjamin Gaignard <benjamin.gaignard@linaro.org>
M:	Vincent Abriou <vincent.abriou@st.com>
L:	dri-devel@lists.freedesktop.org
T:	git git://anongit.freedesktop.org/drm/drm-misc
S:	Maintained
F:	drivers/gpu/drm/sti
F:	Documentation/devicetree/bindings/display/st,stih4xx.txt

DRM DRIVERS FOR STM
M:	Yannick Fertre <yannick.fertre@st.com>
M:	Philippe Cornu <philippe.cornu@st.com>
M:	Benjamin Gaignard <benjamin.gaignard@linaro.org>
M:	Vincent Abriou <vincent.abriou@st.com>
L:	dri-devel@lists.freedesktop.org
T:	git git://anongit.freedesktop.org/drm/drm-misc
S:	Maintained
F:	drivers/gpu/drm/stm
F:	Documentation/devicetree/bindings/display/st,stm32-ltdc.txt

DRM DRIVERS FOR TI LCDC
M:	Jyri Sarha <jsarha@ti.com>
R:	Tomi Valkeinen <tomi.valkeinen@ti.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
F:	drivers/gpu/drm/tilcdc/
F:	Documentation/devicetree/bindings/display/tilcdc/

DRM DRIVERS FOR TI OMAP
M:	Tomi Valkeinen <tomi.valkeinen@ti.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
F:	drivers/gpu/drm/omapdrm/
F:	Documentation/devicetree/bindings/display/ti/

DRM DRIVERS FOR V3D
M:	Eric Anholt <eric@anholt.net>
S:	Supported
F:	drivers/gpu/drm/v3d/
F:	include/uapi/drm/v3d_drm.h
F:	Documentation/devicetree/bindings/display/brcm,bcm-v3d.txt
T:	git git://anongit.freedesktop.org/drm/drm-misc

DRM DRIVERS FOR VC4
M:	Eric Anholt <eric@anholt.net>
T:	git git://github.com/anholt/linux
S:	Supported
F:	drivers/gpu/drm/vc4/
F:	include/uapi/drm/vc4_drm.h
F:	Documentation/devicetree/bindings/display/brcm,bcm-vc4.txt
T:	git git://anongit.freedesktop.org/drm/drm-misc

DRM DRIVERS FOR VIVANTE GPU IP
M:	Lucas Stach <l.stach@pengutronix.de>
R:	Russell King <linux+etnaviv@armlinux.org.uk>
R:	Christian Gmeiner <christian.gmeiner@gmail.com>
L:	etnaviv@lists.freedesktop.org
L:	dri-devel@lists.freedesktop.org
S:	Maintained
F:	drivers/gpu/drm/etnaviv/
F:	include/uapi/drm/etnaviv_drm.h
F:	Documentation/devicetree/bindings/display/etnaviv/

DRM DRIVERS FOR ZTE ZX
M:	Shawn Guo <shawnguo@kernel.org>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
F:	drivers/gpu/drm/zte/
F:	Documentation/devicetree/bindings/display/zte,vou.txt
T:	git git://anongit.freedesktop.org/drm/drm-misc

DRM PANEL DRIVERS
M:	Thierry Reding <thierry.reding@gmail.com>
L:	dri-devel@lists.freedesktop.org
T:	git git://anongit.freedesktop.org/drm/drm-misc
S:	Maintained
F:	drivers/gpu/drm/drm_panel.c
F:	drivers/gpu/drm/panel/
F:	include/drm/drm_panel.h
F:	Documentation/devicetree/bindings/display/panel/

DRM TINYDRM DRIVERS
M:	Noralf Trønnes <noralf@tronnes.org>
W:	https://github.com/notro/tinydrm/wiki/Development
T:	git git://anongit.freedesktop.org/drm/drm-misc
S:	Maintained
F:	drivers/gpu/drm/tinydrm/
F:	include/drm/tinydrm/

DRM DRIVERS FOR XEN
M:	Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
T:	git git://anongit.freedesktop.org/drm/drm-misc
L:	dri-devel@lists.freedesktop.org
L:	xen-devel@lists.xen.org
S:	Supported
F:	drivers/gpu/drm/xen/
F:	Documentation/gpu/xen-front.rst

DRM TTM SUBSYSTEM
M:	Christian Koenig <christian.koenig@amd.com>
M:	Roger He <Hongbo.He@amd.com>
T:	git git://people.freedesktop.org/~agd5f/linux
S:	Maintained
L:	dri-devel@lists.freedesktop.org
F:	include/drm/ttm/
F:	drivers/gpu/drm/ttm/

DSBR100 USB FM RADIO DRIVER
M:	Alexey Klimov <klimov.linux@gmail.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/radio/dsbr100.c

DSCC4 DRIVER
M:	Francois Romieu <romieu@fr.zoreil.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/wan/dscc4.c

DT3155 MEDIA DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Odd Fixes
F:	drivers/media/pci/dt3155/

DVB_USB_AF9015 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/usb/dvb-usb-v2/af9015*

DVB_USB_AF9035 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/usb/dvb-usb-v2/af9035*

DVB_USB_ANYSEE MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/usb/dvb-usb-v2/anysee*

DVB_USB_AU6610 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/usb/dvb-usb-v2/au6610*

DVB_USB_CE6230 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/usb/dvb-usb-v2/ce6230*

DVB_USB_CXUSB MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://github.com/mkrufky
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/usb/dvb-usb/cxusb*

DVB_USB_EC168 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/usb/dvb-usb-v2/ec168*

DVB_USB_GL861 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/usb/dvb-usb-v2/gl861*

DVB_USB_MXL111SF MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://github.com/mkrufky
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/mkrufky/mxl111sf.git
S:	Maintained
F:	drivers/media/usb/dvb-usb-v2/mxl111sf*

DVB_USB_RTL28XXU MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/usb/dvb-usb-v2/rtl28xxu*

DVB_USB_V2 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/usb/dvb-usb-v2/dvb_usb*
F:	drivers/media/usb/dvb-usb-v2/usb_urb.c

DYNAMIC DEBUG
M:	Jason Baron <jbaron@akamai.com>
S:	Maintained
F:	lib/dynamic_debug.c
F:	include/linux/dynamic_debug.h

DYNAMIC INTERRUPT MODERATION
M:	Tal Gilboa <talgi@mellanox.com>
S:	Maintained
F:	include/linux/net_dim.h

DZ DECSTATION DZ11 SERIAL DRIVER
M:	"Maciej W. Rozycki" <macro@linux-mips.org>
S:	Maintained
F:	drivers/tty/serial/dz.*

E3X0 POWER BUTTON DRIVER
M:	Moritz Fischer <moritz.fischer@ettus.com>
L:	usrp-users@lists.ettus.com
W:	http://www.ettus.com
S:	Supported
F:	drivers/input/misc/e3x0-button.c
F:	Documentation/devicetree/bindings/input/e3x0-button.txt

E4000 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/tuners/e4000*

EC100 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/ec100*

ECRYPT FILE SYSTEM
M:	Tyler Hicks <tyhicks@canonical.com>
L:	ecryptfs@vger.kernel.org
W:	http://ecryptfs.org
W:	https://launchpad.net/ecryptfs
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tyhicks/ecryptfs.git
S:	Supported
F:	Documentation/filesystems/ecryptfs.txt
F:	fs/ecryptfs/

EDAC-AMD64
M:	Borislav Petkov <bp@alien8.de>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/amd64_edac*

EDAC-CALXEDA
M:	Robert Richter <rric@kernel.org>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/highbank*

EDAC-CAVIUM OCTEON
M:	Ralf Baechle <ralf@linux-mips.org>
M:	David Daney <david.daney@cavium.com>
L:	linux-edac@vger.kernel.org
L:	linux-mips@linux-mips.org
S:	Supported
F:	drivers/edac/octeon_edac*

EDAC-CAVIUM THUNDERX
M:	David Daney <david.daney@cavium.com>
M:	Jan Glauber <jglauber@cavium.com>
L:	linux-edac@vger.kernel.org
S:	Supported
F:	drivers/edac/thunderx_edac*

EDAC-CORE
M:	Borislav Petkov <bp@alien8.de>
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-edac@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/bp/bp.git for-next
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-edac.git linux_next
S:	Supported
F:	Documentation/admin-guide/ras.rst
F:	Documentation/driver-api/edac.rst
F:	drivers/edac/
F:	include/linux/edac.h

EDAC-E752X
M:	Mark Gross <mark.gross@intel.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/e752x_edac.c

EDAC-E7XXX
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/e7xxx_edac.c

EDAC-FSL_DDR
M:	York Sun <york.sun@nxp.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/fsl_ddr_edac.*

EDAC-GHES
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/ghes_edac.c

EDAC-I3000
L:	linux-edac@vger.kernel.org
S:	Orphan
F:	drivers/edac/i3000_edac.c

EDAC-I5000
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/i5000_edac.c

EDAC-I5400
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/i5400_edac.c

EDAC-I7300
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/i7300_edac.c

EDAC-I7CORE
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/i7core_edac.c

EDAC-I82443BXGX
M:	Tim Small <tim@buttersideup.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/i82443bxgx_edac.c

EDAC-I82975X
M:	Ranganathan Desikan <ravi@jetztechnologies.com>
M:	"Arvind R." <arvino55@gmail.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/i82975x_edac.c

EDAC-IE31200
M:	Jason Baron <jbaron@akamai.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/ie31200_edac.c

EDAC-MPC85XX
M:	Johannes Thumshirn <morbidrsa@gmail.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/mpc85xx_edac.[ch]

EDAC-PASEMI
M:	Egor Martovetsky <egor@pasemi.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/pasemi_edac.c

EDAC-PND2
M:	Tony Luck <tony.luck@intel.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/pnd2_edac.[ch]

EDAC-R82600
M:	Tim Small <tim@buttersideup.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/r82600_edac.c

EDAC-SBRIDGE
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/sb_edac.c

EDAC-SKYLAKE
M:	Tony Luck <tony.luck@intel.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/skx_edac.c

EDAC-TI
M:	Tero Kristo <t-kristo@ti.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/ti_edac.c

EDIROL UA-101/UA-1000 DRIVER
M:	Clemens Ladisch <clemens@ladisch.de>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
T:	git git://git.alsa-project.org/alsa-kernel.git
S:	Maintained
F:	sound/usb/misc/ua101.c

EFI TEST DRIVER
L:	linux-efi@vger.kernel.org
M:	Ivan Hu <ivan.hu@canonical.com>
M:	Ard Biesheuvel <ard.biesheuvel@linaro.org>
S:	Maintained
F:	drivers/firmware/efi/test/

EFI VARIABLE FILESYSTEM
M:	Matthew Garrett <matthew.garrett@nebula.com>
M:	Jeremy Kerr <jk@ozlabs.org>
M:	Ard Biesheuvel <ard.biesheuvel@linaro.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/efi/efi.git
L:	linux-efi@vger.kernel.org
S:	Maintained
F:	fs/efivarfs/

EFIFB FRAMEBUFFER DRIVER
L:	linux-fbdev@vger.kernel.org
M:	Peter Jones <pjones@redhat.com>
S:	Maintained
F:	drivers/video/fbdev/efifb.c

EFS FILESYSTEM
W:	http://aeschi.ch.eu.org/efs/
S:	Orphan
F:	fs/efs/

EHEA (IBM pSeries eHEA 10Gb ethernet adapter) DRIVER
M:	Douglas Miller <dougmill@linux.vnet.ibm.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/ibm/ehea/

EM28XX VIDEO4LINUX DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/usb/em28xx/
F:	Documentation/media/v4l-drivers/em28xx*

EMBEDDED LINUX
M:	Paul Gortmaker <paul.gortmaker@windriver.com>
M:	Matt Mackall <mpm@selenic.com>
M:	David Woodhouse <dwmw2@infradead.org>
L:	linux-embedded@vger.kernel.org
S:	Maintained

Emulex 10Gbps iSCSI - OneConnect DRIVER
M:	Subbu Seetharaman <subbu.seetharaman@broadcom.com>
M:	Ketan Mukadam <ketan.mukadam@broadcom.com>
M:	Jitendra Bhivare <jitendra.bhivare@broadcom.com>
L:	linux-scsi@vger.kernel.org
W:	http://www.broadcom.com
S:	Supported
F:	drivers/scsi/be2iscsi/

Emulex 10Gbps NIC BE2, BE3-R, Lancer, Skyhawk-R DRIVER (be2net)
M:	Sathya Perla <sathya.perla@broadcom.com>
M:	Ajit Khaparde <ajit.khaparde@broadcom.com>
M:	Sriharsha Basavapatna <sriharsha.basavapatna@broadcom.com>
M:	Somnath Kotur <somnath.kotur@broadcom.com>
L:	netdev@vger.kernel.org
W:	http://www.emulex.com
S:	Supported
F:	drivers/net/ethernet/emulex/benet/

EMULEX ONECONNECT ROCE DRIVER
M:	Selvin Xavier <selvin.xavier@broadcom.com>
M:	Devesh Sharma <devesh.sharma@broadcom.com>
L:	linux-rdma@vger.kernel.org
W:	http://www.broadcom.com
S:	Odd Fixes
F:	drivers/infiniband/hw/ocrdma/
F:	include/uapi/rdma/ocrdma-abi.h

EMULEX/BROADCOM LPFC FC/FCOE SCSI DRIVER
M:	James Smart <james.smart@broadcom.com>
M:	Dick Kennedy <dick.kennedy@broadcom.com>
L:	linux-scsi@vger.kernel.org
W:	http://www.broadcom.com
S:	Supported
F:	drivers/scsi/lpfc/

ENE CB710 FLASH CARD READER DRIVER
M:	Michał Mirosław <mirq-linux@rere.qmqm.pl>
S:	Maintained
F:	drivers/misc/cb710/
F:	drivers/mmc/host/cb710-mmc.*
F:	include/linux/cb710.h

ENE KB2426 (ENE0100/ENE020XX) INFRARED RECEIVER
M:	Maxim Levitsky <maximlevitsky@gmail.com>
S:	Maintained
F:	drivers/media/rc/ene_ir.*

EPSON S1D13XXX FRAMEBUFFER DRIVER
M:	Kristoffer Ericson <kristoffer.ericson@gmail.com>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kristoffer/linux-hpc.git
F:	drivers/video/fbdev/s1d13xxxfb.c
F:	include/video/s1d13xxxfb.h

ERRSEQ ERROR TRACKING INFRASTRUCTURE
M:	Jeff Layton <jlayton@kernel.org>
S:	Maintained
F:	lib/errseq.c
F:	include/linux/errseq.h

ET131X NETWORK DRIVER
M:	Mark Einon <mark.einon@gmail.com>
S:	Odd Fixes
F:	drivers/net/ethernet/agere/

ETHERNET BRIDGE
M:	Stephen Hemminger <stephen@networkplumber.org>
L:	bridge@lists.linux-foundation.org (moderated for non-subscribers)
L:	netdev@vger.kernel.org
W:	http://www.linuxfoundation.org/en/Net:Bridge
S:	Maintained
F:	include/linux/netfilter_bridge/
F:	net/bridge/

ETHERNET PHY LIBRARY
M:	Andrew Lunn <andrew@lunn.ch>
M:	Florian Fainelli <f.fainelli@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-mdio
F:	Documentation/devicetree/bindings/net/mdio*
F:	Documentation/networking/phy.txt
F:	drivers/net/phy/
F:	drivers/of/of_mdio.c
F:	drivers/of/of_net.c
F:	include/linux/*mdio*.h
F:	include/linux/of_net.h
F:	include/linux/phy.h
F:	include/linux/phy_fixed.h
F:	include/linux/platform_data/mdio-bcm-unimac.h
F:	include/trace/events/mdio.h
F:	include/uapi/linux/mdio.h
F:	include/uapi/linux/mii.h

EXT2 FILE SYSTEM
M:	Jan Kara <jack@suse.com>
L:	linux-ext4@vger.kernel.org
S:	Maintained
F:	Documentation/filesystems/ext2.txt
F:	fs/ext2/
F:	include/linux/ext2*

EXT4 FILE SYSTEM
M:	"Theodore Ts'o" <tytso@mit.edu>
M:	Andreas Dilger <adilger.kernel@dilger.ca>
L:	linux-ext4@vger.kernel.org
W:	http://ext4.wiki.kernel.org
Q:	http://patchwork.ozlabs.org/project/linux-ext4/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4.git
S:	Maintained
F:	Documentation/filesystems/ext4.txt
F:	fs/ext4/

Extended Verification Module (EVM)
M:	Mimi Zohar <zohar@linux.vnet.ibm.com>
L:	linux-integrity@vger.kernel.org
S:	Supported
F:	security/integrity/evm/

EXTENSIBLE FIRMWARE INTERFACE (EFI)
M:	Ard Biesheuvel <ard.biesheuvel@linaro.org>
L:	linux-efi@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/efi/efi.git
S:	Maintained
F:	Documentation/efi-stub.txt
F:	arch/*/kernel/efi.c
F:	arch/x86/boot/compressed/eboot.[ch]
F:	arch/*/include/asm/efi.h
F:	arch/x86/platform/efi/
F:	drivers/firmware/efi/
F:	include/linux/efi*.h
F:	arch/arm/boot/compressed/efi-header.S
F:	arch/arm64/kernel/efi-entry.S

EXTERNAL CONNECTOR SUBSYSTEM (EXTCON)
M:	MyungJoo Ham <myungjoo.ham@samsung.com>
M:	Chanwoo Choi <cw00.choi@samsung.com>
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/chanwoo/extcon.git
S:	Maintained
F:	drivers/extcon/
F:	include/linux/extcon/
F:	include/linux/extcon.h
F:	Documentation/extcon/
F:	Documentation/devicetree/bindings/extcon/

EXYNOS DP DRIVER
M:	Jingoo Han <jingoohan1@gmail.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
F:	drivers/gpu/drm/exynos/exynos_dp*

EXYNOS SYSMMU (IOMMU) driver
M:	Marek Szyprowski <m.szyprowski@samsung.com>
L:	iommu@lists.linux-foundation.org
S:	Maintained
F:	drivers/iommu/exynos-iommu.c

EZchip NPS platform support
M:	Vineet Gupta <vgupta@synopsys.com>
S:	Supported
F:	arch/arc/plat-eznps
F:	arch/arc/boot/dts/eznps.dts

F2FS FILE SYSTEM
M:	Jaegeuk Kim <jaegeuk@kernel.org>
M:	Chao Yu <yuchao0@huawei.com>
L:	linux-f2fs-devel@lists.sourceforge.net
W:	https://f2fs.wiki.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git
S:	Maintained
F:	Documentation/filesystems/f2fs.txt
F:	Documentation/ABI/testing/sysfs-fs-f2fs
F:	fs/f2fs/
F:	include/linux/f2fs_fs.h
F:	include/trace/events/f2fs.h

F71805F HARDWARE MONITORING DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/f71805f
F:	drivers/hwmon/f71805f.c

FADDR2LINE
M:	Josh Poimboeuf <jpoimboe@redhat.com>
S:	Maintained
F:	scripts/faddr2line

FAILOVER MODULE
M:	Sridhar Samudrala <sridhar.samudrala@intel.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	net/core/failover.c
F:	include/net/failover.h
F:	Documentation/networking/failover.rst

FANOTIFY
M:	Jan Kara <jack@suse.cz>
R:	Amir Goldstein <amir73il@gmail.com>
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
F:	fs/notify/fanotify/
F:	include/linux/fanotify.h
F:	include/uapi/linux/fanotify.h

FARSYNC SYNCHRONOUS DRIVER
M:	Kevin Curtis <kevin.curtis@farsite.co.uk>
W:	http://www.farsite.co.uk/
S:	Supported
F:	drivers/net/wan/farsync.*

FAULT INJECTION SUPPORT
M:	Akinobu Mita <akinobu.mita@gmail.com>
S:	Supported
F:	Documentation/fault-injection/
F:	lib/fault-inject.c

FBTFT Framebuffer drivers
M:	Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
S:	Maintained
F:	drivers/staging/fbtft/

FC0011 TUNER DRIVER
M:	Michael Buesch <m@bues.ch>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/tuners/fc0011.h
F:	drivers/media/tuners/fc0011.c

FC2580 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/tuners/fc2580*

FCOE SUBSYSTEM (libfc, libfcoe, fcoe)
M:	Johannes Thumshirn <jth@kernel.org>
L:	linux-scsi@vger.kernel.org
W:	www.Open-FCoE.org
S:	Supported
F:	drivers/scsi/libfc/
F:	drivers/scsi/fcoe/
F:	include/scsi/fc/
F:	include/scsi/libfc.h
F:	include/scsi/libfcoe.h
F:	include/uapi/scsi/fc/

FILE LOCKING (flock() and fcntl()/lockf())
M:	Jeff Layton <jlayton@kernel.org>
M:	"J. Bruce Fields" <bfields@fieldses.org>
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
F:	include/linux/fcntl.h
F:	include/uapi/linux/fcntl.h
F:	fs/fcntl.c
F:	fs/locks.c

FILESYSTEMS (VFS and infrastructure)
M:	Alexander Viro <viro@zeniv.linux.org.uk>
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
F:	fs/*
F:	include/linux/fs.h
F:	include/uapi/linux/fs.h

FINTEK F75375S HARDWARE MONITOR AND FAN CONTROLLER DRIVER
M:	Riku Voipio <riku.voipio@iki.fi>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/f75375s.c
F:	include/linux/f75375s.h

FIREWIRE AUDIO DRIVERS
M:	Clemens Ladisch <clemens@ladisch.de>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
T:	git git://git.alsa-project.org/alsa-kernel.git
S:	Maintained
F:	sound/firewire/

FIREWIRE MEDIA DRIVERS (firedtv)
M:	Stefan Richter <stefanr@s5r6.in-berlin.de>
L:	linux-media@vger.kernel.org
L:	linux1394-devel@lists.sourceforge.net
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media.git
S:	Maintained
F:	drivers/media/firewire/

FIREWIRE SBP-2 TARGET
M:	Chris Boot <bootc@bootc.net>
L:	linux-scsi@vger.kernel.org
L:	target-devel@vger.kernel.org
L:	linux1394-devel@lists.sourceforge.net
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/nab/lio-core-2.6.git master
S:	Maintained
F:	drivers/target/sbp/

FIREWIRE SUBSYSTEM
M:	Stefan Richter <stefanr@s5r6.in-berlin.de>
L:	linux1394-devel@lists.sourceforge.net
W:	http://ieee1394.wiki.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ieee1394/linux1394.git
S:	Maintained
F:	drivers/firewire/
F:	include/linux/firewire.h
F:	include/uapi/linux/firewire*.h
F:	tools/firewire/

FIRMWARE LOADER (request_firmware)
M:	Luis R. Rodriguez <mcgrof@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	Documentation/firmware_class/
F:	drivers/base/firmware_loader/
F:	include/linux/firmware.h

FLASH ADAPTER DRIVER (IBM Flash Adapter 900GB Full Height PCI Flash Card)
M:	Joshua Morris <josh.h.morris@us.ibm.com>
M:	Philip Kelleher <pjk1939@linux.vnet.ibm.com>
S:	Maintained
F:	drivers/block/rsxx/

FLOPPY DRIVER
M:	Jiri Kosina <jikos@kernel.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jikos/floppy.git
S:	Odd fixes
F:	drivers/block/floppy.c

FMC SUBSYSTEM
M:	Alessandro Rubini <rubini@gnudd.com>
W:	http://www.ohwr.org/projects/fmc-bus
S:	Supported
F:	drivers/fmc/
F:	include/linux/fmc*.h
F:	include/linux/ipmi-fru.h
K:	fmc_d.*register

FPGA MANAGER FRAMEWORK
M:	Alan Tull <atull@kernel.org>
M:	Moritz Fischer <mdf@kernel.org>
L:	linux-fpga@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/atull/linux-fpga.git
Q:	http://patchwork.kernel.org/project/linux-fpga/list/
F:	Documentation/fpga/
F:	Documentation/driver-api/fpga/
F:	Documentation/devicetree/bindings/fpga/
F:	drivers/fpga/
F:	include/linux/fpga/
W:	http://www.rocketboards.org

FPU EMULATOR
M:	Bill Metzenthen <billm@melbpc.org.au>
W:	http://floatingpoint.sourceforge.net/emulator/index.html
S:	Maintained
F:	arch/x86/math-emu/

FRAME RELAY DLCI/FRAD (Sangoma drivers too)
L:	netdev@vger.kernel.org
S:	Orphan
F:	drivers/net/wan/dlci.c
F:	drivers/net/wan/sdla.c

FRAMEBUFFER LAYER
M:	Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
L:	dri-devel@lists.freedesktop.org
L:	linux-fbdev@vger.kernel.org
T:	git git://github.com/bzolnier/linux.git
Q:	http://patchwork.kernel.org/project/linux-fbdev/list/
S:	Maintained
F:	Documentation/fb/
F:	drivers/video/
F:	include/video/
F:	include/linux/fb.h
F:	include/uapi/video/
F:	include/uapi/linux/fb.h

FREESCALE CAAM (Cryptographic Acceleration and Assurance Module) DRIVER
M:	Horia Geantă <horia.geanta@nxp.com>
M:	Aymen Sghaier <aymen.sghaier@nxp.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	drivers/crypto/caam/
F:	Documentation/devicetree/bindings/crypto/fsl-sec4.txt

FREESCALE DIU FRAMEBUFFER DRIVER
M:	Timur Tabi <timur@tabi.org>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	drivers/video/fbdev/fsl-diu-fb.*

FREESCALE DMA DRIVER
M:	Li Yang <leoyang.li@nxp.com>
M:	Zhang Wei <zw@zh-kernel.org>
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	drivers/dma/fsldma.*

FREESCALE eTSEC ETHERNET DRIVER (GIANFAR)
M:	Claudiu Manoil <claudiu.manoil@nxp.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/freescale/gianfar*
F:	Documentation/devicetree/bindings/net/fsl-tsec-phy.txt

FREESCALE GPMI NAND DRIVER
M:	Han Xu <han.xu@nxp.com>
L:	linux-mtd@lists.infradead.org
S:	Maintained
F:	drivers/mtd/nand/raw/gpmi-nand/*

FREESCALE I2C CPM DRIVER
M:	Jochen Friedrich <jochen@scram.de>
L:	linuxppc-dev@lists.ozlabs.org
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	drivers/i2c/busses/i2c-cpm.c

FREESCALE IMX / MXC FEC DRIVER
M:	Fugang Duan <fugang.duan@nxp.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/freescale/fec_main.c
F:	drivers/net/ethernet/freescale/fec_ptp.c
F:	drivers/net/ethernet/freescale/fec.h
F:	Documentation/devicetree/bindings/net/fsl-fec.txt

FREESCALE IMX / MXC FRAMEBUFFER DRIVER
M:	Sascha Hauer <s.hauer@pengutronix.de>
R:	Pengutronix Kernel Team <kernel@pengutronix.de>
L:	linux-fbdev@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	include/linux/platform_data/video-imxfb.h
F:	drivers/video/fbdev/imxfb.c

FREESCALE QORIQ DPAA ETHERNET DRIVER
M:	Madalin Bucur <madalin.bucur@nxp.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/freescale/dpaa

FREESCALE QORIQ DPAA FMAN DRIVER
M:	Madalin Bucur <madalin.bucur@nxp.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/freescale/fman
F:	Documentation/devicetree/bindings/powerpc/fsl/fman.txt

FREESCALE QORIQ PTP CLOCK DRIVER
M:	Yangbo Lu <yangbo.lu@nxp.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/ptp/ptp_qoriq.c
F:	include/linux/fsl/ptp_qoriq.h
F:	Documentation/devicetree/bindings/ptp/ptp-qoriq.txt

FREESCALE QUAD SPI DRIVER
M:	Han Xu <han.xu@nxp.com>
L:	linux-mtd@lists.infradead.org
S:	Maintained
F:	drivers/mtd/spi-nor/fsl-quadspi.c

FREESCALE QUICC ENGINE LIBRARY
M:	Qiang Zhao <qiang.zhao@nxp.com>
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	drivers/soc/fsl/qe/
F:	include/soc/fsl/*qe*.h
F:	include/soc/fsl/*ucc*.h

FREESCALE QUICC ENGINE UCC ETHERNET DRIVER
M:	Li Yang <leoyang.li@nxp.com>
L:	netdev@vger.kernel.org
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	drivers/net/ethernet/freescale/ucc_geth*

FREESCALE QUICC ENGINE UCC HDLC DRIVER
M:	Zhao Qiang <qiang.zhao@nxp.com>
L:	netdev@vger.kernel.org
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	drivers/net/wan/fsl_ucc_hdlc*

FREESCALE QUICC ENGINE UCC UART DRIVER
M:	Timur Tabi <timur@tabi.org>
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	drivers/tty/serial/ucc_uart.c

FREESCALE SOC DRIVERS
M:	Li Yang <leoyang.li@nxp.com>
L:	linuxppc-dev@lists.ozlabs.org
L:	linux-arm-kernel@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/soc/fsl/
F:	drivers/soc/fsl/
F:	include/linux/fsl/

FREESCALE SOC FS_ENET DRIVER
M:	Pantelis Antoniou <pantelis.antoniou@gmail.com>
M:	Vitaly Bordug <vbordug@ru.mvista.com>
L:	linuxppc-dev@lists.ozlabs.org
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/freescale/fs_enet/
F:	include/linux/fs_enet_pd.h

FREESCALE SOC SOUND DRIVERS
M:	Timur Tabi <timur@tabi.org>
M:	Nicolin Chen <nicoleotsuka@gmail.com>
M:	Xiubo Li <Xiubo.Lee@gmail.com>
R:	Fabio Estevam <fabio.estevam@nxp.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	sound/soc/fsl/fsl*
F:	sound/soc/fsl/imx*
F:	sound/soc/fsl/mpc8610_hpcd.c

FREESCALE USB PERIPHERAL DRIVERS
M:	Li Yang <leoyang.li@nxp.com>
L:	linux-usb@vger.kernel.org
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	drivers/usb/gadget/udc/fsl*

FREEVXFS FILESYSTEM
M:	Christoph Hellwig <hch@infradead.org>
W:	ftp://ftp.openlinux.org/pub/people/hch/vxfs
S:	Maintained
F:	fs/freevxfs/

FREEZER
M:	"Rafael J. Wysocki" <rjw@rjwysocki.net>
M:	Pavel Machek <pavel@ucw.cz>
L:	linux-pm@vger.kernel.org
S:	Supported
F:	Documentation/power/freezing-of-tasks.txt
F:	include/linux/freezer.h
F:	kernel/freezer.c

FRONTSWAP API
M:	Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	mm/frontswap.c
F:	include/linux/frontswap.h

FS-CACHE: LOCAL CACHING FOR NETWORK FILESYSTEMS
M:	David Howells <dhowells@redhat.com>
L:	linux-cachefs@redhat.com (moderated for non-subscribers)
S:	Supported
F:	Documentation/filesystems/caching/
F:	fs/fscache/
F:	include/linux/fscache*.h

FSCRYPT: FILE SYSTEM LEVEL ENCRYPTION SUPPORT
M:	Theodore Y. Ts'o <tytso@mit.edu>
M:	Jaegeuk Kim <jaegeuk@kernel.org>
L:	linux-fscrypt@vger.kernel.org
Q:	https://patchwork.kernel.org/project/linux-fscrypt/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tytso/fscrypt.git
S:	Supported
F:	fs/crypto/
F:	include/linux/fscrypt*.h
F:	Documentation/filesystems/fscrypt.rst

FSNOTIFY: FILESYSTEM NOTIFICATION INFRASTRUCTURE
M:	Jan Kara <jack@suse.cz>
R:	Amir Goldstein <amir73il@gmail.com>
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
F:	fs/notify/
F:	include/linux/fsnotify*.h

FUJITSU LAPTOP EXTRAS
M:	Jonathan Woithe <jwoithe@just42.net>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/fujitsu-laptop.c

FUJITSU M-5MO LS CAMERA ISP DRIVER
M:	Kyungmin Park <kyungmin.park@samsung.com>
M:	Heungjun Kim <riverful.kim@samsung.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/m5mols/
F:	include/media/i2c/m5mols.h

FUJITSU TABLET EXTRAS
M:	Robert Gerlach <khnz@gmx.de>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/fujitsu-tablet.c

FUSE: FILESYSTEM IN USERSPACE
M:	Miklos Szeredi <miklos@szeredi.hu>
L:	linux-fsdevel@vger.kernel.org
W:	http://fuse.sourceforge.net/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/fuse.git
S:	Maintained
F:	fs/fuse/
F:	include/uapi/linux/fuse.h
F:	Documentation/filesystems/fuse.txt

FUTEX SUBSYSTEM
M:	Thomas Gleixner <tglx@linutronix.de>
M:	Ingo Molnar <mingo@redhat.com>
R:	Peter Zijlstra <peterz@infradead.org>
R:	Darren Hart <dvhart@infradead.org>
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git locking/core
S:	Maintained
F:	kernel/futex.c
F:	kernel/futex_compat.c
F:	include/asm-generic/futex.h
F:	include/linux/futex.h
F:	include/uapi/linux/futex.h
F:	tools/testing/selftests/futex/
F:	tools/perf/bench/futex*
F:	Documentation/*futex*

GCC PLUGINS
M:	Kees Cook <keescook@chromium.org>
R:	Emese Revfy <re.emese@gmail.com>
L:	kernel-hardening@lists.openwall.com
S:	Maintained
F:	scripts/gcc-plugins/
F:	scripts/gcc-plugin.sh
F:	scripts/Makefile.gcc-plugins
F:	Documentation/gcc-plugins.txt

GCOV BASED KERNEL PROFILING
M:	Peter Oberparleiter <oberpar@linux.ibm.com>
S:	Maintained
F:	kernel/gcov/
F:	Documentation/dev-tools/gcov.rst

GDB KERNEL DEBUGGING HELPER SCRIPTS
M:	Jan Kiszka <jan.kiszka@siemens.com>
M:	Kieran Bingham <kieran@bingham.xyz>
S:	Supported
F:	scripts/gdb/

GDT SCSI DISK ARRAY CONTROLLER DRIVER
M:	Achim Leubner <achim_leubner@adaptec.com>
L:	linux-scsi@vger.kernel.org
W:	http://www.icp-vortex.com/
S:	Supported
F:	drivers/scsi/gdt*

GEMTEK FM RADIO RECEIVER DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/radio/radio-gemtek*

GENERIC GPIO I2C DRIVER
M:	Haavard Skinnemoen <hskinnemoen@gmail.com>
S:	Supported
F:	drivers/i2c/busses/i2c-gpio.c
F:	include/linux/platform_data/i2c-gpio.h

GENERIC GPIO I2C MULTIPLEXER DRIVER
M:	Peter Korsgaard <peter.korsgaard@barco.com>
L:	linux-i2c@vger.kernel.org
S:	Supported
F:	drivers/i2c/muxes/i2c-mux-gpio.c
F:	include/linux/platform_data/i2c-mux-gpio.h
F:	Documentation/i2c/muxes/i2c-mux-gpio

GENERIC HDLC (WAN) DRIVERS
M:	Krzysztof Halasa <khc@pm.waw.pl>
W:	http://www.kernel.org/pub/linux/utils/net/hdlc/
S:	Maintained
F:	drivers/net/wan/c101.c
F:	drivers/net/wan/hd6457*
F:	drivers/net/wan/hdlc*
F:	drivers/net/wan/n2.c
F:	drivers/net/wan/pc300too.c
F:	drivers/net/wan/pci200syn.c
F:	drivers/net/wan/wanxl*

GENERIC INCLUDE/ASM HEADER FILES
M:	Arnd Bergmann <arnd@arndb.de>
L:	linux-arch@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/arnd/asm-generic.git
S:	Maintained
F:	include/asm-generic/
F:	include/uapi/asm-generic/

GENERIC PHY FRAMEWORK
M:	Kishon Vijay Abraham I <kishon@ti.com>
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kishon/linux-phy.git
S:	Supported
F:	drivers/phy/
F:	include/linux/phy/

GENERIC PINCTRL I2C DEMULTIPLEXER DRIVER
M:	Wolfram Sang <wsa+renesas@sang-engineering.com>
S:	Supported
F:	drivers/i2c/muxes/i2c-demux-pinctrl.c

GENERIC PM DOMAINS
M:	"Rafael J. Wysocki" <rjw@rjwysocki.net>
M:	Kevin Hilman <khilman@kernel.org>
M:	Ulf Hansson <ulf.hansson@linaro.org>
L:	linux-pm@vger.kernel.org
S:	Supported
F:	drivers/base/power/domain*.c
F:	include/linux/pm_domain.h
F:	Documentation/devicetree/bindings/power/power_domain.txt

GENERIC UIO DRIVER FOR PCI DEVICES
M:	"Michael S. Tsirkin" <mst@redhat.com>
L:	kvm@vger.kernel.org
S:	Supported
F:	drivers/uio/uio_pci_generic.c

GENWQE (IBM Generic Workqueue Card)
M:	Frank Haverkamp <haver@linux.vnet.ibm.com>
M:	Guilherme G. Piccoli <gpiccoli@linux.vnet.ibm.com>
S:	Supported
F:	drivers/misc/genwqe/

GET_MAINTAINER SCRIPT
M:	Joe Perches <joe@perches.com>
S:	Maintained
F:	scripts/get_maintainer.pl

GFS2 FILE SYSTEM
M:	Bob Peterson <rpeterso@redhat.com>
M:	Andreas Gruenbacher <agruenba@redhat.com>
L:	cluster-devel@redhat.com
W:	http://sources.redhat.com/cluster/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2.git
S:	Supported
F:	Documentation/filesystems/gfs2*.txt
F:	fs/gfs2/
F:	include/uapi/linux/gfs2_ondisk.h

GIGASET ISDN DRIVERS
M:	Paul Bolle <pebolle@tiscali.nl>
L:	gigaset307x-common@lists.sourceforge.net
W:	http://gigaset307x.sourceforge.net/
S:	Odd Fixes
F:	Documentation/isdn/README.gigaset
F:	drivers/isdn/gigaset/
F:	include/uapi/linux/gigaset_dev.h

GO7007 MPEG CODEC
M:	Hans Verkuil <hans.verkuil@cisco.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/usb/go7007/

GOODIX TOUCHSCREEN
M:	Bastien Nocera <hadess@hadess.net>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/input/touchscreen/goodix.c

GPD POCKET FAN DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/gpd-pocket-fan.c

GPIO ACPI SUPPORT
M:	Mika Westerberg <mika.westerberg@linux.intel.com>
M:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
L:	linux-gpio@vger.kernel.org
L:	linux-acpi@vger.kernel.org
S:	Maintained
F:	Documentation/acpi/gpio-properties.txt
F:	drivers/gpio/gpiolib-acpi.c

GPIO IR Transmitter
M:	Sean Young <sean@mess.org>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/rc/gpio-ir-tx.c

GPIO MOCKUP DRIVER
M:	Bamvor Jian Zhang <bamv2005@gmail.com>
R:	Bartosz Golaszewski <brgl@bgdev.pl>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-mockup.c
F:	tools/testing/selftests/gpio/

GPIO SUBSYSTEM
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-gpio@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio.git
S:	Maintained
F:	Documentation/devicetree/bindings/gpio/
F:	Documentation/driver-api/gpio/
F:	Documentation/gpio/
F:	Documentation/ABI/testing/gpio-cdev
F:	Documentation/ABI/obsolete/sysfs-gpio
F:	drivers/gpio/
F:	include/linux/gpio/
F:	include/linux/gpio.h
F:	include/linux/of_gpio.h
F:	include/asm-generic/gpio.h
F:	include/uapi/linux/gpio.h
F:	tools/gpio/

GRE DEMULTIPLEXER DRIVER
M:	Dmitry Kozlov <xeb@mail.ru>
L:	netdev@vger.kernel.org
S:	Maintained
F:	net/ipv4/gre_demux.c
F:	net/ipv4/gre_offload.c
F:	include/net/gre.h

GRETH 10/100/1G Ethernet MAC device driver
M:	Andreas Larsson <andreas@gaisler.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/aeroflex/

GREYBUS AUDIO PROTOCOLS DRIVERS
M:	Vaibhav Agarwal <vaibhav.sr@gmail.com>
M:	Mark Greer <mgreer@animalcreek.com>
S:	Maintained
F:	drivers/staging/greybus/audio_apbridgea.c
F:	drivers/staging/greybus/audio_apbridgea.h
F:	drivers/staging/greybus/audio_codec.c
F:	drivers/staging/greybus/audio_codec.h
F:	drivers/staging/greybus/audio_gb.c
F:	drivers/staging/greybus/audio_manager.c
F:	drivers/staging/greybus/audio_manager.h
F:	drivers/staging/greybus/audio_manager_module.c
F:	drivers/staging/greybus/audio_manager_private.h
F:	drivers/staging/greybus/audio_manager_sysfs.c
F:	drivers/staging/greybus/audio_module.c
F:	drivers/staging/greybus/audio_topology.c

GREYBUS FW/HID/SPI PROTOCOLS DRIVERS
M:	Viresh Kumar <vireshk@kernel.org>
S:	Maintained
F:	drivers/staging/greybus/authentication.c
F:	drivers/staging/greybus/bootrom.c
F:	drivers/staging/greybus/firmware.h
F:	drivers/staging/greybus/fw-core.c
F:	drivers/staging/greybus/fw-download.c
F:	drivers/staging/greybus/fw-managament.c
F:	drivers/staging/greybus/greybus_authentication.h
F:	drivers/staging/greybus/greybus_firmware.h
F:	drivers/staging/greybus/hid.c
F:	drivers/staging/greybus/i2c.c
F:	drivers/staging/greybus/spi.c
F:	drivers/staging/greybus/spilib.c
F:	drivers/staging/greybus/spilib.h

GREYBUS LOOPBACK/TIME PROTOCOLS DRIVERS
M:	Bryan O'Donoghue <pure.logic@nexus-software.ie>
S:	Maintained
F:	drivers/staging/greybus/loopback.c
F:	drivers/staging/greybus/timesync.c
F:	drivers/staging/greybus/timesync_platform.c

GREYBUS PLATFORM DRIVERS
M:	Vaibhav Hiremath <hvaibhav.linux@gmail.com>
S:	Maintained
F:	drivers/staging/greybus/arche-platform.c
F:	drivers/staging/greybus/arche-apb-ctrl.c
F:	drivers/staging/greybus/arche_platform.h

GREYBUS SDIO/GPIO/SPI PROTOCOLS DRIVERS
M:	Rui Miguel Silva <rmfrfs@gmail.com>
S:	Maintained
F:	drivers/staging/greybus/sdio.c
F:	drivers/staging/greybus/light.c
F:	drivers/staging/greybus/gpio.c
F:	drivers/staging/greybus/power_supply.c
F:	drivers/staging/greybus/spi.c
F:	drivers/staging/greybus/spilib.c

GREYBUS SUBSYSTEM
M:	Johan Hovold <johan@kernel.org>
M:	Alex Elder <elder@kernel.org>
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
S:	Maintained
F:	drivers/staging/greybus/
L:	greybus-dev@lists.linaro.org (moderated for non-subscribers)

GREYBUS UART PROTOCOLS DRIVERS
M:	David Lin <dtwlin@gmail.com>
S:	Maintained
F:	drivers/staging/greybus/uart.c
F:	drivers/staging/greybus/log.c

GS1662 VIDEO SERIALIZER
M:	Charles-Antoine Couret <charles-antoine.couret@nexvision.fr>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/spi/gs1662.c

GSPCA FINEPIX SUBDRIVER
M:	Frank Zago <frank@zago.net>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/usb/gspca/finepix.c

GSPCA GL860 SUBDRIVER
M:	Olivier Lorin <o.lorin@laposte.net>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/usb/gspca/gl860/

GSPCA M5602 SUBDRIVER
M:	Erik Andren <erik.andren@gmail.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/usb/gspca/m5602/

GSPCA PAC207 SONIXB SUBDRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Odd Fixes
F:	drivers/media/usb/gspca/pac207.c

GSPCA SN9C20X SUBDRIVER
M:	Brian Johnson <brijohn@gmail.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/usb/gspca/sn9c20x.c

GSPCA T613 SUBDRIVER
M:	Leandro Costantino <lcostantino@gmail.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/usb/gspca/t613.c

GSPCA USB WEBCAM DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Odd Fixes
F:	drivers/media/usb/gspca/

GTP (GPRS Tunneling Protocol)
M:	Pablo Neira Ayuso <pablo@netfilter.org>
M:	Harald Welte <laforge@gnumonks.org>
L:	osmocom-net-gprs@lists.osmocom.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pablo/gtp.git
S:	Maintained
F:	drivers/net/gtp.c

GUID PARTITION TABLE (GPT)
M:	Davidlohr Bueso <dave@stgolabs.net>
L:	linux-efi@vger.kernel.org
S:	Maintained
F:	block/partitions/efi.*

H8/300 ARCHITECTURE
M:	Yoshinori Sato <ysato@users.sourceforge.jp>
L:	uclinux-h8-devel@lists.sourceforge.jp (moderated for non-subscribers)
W:	http://uclinux-h8.sourceforge.jp
T:	git git://git.sourceforge.jp/gitroot/uclinux-h8/linux.git
S:	Maintained
F:	arch/h8300/
F:	drivers/clocksource/h8300_*.c
F:	drivers/clk/h8300/
F:	drivers/irqchip/irq-renesas-h8*.c

HACKRF MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/usb/hackrf/

HARD DRIVE ACTIVE PROTECTION SYSTEM (HDAPS) DRIVER
M:	Frank Seidel <frank@f-seidel.de>
L:	platform-driver-x86@vger.kernel.org
W:	http://www.kernel.org/pub/linux/kernel/people/fseidel/hdaps/
S:	Maintained
F:	drivers/platform/x86/hdaps.c

HARDWARE MONITORING
M:	Jean Delvare <jdelvare@suse.com>
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
W:	http://hwmon.wiki.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging.git
S:	Maintained
F:	Documentation/devicetree/bindings/hwmon/
F:	Documentation/hwmon/
F:	drivers/hwmon/
F:	include/linux/hwmon*.h

HARDWARE RANDOM NUMBER GENERATOR CORE
M:	Matt Mackall <mpm@selenic.com>
M:	Herbert Xu <herbert@gondor.apana.org.au>
L:	linux-crypto@vger.kernel.org
S:	Odd fixes
F:	Documentation/devicetree/bindings/rng/
F:	Documentation/hw_random.txt
F:	drivers/char/hw_random/
F:	include/linux/hw_random.h

HARDWARE TRACING FACILITIES
M:	Alexander Shishkin <alexander.shishkin@linux.intel.com>
S:	Maintained
F:	drivers/hwtracing/

HARDWARE SPINLOCK CORE
M:	Ohad Ben-Cohen <ohad@wizery.com>
M:	Bjorn Andersson <bjorn.andersson@linaro.org>
L:	linux-remoteproc@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ohad/hwspinlock.git
F:	Documentation/devicetree/bindings/hwlock/
F:	Documentation/hwspinlock.txt
F:	drivers/hwspinlock/
F:	include/linux/hwspinlock.h

HARMONY SOUND DRIVER
L:	linux-parisc@vger.kernel.org
S:	Maintained
F:	sound/parisc/harmony.*

HDPVR USB VIDEO ENCODER DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Odd Fixes
F:	drivers/media/usb/hdpvr/

HEWLETT PACKARD ENTERPRISE ILO NMI WATCHDOG DRIVER
M:	Jerry Hoemann <jerry.hoemann@hpe.com>
S:	Supported
F:	Documentation/watchdog/hpwdt.txt
F:	drivers/watchdog/hpwdt.c

HEWLETT-PACKARD SMART ARRAY RAID DRIVER (hpsa)
M:	Don Brace <don.brace@microsemi.com>
L:	esc.storagedev@microsemi.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	Documentation/scsi/hpsa.txt
F:	drivers/scsi/hpsa*.[ch]
F:	include/linux/cciss*.h
F:	include/uapi/linux/cciss*.h

HFI1 DRIVER
M:	Mike Marciniszyn <mike.marciniszyn@intel.com>
M:	Dennis Dalessandro <dennis.dalessandro@intel.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
F:	drivers/infiniband/hw/hfi1

HFS FILESYSTEM
L:	linux-fsdevel@vger.kernel.org
S:	Orphan
F:	Documentation/filesystems/hfs.txt
F:	fs/hfs/

HFSPLUS FILESYSTEM
L:	linux-fsdevel@vger.kernel.org
S:	Orphan
F:	Documentation/filesystems/hfsplus.txt
F:	fs/hfsplus/

HGA FRAMEBUFFER DRIVER
M:	Ferenc Bakonyi <fero@drama.obuda.kando.hu>
L:	linux-nvidia@lists.surfsouth.com
W:	http://drama.obuda.kando.hu/~fero/cgi-bin/hgafb.shtml
S:	Maintained
F:	drivers/video/fbdev/hgafb.c

HIBERNATION (aka Software Suspend, aka swsusp)
M:	"Rafael J. Wysocki" <rjw@rjwysocki.net>
M:	Pavel Machek <pavel@ucw.cz>
L:	linux-pm@vger.kernel.org
B:	https://bugzilla.kernel.org
S:	Supported
F:	arch/x86/power/
F:	drivers/base/power/
F:	kernel/power/
F:	include/linux/suspend.h
F:	include/linux/freezer.h
F:	include/linux/pm.h
F:	arch/*/include/asm/suspend*.h

HID CORE LAYER
M:	Jiri Kosina <jikos@kernel.org>
R:	Benjamin Tissoires <benjamin.tissoires@redhat.com>
L:	linux-input@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid.git
S:	Maintained
F:	drivers/hid/
F:	include/linux/hid*
F:	include/uapi/linux/hid*

HID SENSOR HUB DRIVERS
M:	Jiri Kosina <jikos@kernel.org>
M:	Jonathan Cameron <jic23@kernel.org>
M:	Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
L:	linux-input@vger.kernel.org
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/hid/hid-sensor*
F:	drivers/hid/hid-sensor-*
F:	drivers/iio/*/hid-*
F:	include/linux/hid-sensor-*

HIGH-RESOLUTION TIMERS, CLOCKEVENTS
M:	Thomas Gleixner <tglx@linutronix.de>
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/core
S:	Maintained
F:	Documentation/timers/
F:	kernel/time/hrtimer.c
F:	kernel/time/clockevents.c
F:	kernel/time/timer_*.c
F:	include/linux/clockchips.h
F:	include/linux/hrtimer.h

HIGH-SPEED SCC DRIVER FOR AX.25
L:	linux-hams@vger.kernel.org
S:	Orphan
F:	drivers/net/hamradio/dmascc.c
F:	drivers/net/hamradio/scc.c

HIGHPOINT ROCKETRAID 3xxx RAID DRIVER
M:	HighPoint Linux Team <linux@highpoint-tech.com>
W:	http://www.highpoint-tech.com
S:	Supported
F:	Documentation/scsi/hptiop.txt
F:	drivers/scsi/hptiop.c

HIPPI
M:	Jes Sorensen <jes@trained-monkey.org>
L:	linux-hippi@sunsite.dk
S:	Maintained
F:	include/linux/hippidevice.h
F:	include/uapi/linux/if_hippi.h
F:	net/802/hippi.c
F:	drivers/net/hippi/

HISILICON NETWORK SUBSYSTEM 3 DRIVER (HNS3)
M:	Yisen Zhuang <yisen.zhuang@huawei.com>
M:	Salil Mehta <salil.mehta@huawei.com>
L:	netdev@vger.kernel.org
W:	http://www.hisilicon.com
S:	Maintained
F:	drivers/net/ethernet/hisilicon/hns3/

HISILICON LPC BUS DRIVER
M:	john.garry@huawei.com
W:	http://www.hisilicon.com
S:	Maintained
F:	drivers/bus/hisi_lpc.c
F:	Documentation/devicetree/bindings/arm/hisilicon/hisilicon-low-pin-count.txt

HISILICON NETWORK SUBSYSTEM DRIVER
M:	Yisen Zhuang <yisen.zhuang@huawei.com>
M:	Salil Mehta <salil.mehta@huawei.com>
L:	netdev@vger.kernel.org
W:	http://www.hisilicon.com
S:	Maintained
F:	drivers/net/ethernet/hisilicon/
F:	Documentation/devicetree/bindings/net/hisilicon*.txt

HISILICON PMU DRIVER
M:	Shaokun Zhang <zhangshaokun@hisilicon.com>
W:	http://www.hisilicon.com
S:	Supported
F:	drivers/perf/hisilicon
F:	Documentation/perf/hisi-pmu.txt

HISILICON ROCE DRIVER
M:	Lijun Ou <oulijun@huawei.com>
M:	Wei Hu(Xavier) <xavier.huwei@huawei.com>
L:	linux-rdma@vger.kernel.org
S:	Maintained
F:	drivers/infiniband/hw/hns/
F:	Documentation/devicetree/bindings/infiniband/hisilicon-hns-roce.txt

HISILICON SAS Controller
M:	John Garry <john.garry@huawei.com>
W:	http://www.hisilicon.com
S:	Supported
F:	drivers/scsi/hisi_sas/
F:	Documentation/devicetree/bindings/scsi/hisilicon-sas.txt

HMM - Heterogeneous Memory Management
M:	Jérôme Glisse <jglisse@redhat.com>
L:	linux-mm@kvack.org
S:	Maintained
F:	mm/hmm*
F:	include/linux/hmm*
F:	Documentation/vm/hmm.txt

HOST AP DRIVER
M:	Jouni Malinen <j@w1.fi>
L:	linux-wireless@vger.kernel.org
W:	http://w1.fi/hostap-driver.html
S:	Obsolete
F:	drivers/net/wireless/intersil/hostap/

HP COMPAQ TC1100 TABLET WMI EXTRAS DRIVER
L:	platform-driver-x86@vger.kernel.org
S:	Orphan
F:	drivers/platform/x86/tc1100-wmi.c

HP100:	Driver for HP 10/100 Mbit/s Voice Grade Network Adapter Series
M:	Jaroslav Kysela <perex@perex.cz>
S:	Maintained
F:	drivers/net/ethernet/hp/hp100.*

HPET:	High Precision Event Timers driver
M:	Clemens Ladisch <clemens@ladisch.de>
S:	Maintained
F:	Documentation/timers/hpet.txt
F:	drivers/char/hpet.c
F:	include/linux/hpet.h
F:	include/uapi/linux/hpet.h

HPET:	x86
S:	Orphan
F:	arch/x86/kernel/hpet.c
F:	arch/x86/include/asm/hpet.h

HPFS FILESYSTEM
M:	Mikulas Patocka <mikulas@artax.karlin.mff.cuni.cz>
W:	http://artax.karlin.mff.cuni.cz/~mikulas/vyplody/hpfs/index-e.cgi
S:	Maintained
F:	fs/hpfs/

HSI SUBSYSTEM
M:	Sebastian Reichel <sre@kernel.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sre/linux-hsi.git
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-hsi
F:	Documentation/driver-api/hsi.rst
F:	drivers/hsi/
F:	include/linux/hsi/
F:	include/uapi/linux/hsi/

HSO 3G MODEM DRIVER
L:	linux-usb@vger.kernel.org
S:	Orphan
F:	drivers/net/usb/hso.c

HSR NETWORK PROTOCOL
M:	Arvid Brodin <arvid.brodin@alten.se>
L:	netdev@vger.kernel.org
S:	Maintained
F:	net/hsr/

HT16K33 LED CONTROLLER DRIVER
M:	Robin van der Gracht <robin@protonic.nl>
S:	Maintained
F:	drivers/auxdisplay/ht16k33.c
F:	Documentation/devicetree/bindings/display/ht16k33.txt

HTCPEN TOUCHSCREEN DRIVER
M:	Pau Oliva Fora <pof@eslack.org>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/input/touchscreen/htcpen.c

HUAWEI ETHERNET DRIVER
M:	Aviad Krawczyk <aviad.krawczyk@huawei.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/hinic.txt
F:	drivers/net/ethernet/huawei/hinic/

HUGETLB FILESYSTEM
M:	Mike Kravetz <mike.kravetz@oracle.com>
L:	linux-mm@kvack.org
S:	Maintained
F:	fs/hugetlbfs/
F:	mm/hugetlb.c
F:	include/linux/hugetlb.h
F:	Documentation/admin-guide/mm/hugetlbpage.rst
F:	Documentation/vm/hugetlbfs_reserv.rst
F:	Documentation/ABI/testing/sysfs-kernel-mm-hugepages

HVA ST MEDIA DRIVER
M:	Jean-Christophe Trotin <jean-christophe.trotin@st.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Supported
F:	drivers/media/platform/sti/hva

HWPOISON MEMORY FAILURE HANDLING
M:	Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
L:	linux-mm@kvack.org
S:	Maintained
F:	mm/memory-failure.c
F:	mm/hwpoison-inject.c

Hyper-V CORE AND DRIVERS
M:	"K. Y. Srinivasan" <kys@microsoft.com>
M:	Haiyang Zhang <haiyangz@microsoft.com>
M:	Stephen Hemminger <sthemmin@microsoft.com>
L:	devel@linuxdriverproject.org
S:	Maintained
F:	Documentation/networking/netvsc.txt
F:	arch/x86/include/asm/mshyperv.h
F:	arch/x86/include/asm/trace/hyperv.h
F:	arch/x86/include/asm/hyperv-tlfs.h
F:	arch/x86/kernel/cpu/mshyperv.c
F:	arch/x86/hyperv
F:	drivers/hid/hid-hyperv.c
F:	drivers/hv/
F:	drivers/input/serio/hyperv-keyboard.c
F:	drivers/pci/controller/pci-hyperv.c
F:	drivers/net/hyperv/
F:	drivers/scsi/storvsc_drv.c
F:	drivers/uio/uio_hv_generic.c
F:	drivers/video/fbdev/hyperv_fb.c
F:	net/vmw_vsock/hyperv_transport.c
F:	include/linux/hyperv.h
F:	include/uapi/linux/hyperv.h
F:	tools/hv/
F:	Documentation/ABI/stable/sysfs-bus-vmbus

HYPERVISOR VIRTUAL CONSOLE DRIVER
L:	linuxppc-dev@lists.ozlabs.org
S:	Odd Fixes
F:	drivers/tty/hvc/

I2C ACPI SUPPORT
M:	Mika Westerberg <mika.westerberg@linux.intel.com>
L:	linux-i2c@vger.kernel.org
L:	linux-acpi@vger.kernel.org
S:	Maintained
F:	drivers/i2c/i2c-core-acpi.c

I2C MUXES
M:	Peter Rosin <peda@axentia.se>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/i2c/i2c-topology
F:	Documentation/i2c/muxes/
F:	Documentation/devicetree/bindings/i2c/i2c-mux*
F:	Documentation/devicetree/bindings/i2c/i2c-arb*
F:	Documentation/devicetree/bindings/i2c/i2c-gate*
F:	drivers/i2c/i2c-mux.c
F:	drivers/i2c/muxes/
F:	include/linux/i2c-mux.h

I2C MV64XXX MARVELL AND ALLWINNER DRIVER
M:	Gregory CLEMENT <gregory.clement@bootlin.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	drivers/i2c/busses/i2c-mv64xxx.c

I2C OVER PARALLEL PORT
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/i2c/busses/i2c-parport
F:	Documentation/i2c/busses/i2c-parport-light
F:	drivers/i2c/busses/i2c-parport.c
F:	drivers/i2c/busses/i2c-parport-light.c

I2C SUBSYSTEM
M:	Wolfram Sang <wsa@the-dreams.de>
L:	linux-i2c@vger.kernel.org
W:	https://i2c.wiki.kernel.org/
Q:	https://patchwork.ozlabs.org/project/linux-i2c/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/wsa/linux.git
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/i2c.txt
F:	Documentation/i2c/
F:	drivers/i2c/*
F:	include/linux/i2c.h
F:	include/linux/i2c-dev.h
F:	include/linux/i2c-smbus.h
F:	include/uapi/linux/i2c.h
F:	include/uapi/linux/i2c-*.h

I2C SUBSYSTEM HOST DRIVERS
L:	linux-i2c@vger.kernel.org
W:	https://i2c.wiki.kernel.org/
Q:	https://patchwork.ozlabs.org/project/linux-i2c/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/wsa/linux.git
S:	Odd Fixes
F:	Documentation/devicetree/bindings/i2c/
F:	drivers/i2c/algos/
F:	drivers/i2c/busses/

I2C-TAOS-EVM DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/i2c/busses/i2c-taos-evm
F:	drivers/i2c/busses/i2c-taos-evm.c

I2C-TINY-USB DRIVER
M:	Till Harbaum <till@harbaum.org>
L:	linux-i2c@vger.kernel.org
W:	http://www.harbaum.org/till/i2c_tiny_usb
S:	Maintained
F:	drivers/i2c/busses/i2c-tiny-usb.c

I2C/SMBUS CONTROLLER DRIVERS FOR PC
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/i2c/busses/i2c-ali1535
F:	Documentation/i2c/busses/i2c-ali1563
F:	Documentation/i2c/busses/i2c-ali15x3
F:	Documentation/i2c/busses/i2c-amd756
F:	Documentation/i2c/busses/i2c-amd8111
F:	Documentation/i2c/busses/i2c-i801
F:	Documentation/i2c/busses/i2c-nforce2
F:	Documentation/i2c/busses/i2c-piix4
F:	Documentation/i2c/busses/i2c-sis5595
F:	Documentation/i2c/busses/i2c-sis630
F:	Documentation/i2c/busses/i2c-sis96x
F:	Documentation/i2c/busses/i2c-via
F:	Documentation/i2c/busses/i2c-viapro
F:	drivers/i2c/busses/i2c-ali1535.c
F:	drivers/i2c/busses/i2c-ali1563.c
F:	drivers/i2c/busses/i2c-ali15x3.c
F:	drivers/i2c/busses/i2c-amd756.c
F:	drivers/i2c/busses/i2c-amd756-s4882.c
F:	drivers/i2c/busses/i2c-amd8111.c
F:	drivers/i2c/busses/i2c-i801.c
F:	drivers/i2c/busses/i2c-isch.c
F:	drivers/i2c/busses/i2c-nforce2.c
F:	drivers/i2c/busses/i2c-nforce2-s4985.c
F:	drivers/i2c/busses/i2c-piix4.c
F:	drivers/i2c/busses/i2c-sis5595.c
F:	drivers/i2c/busses/i2c-sis630.c
F:	drivers/i2c/busses/i2c-sis96x.c
F:	drivers/i2c/busses/i2c-via.c
F:	drivers/i2c/busses/i2c-viapro.c

I2C/SMBUS INTEL CHT WHISKEY COVE PMIC DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	drivers/i2c/busses/i2c-cht-wc.c

I2C/SMBUS ISMT DRIVER
M:	Seth Heasley <seth.heasley@intel.com>
M:	Neil Horman <nhorman@tuxdriver.com>
L:	linux-i2c@vger.kernel.org
F:	drivers/i2c/busses/i2c-ismt.c
F:	Documentation/i2c/busses/i2c-ismt

I2C/SMBUS STUB DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	drivers/i2c/i2c-stub.c

IA64 (Itanium) PLATFORM
M:	Tony Luck <tony.luck@intel.com>
M:	Fenghua Yu <fenghua.yu@intel.com>
L:	linux-ia64@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux.git
S:	Maintained
F:	arch/ia64/

IBM Power 842 compression accelerator
M:	Haren Myneni <haren@us.ibm.com>
S:	Supported
F:	drivers/crypto/nx/Makefile
F:	drivers/crypto/nx/Kconfig
F:	drivers/crypto/nx/nx-842*
F:	include/linux/sw842.h
F:	crypto/842.c
F:	lib/842/

IBM Power in-Nest Crypto Acceleration
M:	Leonidas S. Barbosa <leosilva@linux.vnet.ibm.com>
M:	Paulo Flabiano Smorigo <pfsmorigo@linux.vnet.ibm.com>
L:	linux-crypto@vger.kernel.org
S:	Supported
F:	drivers/crypto/nx/Makefile
F:	drivers/crypto/nx/Kconfig
F:	drivers/crypto/nx/nx-aes*
F:	drivers/crypto/nx/nx-sha*
F:	drivers/crypto/nx/nx.*
F:	drivers/crypto/nx/nx_csbcpb.h
F:	drivers/crypto/nx/nx_debugfs.h

IBM Power Linux RAID adapter
M:	Brian King <brking@us.ibm.com>
S:	Supported
F:	drivers/scsi/ipr.*

IBM Power SRIOV Virtual NIC Device Driver
M:	Thomas Falcon <tlfalcon@linux.vnet.ibm.com>
M:	John Allen <jallen@linux.vnet.ibm.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/ibm/ibmvnic.*

IBM Power Virtual Accelerator Switchboard
M:	Sukadev Bhattiprolu
L:	linuxppc-dev@lists.ozlabs.org
S:	Supported
F:	arch/powerpc/platforms/powernv/vas*
F:	arch/powerpc/platforms/powernv/copy-paste.h
F:	arch/powerpc/include/asm/vas.h
F:	arch/powerpc/include/uapi/asm/vas.h

IBM Power Virtual Ethernet Device Driver
M:	Thomas Falcon <tlfalcon@linux.vnet.ibm.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/ibm/ibmveth.*

IBM Power Virtual FC Device Drivers
M:	Tyrel Datwyler <tyreld@linux.vnet.ibm.com>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/ibmvscsi/ibmvfc*

IBM Power Virtual Management Channel Driver
M:	Bryant G. Ly <bryantly@linux.vnet.ibm.com>
M:	Steven Royer <seroyer@linux.vnet.ibm.com>
S:	Supported
F:	drivers/misc/ibmvmc.*

IBM Power Virtual SCSI Device Drivers
M:	Tyrel Datwyler <tyreld@linux.vnet.ibm.com>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/ibmvscsi/ibmvscsi*
F:	include/scsi/viosrp.h

IBM Power Virtual SCSI Device Target Driver
M:	Bryant G. Ly <bryantly@linux.vnet.ibm.com>
M:	Michael Cyr <mikecyr@linux.vnet.ibm.com>
L:	linux-scsi@vger.kernel.org
L:	target-devel@vger.kernel.org
S:	Supported
F:	drivers/scsi/ibmvscsi_tgt/

IBM Power VMX Cryptographic instructions
M:	Leonidas S. Barbosa <leosilva@linux.vnet.ibm.com>
M:	Paulo Flabiano Smorigo <pfsmorigo@linux.vnet.ibm.com>
L:	linux-crypto@vger.kernel.org
S:	Supported
F:	drivers/crypto/vmx/Makefile
F:	drivers/crypto/vmx/Kconfig
F:	drivers/crypto/vmx/vmx.c
F:	drivers/crypto/vmx/aes*
F:	drivers/crypto/vmx/ghash*
F:	drivers/crypto/vmx/ppc-xlate.pl

IBM ServeRAID RAID DRIVER
S:	Orphan
F:	drivers/scsi/ips.*

ICH LPC AND GPIO DRIVER
M:	Peter Tyser <ptyser@xes-inc.com>
S:	Maintained
F:	drivers/mfd/lpc_ich.c
F:	drivers/gpio/gpio-ich.c

IDE SUBSYSTEM
M:	"David S. Miller" <davem@davemloft.net>
L:	linux-ide@vger.kernel.org
Q:	http://patchwork.ozlabs.org/project/linux-ide/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/davem/ide.git
S:	Maintained
F:	Documentation/ide/
F:	drivers/ide/
F:	include/linux/ide.h

IDE/ATAPI DRIVERS
M:	Borislav Petkov <bp@alien8.de>
L:	linux-ide@vger.kernel.org
S:	Maintained
F:	Documentation/cdrom/ide-cd
F:	drivers/ide/ide-cd*

IDEAPAD LAPTOP EXTRAS DRIVER
M:	Ike Panhc <ike.pan@canonical.com>
L:	platform-driver-x86@vger.kernel.org
W:	http://launchpad.net/ideapad-laptop
S:	Maintained
F:	drivers/platform/x86/ideapad-laptop.c

IDEAPAD LAPTOP SLIDEBAR DRIVER
M:	Andrey Moiseev <o2g.org.ru@gmail.com>
L:	linux-input@vger.kernel.org
W:	https://github.com/o2genum/ideapad-slidebar
S:	Maintained
F:	drivers/input/misc/ideapad_slidebar.c

IDT VersaClock 5 CLOCK DRIVER
M:	Marek Vasut <marek.vasut@gmail.com>
S:	Maintained
F:	drivers/clk/clk-versaclock5.c

IEEE 802.15.4 SUBSYSTEM
M:	Alexander Aring <alex.aring@gmail.com>
M:	Stefan Schmidt <stefan@osg.samsung.com>
L:	linux-wpan@vger.kernel.org
W:	http://wpan.cakelab.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sschmidt/wpan.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sschmidt/wpan-next.git
S:	Maintained
F:	net/ieee802154/
F:	net/mac802154/
F:	drivers/net/ieee802154/
F:	include/linux/nl802154.h
F:	include/linux/ieee802154.h
F:	include/net/nl802154.h
F:	include/net/mac802154.h
F:	include/net/af_ieee802154.h
F:	include/net/cfg802154.h
F:	include/net/ieee802154_netdev.h
F:	Documentation/networking/ieee802154.txt

IFE PROTOCOL
M:	Yotam Gigi <yotam.gi@gmail.com>
M:	Jamal Hadi Salim <jhs@mojatatu.com>
F:	net/ife
F:	include/net/ife.h
F:	include/uapi/linux/ife.h

IGORPLUG-USB IR RECEIVER
M:	Sean Young <sean@mess.org>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/rc/igorplugusb.c

IGUANAWORKS USB IR TRANSCEIVER
M:	Sean Young <sean@mess.org>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/rc/iguanair.c

IIO DIGITAL POTENTIOMETER DAC
M:	Peter Rosin <peda@axentia.se>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-iio-dac-dpot-dac
F:	Documentation/devicetree/bindings/iio/dac/dpot-dac.txt
F:	drivers/iio/dac/dpot-dac.c

IIO ENVELOPE DETECTOR
M:	Peter Rosin <peda@axentia.se>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-iio-adc-envelope-detector
F:	Documentation/devicetree/bindings/iio/adc/envelope-detector.txt
F:	drivers/iio/adc/envelope-detector.c

IIO MULTIPLEXER
M:	Peter Rosin <peda@axentia.se>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/multiplexer/iio-mux.txt
F:	drivers/iio/multiplexer/iio-mux.c

IIO SUBSYSTEM AND DRIVERS
M:	Jonathan Cameron <jic23@kernel.org>
R:	Hartmut Knaack <knaack.h@gmx.de>
R:	Lars-Peter Clausen <lars@metafoo.de>
R:	Peter Meerwald-Stadler <pmeerw@pmeerw.net>
L:	linux-iio@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jic23/iio.git
S:	Maintained
F:	Documentation/ABI/testing/configfs-iio*
F:	Documentation/ABI/testing/sysfs-bus-iio*
F:	Documentation/devicetree/bindings/iio/
F:	drivers/iio/
F:	drivers/staging/iio/
F:	include/linux/iio/
F:	tools/iio/

IIO UNIT CONVERTER
M:	Peter Rosin <peda@axentia.se>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/afe/current-sense-amplifier.txt
F:	Documentation/devicetree/bindings/iio/afe/current-sense-shunt.txt
F:	Documentation/devicetree/bindings/iio/afe/voltage-divider.txt
F:	drivers/iio/afe/iio-rescale.c

IKANOS/ADI EAGLE ADSL USB DRIVER
M:	Matthieu Castet <castet.matthieu@free.fr>
M:	Stanislaw Gruszka <stf_xl@wp.pl>
S:	Maintained
F:	drivers/usb/atm/ueagle-atm.c

IMGTEC ASCII LCD DRIVER
M:	Paul Burton <paul.burton@mips.com>
S:	Maintained
F:	Documentation/devicetree/bindings/auxdisplay/img-ascii-lcd.txt
F:	drivers/auxdisplay/img-ascii-lcd.c

IMGTEC IR DECODER DRIVER
M:	James Hogan <jhogan@kernel.org>
S:	Maintained
F:	drivers/media/rc/img-ir/

IMON SOUNDGRAPH USB IR RECEIVER
M:	Sean Young <sean@mess.org>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/rc/imon_raw.c
F:	drivers/media/rc/imon.c

IMS TWINTURBO FRAMEBUFFER DRIVER
L:	linux-fbdev@vger.kernel.org
S:	Orphan
F:	drivers/video/fbdev/imsttfb.c

INA209 HARDWARE MONITOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/ina209
F:	Documentation/devicetree/bindings/i2c/ina209.txt
F:	drivers/hwmon/ina209.c

INA2XX HARDWARE MONITOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/ina2xx
F:	drivers/hwmon/ina2xx.c
F:	include/linux/platform_data/ina2xx.h

INDUSTRY PACK SUBSYSTEM (IPACK)
M:	Samuel Iglesias Gonsalvez <siglesias@igalia.com>
M:	Jens Taprogge <jens.taprogge@taprogge.org>
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
L:	industrypack-devel@lists.sourceforge.net
W:	http://industrypack.sourceforge.net
S:	Maintained
F:	drivers/ipack/

INFINIBAND SUBSYSTEM
M:	Doug Ledford <dledford@redhat.com>
M:	Jason Gunthorpe <jgg@mellanox.com>
L:	linux-rdma@vger.kernel.org
W:	https://github.com/linux-rdma/rdma-core
Q:	http://patchwork.kernel.org/project/linux-rdma/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rdma/rdma.git
S:	Supported
F:	Documentation/devicetree/bindings/infiniband/
F:	Documentation/infiniband/
F:	drivers/infiniband/
F:	include/uapi/linux/if_infiniband.h
F:	include/uapi/rdma/
F:	include/rdma/

INGENIC JZ4780 DMA Driver
M:	Zubair Lutfullah Kakakhel <Zubair.Kakakhel@imgtec.com>
S:	Maintained
F:	drivers/dma/dma-jz4780.c

INGENIC JZ4780 NAND DRIVER
M:	Harvey Hunt <harveyhuntnexus@gmail.com>
L:	linux-mtd@lists.infradead.org
S:	Maintained
F:	drivers/mtd/nand/raw/jz4780_*

INOTIFY
M:	Jan Kara <jack@suse.cz>
R:	Amir Goldstein <amir73il@gmail.com>
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
F:	Documentation/filesystems/inotify.txt
F:	fs/notify/inotify/
F:	include/linux/inotify.h
F:	include/uapi/linux/inotify.h

INPUT (KEYBOARD, MOUSE, JOYSTICK, TOUCHSCREEN) DRIVERS
M:	Dmitry Torokhov <dmitry.torokhov@gmail.com>
L:	linux-input@vger.kernel.org
Q:	http://patchwork.kernel.org/project/linux-input/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git
S:	Maintained
F:	drivers/input/
F:	include/linux/input.h
F:	include/uapi/linux/input.h
F:	include/uapi/linux/input-event-codes.h
F:	include/linux/input/
F:	Documentation/devicetree/bindings/input/
F:	Documentation/input/

INPUT MULTITOUCH (MT) PROTOCOL
M:	Henrik Rydberg <rydberg@bitmath.org>
L:	linux-input@vger.kernel.org
S:	Odd fixes
F:	Documentation/input/multi-touch-protocol.rst
F:	drivers/input/input-mt.c
K:	\b(ABS|SYN)_MT_

INSIDE SECURE CRYPTO DRIVER
M:	Antoine Tenart <antoine.tenart@bootlin.com>
F:	drivers/crypto/inside-secure/
S:	Maintained
L:	linux-crypto@vger.kernel.org

INTEGRITY MEASUREMENT ARCHITECTURE (IMA)
M:	Mimi Zohar <zohar@linux.vnet.ibm.com>
M:	Dmitry Kasatkin <dmitry.kasatkin@gmail.com>
L:	linux-integrity@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/zohar/linux-integrity.git
S:	Supported
F:	security/integrity/ima/

INTEL 810/815 FRAMEBUFFER DRIVER
M:	Antonino Daplas <adaplas@gmail.com>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	drivers/video/fbdev/i810/

INTEL ASoC DRIVERS
M:	Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
M:	Liam Girdwood <liam.r.girdwood@linux.intel.com>
M:	Jie Yang <yang.jie@linux.intel.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Supported
F:	sound/soc/intel/

INTEL C600 SERIES SAS CONTROLLER DRIVER
M:	Intel SCU Linux support <intel-linux-scu@intel.com>
M:	Artur Paszkiewicz <artur.paszkiewicz@intel.com>
L:	linux-scsi@vger.kernel.org
T:	git git://git.code.sf.net/p/intel-sas/isci
S:	Supported
F:	drivers/scsi/isci/

INTEL DRM DRIVERS (excluding Poulsbo, Moorestown and derivative chipsets)
M:	Jani Nikula <jani.nikula@linux.intel.com>
M:	Joonas Lahtinen <joonas.lahtinen@linux.intel.com>
M:	Rodrigo Vivi <rodrigo.vivi@intel.com>
L:	intel-gfx@lists.freedesktop.org
W:	https://01.org/linuxgraphics/
B:	https://01.org/linuxgraphics/documentation/how-report-bugs
C:	irc://chat.freenode.net/intel-gfx
Q:	http://patchwork.freedesktop.org/project/intel-gfx/
T:	git git://anongit.freedesktop.org/drm-intel
S:	Supported
F:	drivers/gpu/drm/i915/
F:	include/drm/i915*
F:	include/uapi/drm/i915_drm.h
F:	Documentation/gpu/i915.rst

INTEL ETHERNET DRIVERS
M:	Jeff Kirsher <jeffrey.t.kirsher@intel.com>
L:	intel-wired-lan@lists.osuosl.org (moderated for non-subscribers)
W:	http://www.intel.com/support/feedback.htm
W:	http://e1000.sourceforge.net/
Q:	http://patchwork.ozlabs.org/project/intel-wired-lan/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jkirsher/net-queue.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jkirsher/next-queue.git
S:	Supported
F:	Documentation/networking/e100.rst
F:	Documentation/networking/e1000.rst
F:	Documentation/networking/e1000e.txt
F:	Documentation/networking/igb.txt
F:	Documentation/networking/igbvf.txt
F:	Documentation/networking/ixgb.txt
F:	Documentation/networking/ixgbe.txt
F:	Documentation/networking/ixgbevf.txt
F:	Documentation/networking/i40e.txt
F:	Documentation/networking/i40evf.txt
F:	Documentation/networking/ice.txt
F:	drivers/net/ethernet/intel/
F:	drivers/net/ethernet/intel/*/
F:	include/linux/avf/virtchnl.h

INTEL FRAMEBUFFER DRIVER (excluding 810 and 815)
M:	Maik Broemme <mbroemme@libmpq.org>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	Documentation/fb/intelfb.txt
F:	drivers/video/fbdev/intelfb/

INTEL GVT-g DRIVERS (Intel GPU Virtualization)
M:	Zhenyu Wang <zhenyuw@linux.intel.com>
M:	Zhi Wang <zhi.a.wang@intel.com>
L:	intel-gvt-dev@lists.freedesktop.org
L:	intel-gfx@lists.freedesktop.org
W:	https://01.org/igvt-g
T:	git https://github.com/intel/gvt-linux.git
S:	Supported
F:	drivers/gpu/drm/i915/gvt/

INTEL HID EVENT DRIVER
M:	Alex Hung <alex.hung@canonical.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/intel-hid.c

INTEL I/OAT DMA DRIVER
M:	Dave Jiang <dave.jiang@intel.com>
R:	Dan Williams <dan.j.williams@intel.com>
L:	dmaengine@vger.kernel.org
Q:	https://patchwork.kernel.org/project/linux-dmaengine/list/
S:	Supported
F:	drivers/dma/ioat*

INTEL IDLE DRIVER
M:	Jacob Pan <jacob.jun.pan@linux.intel.com>
M:	Len Brown <lenb@kernel.org>
L:	linux-pm@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux.git
B:	https://bugzilla.kernel.org
S:	Supported
F:	drivers/idle/intel_idle.c

INTEL INTEGRATED SENSOR HUB DRIVER
M:	Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
M:	Jiri Kosina <jikos@kernel.org>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/hid/intel-ish-hid/

INTEL IOMMU (VT-d)
M:	David Woodhouse <dwmw2@infradead.org>
L:	iommu@lists.linux-foundation.org
T:	git git://git.infradead.org/iommu-2.6.git
S:	Supported
F:	drivers/iommu/intel-iommu.c
F:	include/linux/intel-iommu.h

INTEL IOP-ADMA DMA DRIVER
R:	Dan Williams <dan.j.williams@intel.com>
S:	Odd fixes
F:	drivers/dma/iop-adma.c

INTEL IPU3 CSI-2 CIO2 DRIVER
M:	Yong Zhi <yong.zhi@intel.com>
M:	Sakari Ailus <sakari.ailus@linux.intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/pci/intel/ipu3/
F:	Documentation/media/uapi/v4l/pixfmt-srggb10-ipu3.rst

INTEL IXP4XX QMGR, NPE, ETHERNET and HSS SUPPORT
M:	Krzysztof Halasa <khalasa@piap.pl>
S:	Maintained
F:	arch/arm/mach-ixp4xx/include/mach/qmgr.h
F:	arch/arm/mach-ixp4xx/include/mach/npe.h
F:	arch/arm/mach-ixp4xx/ixp4xx_qmgr.c
F:	arch/arm/mach-ixp4xx/ixp4xx_npe.c
F:	drivers/net/ethernet/xscale/ixp4xx_eth.c
F:	drivers/net/wan/ixp4xx_hss.c

INTEL IXP4XX RANDOM NUMBER GENERATOR SUPPORT
M:	Deepak Saxena <dsaxena@plexity.net>
S:	Maintained
F:	drivers/char/hw_random/ixp4xx-rng.c

INTEL MANAGEMENT ENGINE (mei)
M:	Tomas Winkler <tomas.winkler@intel.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	include/uapi/linux/mei.h
F:	include/linux/mei_cl_bus.h
F:	drivers/misc/mei/*
F:	drivers/watchdog/mei_wdt.c
F:	Documentation/misc-devices/mei/*
F:	samples/mei/*

INTEL MENLOW THERMAL DRIVER
M:	Sujith Thomas <sujith.thomas@intel.com>
L:	platform-driver-x86@vger.kernel.org
W:	https://01.org/linux-acpi
S:	Supported
F:	drivers/platform/x86/intel_menlow.c

INTEL MERRIFIELD GPIO DRIVER
M:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-merrifield.c

INTEL MIC DRIVERS (mic)
M:	Sudeep Dutt <sudeep.dutt@intel.com>
M:	Ashutosh Dixit <ashutosh.dixit@intel.com>
S:	Supported
W:	https://github.com/sudeepdutt/mic
W:	http://software.intel.com/en-us/mic-developer
F:	include/linux/mic_bus.h
F:	include/linux/scif.h
F:	include/uapi/linux/mic_common.h
F:	include/uapi/linux/mic_ioctl.h
F:	include/uapi/linux/scif_ioctl.h
F:	drivers/misc/mic/
F:	drivers/dma/mic_x100_dma.c
F:	drivers/dma/mic_x100_dma.h
F:	Documentation/mic/

INTEL PMC CORE DRIVER
M:	Rajneesh Bhardwaj <rajneesh.bhardwaj@intel.com>
M:	Vishwanath Somayaji <vishwanath.somayaji@intel.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	arch/x86/include/asm/pmc_core.h
F:	drivers/platform/x86/intel_pmc_core*

INTEL PMC/P-Unit IPC DRIVER
M:	Zha Qipeng<qipeng.zha@intel.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/intel_pmc_ipc.c
F:	drivers/platform/x86/intel_punit_ipc.c
F:	arch/x86/include/asm/intel_pmc_ipc.h
F:	arch/x86/include/asm/intel_punit_ipc.h

INTEL PRO/WIRELESS 2100, 2200BG, 2915ABG NETWORK CONNECTION SUPPORT
M:	Stanislav Yakovlev <stas.yakovlev@gmail.com>
L:	linux-wireless@vger.kernel.org
S:	Maintained
F:	Documentation/networking/README.ipw2100
F:	Documentation/networking/README.ipw2200
F:	drivers/net/wireless/intel/ipw2x00/

INTEL PSTATE DRIVER
M:	Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
M:	Len Brown <lenb@kernel.org>
L:	linux-pm@vger.kernel.org
S:	Supported
F:	drivers/cpufreq/intel_pstate.c

INTEL RDMA RNIC DRIVER
M:	Faisal Latif <faisal.latif@intel.com>
M:	Shiraz Saleem <shiraz.saleem@intel.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
F:	drivers/infiniband/hw/i40iw/
F:	include/uapi/rdma/i40iw-abi.h

INTEL SHA MULTIBUFFER DRIVER
M:	Megha Dey <megha.dey@linux.intel.com>
R:	Tim Chen <tim.c.chen@linux.intel.com>
L:	linux-crypto@vger.kernel.org
S:	Supported
F:	arch/x86/crypto/sha*-mb
F:	crypto/mcryptd.c

INTEL TELEMETRY DRIVER
M:	Souvik Kumar Chakravarty <souvik.k.chakravarty@intel.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	arch/x86/include/asm/intel_telemetry.h
F:	drivers/platform/x86/intel_telemetry*

INTEL VIRTUAL BUTTON DRIVER
M:	AceLan Kao <acelan.kao@canonical.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/intel-vbtn.c

INTEL WIRELESS 3945ABG/BG, 4965AGN (iwlegacy)
M:	Stanislaw Gruszka <sgruszka@redhat.com>
L:	linux-wireless@vger.kernel.org
S:	Supported
F:	drivers/net/wireless/intel/iwlegacy/

INTEL WIRELESS WIFI LINK (iwlwifi)
M:	Johannes Berg <johannes.berg@intel.com>
M:	Emmanuel Grumbach <emmanuel.grumbach@intel.com>
M:	Luca Coelho <luciano.coelho@intel.com>
M:	Intel Linux Wireless <linuxwifi@intel.com>
L:	linux-wireless@vger.kernel.org
W:	http://intellinuxwireless.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/iwlwifi/iwlwifi.git
S:	Supported
F:	drivers/net/wireless/intel/iwlwifi/

INTEL WIRELESS WIMAX CONNECTION 2400
M:	Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
M:	linux-wimax@intel.com
L:	wimax@linuxwimax.org (subscribers-only)
S:	Supported
W:	http://linuxwimax.org
F:	Documentation/wimax/README.i2400m
F:	drivers/net/wimax/i2400m/
F:	include/uapi/linux/wimax/i2400m.h

INTEL WMI THUNDERBOLT FORCE POWER DRIVER
M:	Mario Limonciello <mario.limonciello@dell.com>
S:	Maintained
F:	drivers/platform/x86/intel-wmi-thunderbolt.c

INTEL(R) TRACE HUB
M:	Alexander Shishkin <alexander.shishkin@linux.intel.com>
S:	Supported
F:	Documentation/trace/intel_th.txt
F:	drivers/hwtracing/intel_th/

INTEL(R) TRUSTED EXECUTION TECHNOLOGY (TXT)
M:	Ning Sun <ning.sun@intel.com>
L:	tboot-devel@lists.sourceforge.net
W:	http://tboot.sourceforge.net
T:	hg http://tboot.hg.sourceforge.net:8000/hgroot/tboot/tboot
S:	Supported
F:	Documentation/intel_txt.txt
F:	include/linux/tboot.h
F:	arch/x86/kernel/tboot.c

INTEL-MID GPIO DRIVER
M:	David Cohen <david.a.cohen@linux.intel.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-intel-mid.c

INVENSENSE MPU-3050 GYROSCOPE DRIVER
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	drivers/iio/gyro/mpu3050*
F:	Documentation/devicetree/bindings/iio/gyroscope/inv,mpu3050.txt

IOC3 ETHERNET DRIVER
M:	Ralf Baechle <ralf@linux-mips.org>
L:	linux-mips@linux-mips.org
S:	Maintained
F:	drivers/net/ethernet/sgi/ioc3-eth.c

IOC3 SERIAL DRIVER
M:	Pat Gefre <pfg@sgi.com>
L:	linux-serial@vger.kernel.org
S:	Maintained
F:	drivers/tty/serial/ioc3_serial.c

IOMMU DRIVERS
M:	Joerg Roedel <joro@8bytes.org>
L:	iommu@lists.linux-foundation.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git
S:	Maintained
F:	Documentation/devicetree/bindings/iommu/
F:	drivers/iommu/
F:	include/linux/iommu.h
F:	include/linux/of_iommu.h
F:	include/linux/iova.h

IP MASQUERADING
M:	Juanjo Ciarlante <jjciarla@raiz.uncu.edu.ar>
S:	Maintained
F:	net/ipv4/netfilter/ipt_MASQUERADE.c

IPMI SUBSYSTEM
M:	Corey Minyard <minyard@acm.org>
L:	openipmi-developer@lists.sourceforge.net (moderated for non-subscribers)
W:	http://openipmi.sourceforge.net/
S:	Supported
F:	Documentation/IPMI.txt
F:	drivers/char/ipmi/
F:	include/linux/ipmi*
F:	include/uapi/linux/ipmi*

IPS SCSI RAID DRIVER
M:	Adaptec OEM Raid Solutions <aacraid@microsemi.com>
L:	linux-scsi@vger.kernel.org
W:	http://www.adaptec.com/
S:	Maintained
F:	drivers/scsi/ips*

IPVS
M:	Wensong Zhang <wensong@linux-vs.org>
M:	Simon Horman <horms@verge.net.au>
M:	Julian Anastasov <ja@ssi.bg>
L:	netdev@vger.kernel.org
L:	lvs-devel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/horms/ipvs-next.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/horms/ipvs.git
F:	Documentation/networking/ipvs-sysctl.txt
F:	include/net/ip_vs.h
F:	include/uapi/linux/ip_vs.h
F:	net/netfilter/ipvs/

IPWIRELESS DRIVER
M:	Jiri Kosina <jikos@kernel.org>
M:	David Sterba <dsterba@suse.com>
S:	Odd Fixes
F:	drivers/tty/ipwireless/

IPX NETWORK LAYER
L:	netdev@vger.kernel.org
S:	Obsolete
F:	include/uapi/linux/ipx.h
F:	drivers/staging/ipx/

IRQ DOMAINS (IRQ NUMBER MAPPING LIBRARY)
M:	Marc Zyngier <marc.zyngier@arm.com>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git irq/core
F:	Documentation/IRQ-domain.txt
F:	include/linux/irqdomain.h
F:	kernel/irq/irqdomain.c
F:	kernel/irq/msi.c

IRQ SUBSYSTEM
M:	Thomas Gleixner <tglx@linutronix.de>
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git irq/core
F:	kernel/irq/

IRQCHIP DRIVERS
M:	Thomas Gleixner <tglx@linutronix.de>
M:	Jason Cooper <jason@lakedaemon.net>
M:	Marc Zyngier <marc.zyngier@arm.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git irq/core
F:	Documentation/devicetree/bindings/interrupt-controller/
F:	drivers/irqchip/

ISA
M:	William Breathitt Gray <vilhelm.gray@gmail.com>
S:	Maintained
F:	Documentation/isa.txt
F:	drivers/base/isa.c
F:	include/linux/isa.h

ISA RADIO MODULE
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/radio/radio-isa*

ISAPNP
M:	Jaroslav Kysela <perex@perex.cz>
S:	Maintained
F:	Documentation/isapnp.txt
F:	drivers/pnp/isapnp/
F:	include/linux/isapnp.h

ISCSI
M:	Lee Duncan <lduncan@suse.com>
M:	Chris Leech <cleech@redhat.com>
L:	open-iscsi@googlegroups.com
W:	www.open-iscsi.com
S:	Maintained
F:	drivers/scsi/*iscsi*
F:	include/scsi/*iscsi*

iSCSI BOOT FIRMWARE TABLE (iBFT) DRIVER
M:	Peter Jones <pjones@redhat.com>
M:	Konrad Rzeszutek Wilk <konrad@kernel.org>
S:	Maintained
F:	drivers/firmware/iscsi_ibft*

ISCSI EXTENSIONS FOR RDMA (ISER) INITIATOR
M:	Or Gerlitz <ogerlitz@mellanox.com>
M:	Sagi Grimberg <sagi@grimberg.me>
M:	Roi Dayan <roid@mellanox.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
W:	http://www.openfabrics.org
W:	www.open-iscsi.org
Q:	http://patchwork.kernel.org/project/linux-rdma/list/
F:	drivers/infiniband/ulp/iser/

ISCSI EXTENSIONS FOR RDMA (ISER) TARGET
M:	Sagi Grimberg <sagi@grimberg.me>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending.git master
L:	linux-rdma@vger.kernel.org
L:	target-devel@vger.kernel.org
S:	Supported
W:	http://www.linux-iscsi.org
F:	drivers/infiniband/ulp/isert

ISDN SUBSYSTEM
M:	Karsten Keil <isdn@linux-pingi.de>
L:	isdn4linux@listserv.isdn4linux.de (subscribers-only)
L:	netdev@vger.kernel.org
W:	http://www.isdn4linux.de
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kkeil/isdn-2.6.git
S:	Maintained
F:	Documentation/isdn/
F:	drivers/isdn/
F:	include/linux/isdn.h
F:	include/linux/isdn/
F:	include/uapi/linux/isdn.h
F:	include/uapi/linux/isdn/

ISDN SUBSYSTEM (Eicon active card driver)
M:	Armin Schindler <mac@melware.de>
L:	isdn4linux@listserv.isdn4linux.de (subscribers-only)
W:	http://www.melware.de
S:	Maintained
F:	drivers/isdn/hardware/eicon/

IT87 HARDWARE MONITORING DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/it87
F:	drivers/hwmon/it87.c

IT913X MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/tuners/it913x*

IVTV VIDEO4LINUX DRIVER
M:	Andy Walls <awalls@md.metrocast.net>
L:	ivtv-devel@ivtvdriver.org (subscribers-only)
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	http://www.ivtvdriver.org
S:	Maintained
F:	Documentation/media/v4l-drivers/ivtv*
F:	drivers/media/pci/ivtv/
F:	include/uapi/linux/ivtv*

IX2505V MEDIA DRIVER
M:	Malcolm Priestley <tvboxspy@gmail.com>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
S:	Maintained
F:	drivers/media/dvb-frontends/ix2505v*

JAILHOUSE HYPERVISOR INTERFACE
M:	Jan Kiszka <jan.kiszka@siemens.com>
L:	jailhouse-dev@googlegroups.com
S:	Maintained
F:	arch/x86/kernel/jailhouse.c
F:	arch/x86/include/asm/jailhouse_para.h

JC42.4 TEMPERATURE SENSOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/jc42.c
F:	Documentation/hwmon/jc42

JFS FILESYSTEM
M:	Dave Kleikamp <shaggy@kernel.org>
L:	jfs-discussion@lists.sourceforge.net
W:	http://jfs.sourceforge.net/
T:	git git://github.com/kleikamp/linux-shaggy.git
S:	Maintained
F:	Documentation/filesystems/jfs.txt
F:	fs/jfs/

JME NETWORK DRIVER
M:	Guo-Fu Tseng <cooldavid@cooldavid.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/jme.*

JOURNALLING FLASH FILE SYSTEM V2 (JFFS2)
M:	David Woodhouse <dwmw2@infradead.org>
L:	linux-mtd@lists.infradead.org
W:	http://www.linux-mtd.infradead.org/doc/jffs2.html
S:	Maintained
F:	fs/jffs2/
F:	include/uapi/linux/jffs2.h

JOURNALLING LAYER FOR BLOCK DEVICES (JBD2)
M:	"Theodore Ts'o" <tytso@mit.edu>
M:	Jan Kara <jack@suse.com>
L:	linux-ext4@vger.kernel.org
S:	Maintained
F:	fs/jbd2/
F:	include/linux/jbd2.h

JPU V4L2 MEM2MEM DRIVER FOR RENESAS
M:	Mikhail Ulyanov <mikhail.ulyanov@cogentembedded.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/platform/rcar_jpu.c

JSM Neo PCI based serial card
M:	Guilherme G. Piccoli <gpiccoli@linux.vnet.ibm.com>
L:	linux-serial@vger.kernel.org
S:	Maintained
F:	drivers/tty/serial/jsm/

K10TEMP HARDWARE MONITORING DRIVER
M:	Clemens Ladisch <clemens@ladisch.de>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/k10temp
F:	drivers/hwmon/k10temp.c

K8TEMP HARDWARE MONITORING DRIVER
M:	Rudolf Marek <r.marek@assembler.cz>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/k8temp
F:	drivers/hwmon/k8temp.c

KASAN
M:	Andrey Ryabinin <aryabinin@virtuozzo.com>
R:	Alexander Potapenko <glider@google.com>
R:	Dmitry Vyukov <dvyukov@google.com>
L:	kasan-dev@googlegroups.com
S:	Maintained
F:	arch/*/include/asm/kasan.h
F:	arch/*/mm/kasan_init*
F:	Documentation/dev-tools/kasan.rst
F:	include/linux/kasan*.h
F:	lib/test_kasan.c
F:	mm/kasan/
F:	scripts/Makefile.kasan

KCONFIG
M:	Masahiro Yamada <yamada.masahiro@socionext.com>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-kbuild.git kconfig
L:	linux-kbuild@vger.kernel.org
S:	Maintained
F:	Documentation/kbuild/kconfig*
F:	scripts/kconfig/
F:	scripts/Kconfig.include

KDUMP
M:	Dave Young <dyoung@redhat.com>
M:	Baoquan He <bhe@redhat.com>
R:	Vivek Goyal <vgoyal@redhat.com>
L:	kexec@lists.infradead.org
W:	http://lse.sourceforge.net/kdump/
S:	Maintained
F:	Documentation/kdump/

KEENE FM RADIO TRANSMITTER DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/radio/radio-keene*

KERNEL AUTOMOUNTER
M:	Ian Kent <raven@themaw.net>
L:	autofs@vger.kernel.org
S:	Maintained
F:	fs/autofs/

KERNEL BUILD + files below scripts/ (unless maintained elsewhere)
M:	Masahiro Yamada <yamada.masahiro@socionext.com>
M:	Michal Marek <michal.lkml@markovi.net>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-kbuild.git
L:	linux-kbuild@vger.kernel.org
S:	Maintained
F:	Documentation/kbuild/
F:	Makefile
F:	scripts/Kbuild*
F:	scripts/Makefile*
F:	scripts/basic/
F:	scripts/mk*
F:	scripts/mod/
F:	scripts/package/

KERNEL JANITORS
L:	kernel-janitors@vger.kernel.org
W:	http://kernelnewbies.org/KernelJanitors
S:	Odd Fixes

KERNEL NFSD, SUNRPC, AND LOCKD SERVERS
M:	"J. Bruce Fields" <bfields@fieldses.org>
M:	Jeff Layton <jlayton@kernel.org>
L:	linux-nfs@vger.kernel.org
W:	http://nfs.sourceforge.net/
T:	git git://linux-nfs.org/~bfields/linux.git
S:	Supported
F:	fs/nfsd/
F:	include/uapi/linux/nfsd/
F:	fs/lockd/
F:	fs/nfs_common/
F:	net/sunrpc/
F:	include/linux/lockd/
F:	include/linux/sunrpc/
F:	include/uapi/linux/sunrpc/

KERNEL SELFTEST FRAMEWORK
M:	Shuah Khan <shuah@kernel.org>
L:	linux-kselftest@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest.git
Q:	https://patchwork.kernel.org/project/linux-kselftest/list/
S:	Maintained
F:	tools/testing/selftests/
F:	Documentation/dev-tools/kselftest*

KERNEL USERMODE HELPER
M:	"Luis R. Rodriguez" <mcgrof@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	kernel/umh.c
F:	include/linux/umh.h

KERNEL VIRTUAL MACHINE (KVM)
M:	Paolo Bonzini <pbonzini@redhat.com>
M:	Radim Krčmář <rkrcmar@redhat.com>
L:	kvm@vger.kernel.org
W:	http://www.linux-kvm.org
T:	git git://git.kernel.org/pub/scm/virt/kvm/kvm.git
S:	Supported
F:	Documentation/virtual/kvm/
F:	include/trace/events/kvm.h
F:	include/uapi/asm-generic/kvm*
F:	include/uapi/linux/kvm*
F:	include/asm-generic/kvm*
F:	include/linux/kvm*
F:	include/kvm/iodev.h
F:	virt/kvm/*
F:	tools/kvm/

KERNEL VIRTUAL MACHINE FOR AMD-V (KVM/amd)
M:	Joerg Roedel <joro@8bytes.org>
L:	kvm@vger.kernel.org
W:	http://www.linux-kvm.org/
S:	Maintained
F:	arch/x86/include/asm/svm.h
F:	arch/x86/kvm/svm.c

KERNEL VIRTUAL MACHINE FOR ARM (KVM/arm)
M:	Christoffer Dall <christoffer.dall@arm.com>
M:	Marc Zyngier <marc.zyngier@arm.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	kvmarm@lists.cs.columbia.edu
W:	http://systems.cs.columbia.edu/projects/kvm-arm
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kvmarm/kvmarm.git
S:	Supported
F:	arch/arm/include/uapi/asm/kvm*
F:	arch/arm/include/asm/kvm*
F:	arch/arm/kvm/
F:	virt/kvm/arm/
F:	include/kvm/arm_*

KERNEL VIRTUAL MACHINE FOR ARM64 (KVM/arm64)
M:	Christoffer Dall <christoffer.dall@arm.com>
M:	Marc Zyngier <marc.zyngier@arm.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	kvmarm@lists.cs.columbia.edu
S:	Maintained
F:	arch/arm64/include/uapi/asm/kvm*
F:	arch/arm64/include/asm/kvm*
F:	arch/arm64/kvm/

KERNEL VIRTUAL MACHINE FOR MIPS (KVM/mips)
M:	James Hogan <jhogan@kernel.org>
L:	linux-mips@linux-mips.org
S:	Supported
F:	arch/mips/include/uapi/asm/kvm*
F:	arch/mips/include/asm/kvm*
F:	arch/mips/kvm/

KERNEL VIRTUAL MACHINE FOR POWERPC (KVM/powerpc)
M:	Paul Mackerras <paulus@ozlabs.org>
L:	kvm-ppc@vger.kernel.org
W:	http://www.linux-kvm.org/
T:	git git://github.com/agraf/linux-2.6.git
S:	Supported
F:	arch/powerpc/include/uapi/asm/kvm*
F:	arch/powerpc/include/asm/kvm*
F:	arch/powerpc/kvm/
F:	arch/powerpc/kernel/kvm*

KERNEL VIRTUAL MACHINE for s390 (KVM/s390)
M:	Christian Borntraeger <borntraeger@de.ibm.com>
M:	Janosch Frank <frankja@linux.ibm.com>
R:	David Hildenbrand <david@redhat.com>
R:	Cornelia Huck <cohuck@redhat.com>
L:	linux-s390@vger.kernel.org
W:	http://www.ibm.com/developerworks/linux/linux390/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kvms390/linux.git
S:	Supported
F:	arch/s390/include/uapi/asm/kvm*
F:	arch/s390/include/asm/gmap.h
F:	arch/s390/include/asm/kvm*
F:	arch/s390/kvm/
F:	arch/s390/mm/gmap.c

KERNEL VIRTUAL MACHINE FOR X86 (KVM/x86)
M:	Paolo Bonzini <pbonzini@redhat.com>
M:	Radim Krčmář <rkrcmar@redhat.com>
L:	kvm@vger.kernel.org
W:	http://www.linux-kvm.org
T:	git git://git.kernel.org/pub/scm/virt/kvm/kvm.git
S:	Supported
F:	arch/x86/kvm/
F:	arch/x86/include/uapi/asm/kvm*
F:	arch/x86/include/asm/kvm*
F:	arch/x86/include/asm/pvclock-abi.h
F:	arch/x86/kernel/kvm.c
F:	arch/x86/kernel/kvmclock.c

KERNFS
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
M:	Tejun Heo <tj@kernel.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core.git
S:	Supported
F:	include/linux/kernfs.h
F:	fs/kernfs/

KEXEC
M:	Eric Biederman <ebiederm@xmission.com>
W:	http://kernel.org/pub/linux/utils/kernel/kexec/
L:	kexec@lists.infradead.org
S:	Maintained
F:	include/linux/kexec.h
F:	include/uapi/linux/kexec.h
F:	kernel/kexec*

KEYS-ENCRYPTED
M:	Mimi Zohar <zohar@linux.vnet.ibm.com>
L:	linux-integrity@vger.kernel.org
L:	keyrings@vger.kernel.org
S:	Supported
F:	Documentation/security/keys/trusted-encrypted.rst
F:	include/keys/encrypted-type.h
F:	security/keys/encrypted-keys/

KEYS-TRUSTED
M:	James Bottomley <jejb@linux.vnet.ibm.com>
M:	Mimi Zohar <zohar@linux.vnet.ibm.com>
L:	linux-integrity@vger.kernel.org
L:	keyrings@vger.kernel.org
S:	Supported
F:	Documentation/security/keys/trusted-encrypted.rst
F:	include/keys/trusted-type.h
F:	security/keys/trusted.c
F:	security/keys/trusted.h

KEYS/KEYRINGS:
M:	David Howells <dhowells@redhat.com>
L:	keyrings@vger.kernel.org
S:	Maintained
F:	Documentation/security/keys/core.rst
F:	include/linux/key.h
F:	include/linux/key-type.h
F:	include/linux/keyctl.h
F:	include/uapi/linux/keyctl.h
F:	include/keys/
F:	security/keys/

KGDB / KDB /debug_core
M:	Jason Wessel <jason.wessel@windriver.com>
M:	Daniel Thompson <daniel.thompson@linaro.org>
W:	http://kgdb.wiki.kernel.org/
L:	kgdb-bugreport@lists.sourceforge.net
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/kgdb.git
S:	Maintained
F:	Documentation/dev-tools/kgdb.rst
F:	drivers/misc/kgdbts.c
F:	drivers/tty/serial/kgdboc.c
F:	include/linux/kdb.h
F:	include/linux/kgdb.h
F:	kernel/debug/

KMEMLEAK
M:	Catalin Marinas <catalin.marinas@arm.com>
S:	Maintained
F:	Documentation/dev-tools/kmemleak.rst
F:	include/linux/kmemleak.h
F:	mm/kmemleak.c
F:	mm/kmemleak-test.c

KMOD KERNEL MODULE LOADER - USERMODE HELPER
M:	"Luis R. Rodriguez" <mcgrof@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	kernel/kmod.c
F:	include/linux/kmod.h
F:	lib/test_kmod.c
F:	tools/testing/selftests/kmod/

KPROBES
M:	Ananth N Mavinakayanahalli <ananth@linux.vnet.ibm.com>
M:	Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
M:	"David S. Miller" <davem@davemloft.net>
M:	Masami Hiramatsu <mhiramat@kernel.org>
S:	Maintained
F:	Documentation/kprobes.txt
F:	include/linux/kprobes.h
F:	include/asm-generic/kprobes.h
F:	kernel/kprobes.c

KS0108 LCD CONTROLLER DRIVER
M:	Miguel Ojeda Sandonis <miguel.ojeda.sandonis@gmail.com>
S:	Maintained
F:	Documentation/auxdisplay/ks0108
F:	drivers/auxdisplay/ks0108.c
F:	include/linux/ks0108.h

L3MDEV
M:	David Ahern <dsa@cumulusnetworks.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	net/l3mdev
F:	include/net/l3mdev.h

LANTIQ MIPS ARCHITECTURE
M:	John Crispin <john@phrozen.org>
L:	linux-mips@linux-mips.org
S:	Maintained
F:	arch/mips/lantiq
F:	drivers/soc/lantiq

LAPB module
L:	linux-x25@vger.kernel.org
S:	Orphan
F:	Documentation/networking/lapb-module.txt
F:	include/*/lapb.h
F:	net/lapb/

LASI 53c700 driver for PARISC
M:	"James E.J. Bottomley" <James.Bottomley@HansenPartnership.com>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	Documentation/scsi/53c700.txt
F:	drivers/scsi/53c700*

LEAKING_ADDRESSES
M:	Tobin C. Harding <me@tobin.cc>
M:	Tycho Andersen <tycho@tycho.ws>
L:	kernel-hardening@lists.openwall.com
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tobin/leaks.git
F:	scripts/leaking_addresses.pl

LED SUBSYSTEM
M:	Jacek Anaszewski <jacek.anaszewski@gmail.com>
M:	Pavel Machek <pavel@ucw.cz>
L:	linux-leds@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/j.anaszewski/linux-leds.git
S:	Maintained
F:	Documentation/devicetree/bindings/leds/
F:	drivers/leds/
F:	include/linux/leds.h

LEGACY EEPROM DRIVER
M:	Jean Delvare <jdelvare@suse.com>
S:	Maintained
F:	Documentation/misc-devices/eeprom
F:	drivers/misc/eeprom/eeprom.c

LEGO MINDSTORMS EV3
R:	David Lechner <david@lechnology.com>
S:	Maintained
F:	arch/arm/boot/dts/da850-lego-ev3.dts
F:	Documentation/devicetree/bindings/power/supply/lego_ev3_battery.txt
F:	drivers/power/supply/lego_ev3_battery.c

LEGO USB Tower driver
M:	Juergen Stuber <starblue@users.sourceforge.net>
L:	legousb-devel@lists.sourceforge.net
W:	http://legousb.sourceforge.net/
S:	Maintained
F:	drivers/usb/misc/legousbtower.c

LG2160 MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://github.com/mkrufky
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/mkrufky/tuners.git
S:	Maintained
F:	drivers/media/dvb-frontends/lg2160.*

LGDT3305 MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://github.com/mkrufky
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/mkrufky/tuners.git
S:	Maintained
F:	drivers/media/dvb-frontends/lgdt3305.*

LIBATA PATA ARASAN COMPACT FLASH CONTROLLER
M:	Viresh Kumar <vireshk@kernel.org>
L:	linux-ide@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tj/libata.git
S:	Maintained
F:	include/linux/pata_arasan_cf_data.h
F:	drivers/ata/pata_arasan_cf.c

LIBATA PATA DRIVERS
M:	Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
M:	Tejun Heo <tj@kernel.org>
L:	linux-ide@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tj/libata.git
S:	Maintained
F:	drivers/ata/pata_*.c
F:	drivers/ata/ata_generic.c

LIBATA PATA FARADAY FTIDE010 AND GEMINI SATA BRIDGE DRIVERS
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-ide@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tj/libata.git
S:	Maintained
F:	drivers/ata/pata_ftide010.c
F:	drivers/ata/sata_gemini.c
F:	drivers/ata/sata_gemini.h

LIBATA SATA AHCI PLATFORM devices support
M:	Hans de Goede <hdegoede@redhat.com>
M:	Tejun Heo <tj@kernel.org>
L:	linux-ide@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tj/libata.git
S:	Maintained
F:	drivers/ata/ahci_platform.c
F:	drivers/ata/libahci_platform.c
F:	include/linux/ahci_platform.h

LIBATA SATA PROMISE TX2/TX4 CONTROLLER DRIVER
M:	Mikael Pettersson <mikpelinux@gmail.com>
L:	linux-ide@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tj/libata.git
S:	Maintained
F:	drivers/ata/sata_promise.*

LIBATA SUBSYSTEM (Serial and Parallel ATA drivers)
M:	Tejun Heo <tj@kernel.org>
L:	linux-ide@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tj/libata.git
S:	Maintained
F:	drivers/ata/
F:	include/linux/ata.h
F:	include/linux/libata.h
F:	Documentation/devicetree/bindings/ata/

LIBLOCKDEP
M:	Sasha Levin <alexander.levin@verizon.com>
S:	Maintained
F:	tools/lib/lockdep/

LIBNVDIMM BLK: MMIO-APERTURE DRIVER
M:	Ross Zwisler <ross.zwisler@linux.intel.com>
M:	Dan Williams <dan.j.williams@intel.com>
M:	Vishal Verma <vishal.l.verma@intel.com>
M:	Dave Jiang <dave.jiang@intel.com>
L:	linux-nvdimm@lists.01.org
Q:	https://patchwork.kernel.org/project/linux-nvdimm/list/
S:	Supported
F:	drivers/nvdimm/blk.c
F:	drivers/nvdimm/region_devs.c

LIBNVDIMM BTT: BLOCK TRANSLATION TABLE
M:	Vishal Verma <vishal.l.verma@intel.com>
M:	Dan Williams <dan.j.williams@intel.com>
M:	Ross Zwisler <ross.zwisler@linux.intel.com>
M:	Dave Jiang <dave.jiang@intel.com>
L:	linux-nvdimm@lists.01.org
Q:	https://patchwork.kernel.org/project/linux-nvdimm/list/
S:	Supported
F:	drivers/nvdimm/btt*

LIBNVDIMM PMEM: PERSISTENT MEMORY DRIVER
M:	Ross Zwisler <ross.zwisler@linux.intel.com>
M:	Dan Williams <dan.j.williams@intel.com>
M:	Vishal Verma <vishal.l.verma@intel.com>
M:	Dave Jiang <dave.jiang@intel.com>
L:	linux-nvdimm@lists.01.org
Q:	https://patchwork.kernel.org/project/linux-nvdimm/list/
S:	Supported
F:	drivers/nvdimm/pmem*

LIBNVDIMM: DEVICETREE BINDINGS
M:	Oliver O'Halloran <oohall@gmail.com>
L:	linux-nvdimm@lists.01.org
Q:	https://patchwork.kernel.org/project/linux-nvdimm/list/
S:	Supported
F:	drivers/nvdimm/of_pmem.c
F:	Documentation/devicetree/bindings/pmem/pmem-region.txt

LIBNVDIMM: NON-VOLATILE MEMORY DEVICE SUBSYSTEM
M:	Dan Williams <dan.j.williams@intel.com>
M:	Ross Zwisler <ross.zwisler@linux.intel.com>
M:	Vishal Verma <vishal.l.verma@intel.com>
M:	Dave Jiang <dave.jiang@intel.com>
L:	linux-nvdimm@lists.01.org
Q:	https://patchwork.kernel.org/project/linux-nvdimm/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm.git
S:	Supported
F:	drivers/nvdimm/*
F:	drivers/acpi/nfit/*
F:	include/linux/nd.h
F:	include/linux/libnvdimm.h
F:	include/uapi/linux/ndctl.h

LIGHTNVM PLATFORM SUPPORT
M:	Matias Bjorling <mb@lightnvm.io>
W:	http://github/OpenChannelSSD
L:	linux-block@vger.kernel.org
S:	Maintained
F:	drivers/lightnvm/
F:	include/linux/lightnvm.h
F:	include/uapi/linux/lightnvm.h

LINUX FOR POWER MACINTOSH
M:	Benjamin Herrenschmidt <benh@kernel.crashing.org>
W:	http://www.penguinppc.org/
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	arch/powerpc/platforms/powermac/
F:	drivers/macintosh/

LINUX FOR POWERPC (32-BIT AND 64-BIT)
M:	Benjamin Herrenschmidt <benh@kernel.crashing.org>
M:	Paul Mackerras <paulus@samba.org>
M:	Michael Ellerman <mpe@ellerman.id.au>
W:	https://github.com/linuxppc/linux/wiki
L:	linuxppc-dev@lists.ozlabs.org
Q:	http://patchwork.ozlabs.org/project/linuxppc-dev/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git
S:	Supported
F:	Documentation/ABI/stable/sysfs-firmware-opal-*
F:	Documentation/devicetree/bindings/powerpc/
F:	Documentation/devicetree/bindings/rtc/rtc-opal.txt
F:	Documentation/devicetree/bindings/i2c/i2c-opal.txt
F:	Documentation/powerpc/
F:	arch/powerpc/
F:	drivers/char/tpm/tpm_ibmvtpm*
F:	drivers/crypto/nx/
F:	drivers/crypto/vmx/
F:	drivers/i2c/busses/i2c-opal.c
F:	drivers/net/ethernet/ibm/ibmveth.*
F:	drivers/net/ethernet/ibm/ibmvnic.*
F:	drivers/pci/hotplug/pnv_php.c
F:	drivers/pci/hotplug/rpa*
F:	drivers/rtc/rtc-opal.c
F:	drivers/scsi/ibmvscsi/
F:	drivers/tty/hvc/hvc_opal.c
F:	drivers/watchdog/wdrtas.c
F:	tools/testing/selftests/powerpc
N:	/pmac
N:	powermac
N:	powernv
N:	[^a-z0-9]ps3
N:	pseries

LINUX FOR POWERPC EMBEDDED MPC5XXX
M:	Anatolij Gustschin <agust@denx.de>
L:	linuxppc-dev@lists.ozlabs.org
T:	git git://git.denx.de/linux-denx-agust.git
S:	Maintained
F:	arch/powerpc/platforms/512x/
F:	arch/powerpc/platforms/52xx/

LINUX FOR POWERPC EMBEDDED PPC4XX
M:	Alistair Popple <alistair@popple.id.au>
M:	Matt Porter <mporter@kernel.crashing.org>
W:	http://www.penguinppc.org/
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	arch/powerpc/platforms/40x/
F:	arch/powerpc/platforms/44x/

LINUX FOR POWERPC EMBEDDED PPC83XX AND PPC85XX
M:	Scott Wood <oss@buserror.net>
M:	Kumar Gala <galak@kernel.crashing.org>
W:	http://www.penguinppc.org/
L:	linuxppc-dev@lists.ozlabs.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/scottwood/linux.git
S:	Maintained
F:	arch/powerpc/platforms/83xx/
F:	arch/powerpc/platforms/85xx/
F:	Documentation/devicetree/bindings/powerpc/fsl/

LINUX FOR POWERPC EMBEDDED PPC8XX
M:	Vitaly Bordug <vitb@kernel.crashing.org>
W:	http://www.penguinppc.org/
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	arch/powerpc/platforms/8xx/

LINUX FOR POWERPC EMBEDDED XILINX VIRTEX
L:	linuxppc-dev@lists.ozlabs.org
S:	Orphan
F:	arch/powerpc/*/*virtex*
F:	arch/powerpc/*/*/*virtex*

LINUX FOR POWERPC PA SEMI PWRFICIENT
L:	linuxppc-dev@lists.ozlabs.org
S:	Orphan
F:	arch/powerpc/platforms/pasemi/
F:	drivers/*/*pasemi*
F:	drivers/*/*/*pasemi*

LINUX KERNEL DUMP TEST MODULE (LKDTM)
M:	Kees Cook <keescook@chromium.org>
S:	Maintained
F:	drivers/misc/lkdtm/*

LINUX KERNEL MEMORY CONSISTENCY MODEL (LKMM)
M:	Alan Stern <stern@rowland.harvard.edu>
M:	Andrea Parri <andrea.parri@amarulasolutions.com>
M:	Will Deacon <will.deacon@arm.com>
M:	Peter Zijlstra <peterz@infradead.org>
M:	Boqun Feng <boqun.feng@gmail.com>
M:	Nicholas Piggin <npiggin@gmail.com>
M:	David Howells <dhowells@redhat.com>
M:	Jade Alglave <j.alglave@ucl.ac.uk>
M:	Luc Maranget <luc.maranget@inria.fr>
M:	"Paul E. McKenney" <paulmck@linux.vnet.ibm.com>
R:	Akira Yokosawa <akiyks@gmail.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git
F:	tools/memory-model/
F:	Documentation/memory-barriers.txt

LINUX SECURITY MODULE (LSM) FRAMEWORK
M:	Chris Wright <chrisw@sous-sol.org>
L:	linux-security-module@vger.kernel.org
S:	Supported

LIS3LV02D ACCELEROMETER DRIVER
M:	Eric Piel <eric.piel@tremplin-utc.net>
S:	Maintained
F:	Documentation/misc-devices/lis3lv02d
F:	drivers/misc/lis3lv02d/
F:	drivers/platform/x86/hp_accel.c

LIVE PATCHING
M:	Josh Poimboeuf <jpoimboe@redhat.com>
M:	Jessica Yu <jeyu@kernel.org>
M:	Jiri Kosina <jikos@kernel.org>
M:	Miroslav Benes <mbenes@suse.cz>
R:	Petr Mladek <pmladek@suse.com>
S:	Maintained
F:	kernel/livepatch/
F:	include/linux/livepatch.h
F:	arch/x86/include/asm/livepatch.h
F:	arch/x86/kernel/livepatch.c
F:	Documentation/livepatch/
F:	Documentation/ABI/testing/sysfs-kernel-livepatch
F:	samples/livepatch/
L:	live-patching@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jikos/livepatching.git

LLC (802.2)
L:	netdev@vger.kernel.org
S:	Odd fixes
F:	include/linux/llc.h
F:	include/uapi/linux/llc.h
F:	include/net/llc*
F:	net/llc/

LM73 HARDWARE MONITOR DRIVER
M:	Guillaume Ligneul <guillaume.ligneul@gmail.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/lm73.c

LM78 HARDWARE MONITOR DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/lm78
F:	drivers/hwmon/lm78.c

LM83 HARDWARE MONITOR DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/lm83
F:	drivers/hwmon/lm83.c

LM90 HARDWARE MONITOR DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/lm90
F:	Documentation/devicetree/bindings/hwmon/lm90.txt
F:	drivers/hwmon/lm90.c
F:	include/dt-bindings/thermal/lm90.h

LM95234 HARDWARE MONITOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/lm95234
F:	drivers/hwmon/lm95234.c

LME2510 MEDIA DRIVER
M:	Malcolm Priestley <tvboxspy@gmail.com>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
S:	Maintained
F:	drivers/media/usb/dvb-usb-v2/lmedm04*

LOADPIN SECURITY MODULE
M:	Kees Cook <keescook@chromium.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git lsm/loadpin
S:	Supported
F:	security/loadpin/
F:	Documentation/admin-guide/LSM/LoadPin.rst

LOCKING PRIMITIVES
M:	Peter Zijlstra <peterz@infradead.org>
M:	Ingo Molnar <mingo@redhat.com>
M:	Will Deacon <will.deacon@arm.com>
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git locking/core
S:	Maintained
F:	Documentation/locking/
F:	include/linux/lockdep.h
F:	include/linux/spinlock*.h
F:	arch/*/include/asm/spinlock*.h
F:	include/linux/rwlock*.h
F:	include/linux/mutex*.h
F:	arch/*/include/asm/mutex*.h
F:	include/linux/rwsem*.h
F:	arch/*/include/asm/rwsem.h
F:	include/linux/seqlock.h
F:	lib/locking*.[ch]
F:	kernel/locking/
X:	kernel/locking/locktorture.c

LOGICAL DISK MANAGER SUPPORT (LDM, Windows 2000/XP/Vista Dynamic Disks)
M:	"Richard Russon (FlatCap)" <ldm@flatcap.org>
L:	linux-ntfs-dev@lists.sourceforge.net
W:	http://www.linux-ntfs.org/content/view/19/37/
S:	Maintained
F:	Documentation/ldm.txt
F:	block/partitions/ldm.*

LSILOGIC MPT FUSION DRIVERS (FC/SAS/SPI)
M:	Sathya Prakash <sathya.prakash@broadcom.com>
M:	Chaitra P B <chaitra.basappa@broadcom.com>
M:	Suganath Prabu Subramani <suganath-prabu.subramani@broadcom.com>
L:	MPT-FusionLinux.pdl@broadcom.com
L:	linux-scsi@vger.kernel.org
W:	http://www.avagotech.com/support/
S:	Supported
F:	drivers/message/fusion/
F:	drivers/scsi/mpt3sas/

LSILOGIC/SYMBIOS/NCR 53C8XX and 53C1010 PCI-SCSI drivers
M:	Matthew Wilcox <matthew@wil.cx>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	drivers/scsi/sym53c8xx_2/

LTC4261 HARDWARE MONITOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/ltc4261
F:	drivers/hwmon/ltc4261.c

LTC4306 I2C MULTIPLEXER DRIVER
M:	Michael Hennerich <michael.hennerich@analog.com>
W:	http://ez.analog.com/community/linux-device-drivers
L:	linux-i2c@vger.kernel.org
S:	Supported
F:	drivers/i2c/muxes/i2c-mux-ltc4306.c
F:	Documentation/devicetree/bindings/i2c/i2c-mux-ltc4306.txt

LTP (Linux Test Project)
M:	Mike Frysinger <vapier@gentoo.org>
M:	Cyril Hrubis <chrubis@suse.cz>
M:	Wanlong Gao <wanlong.gao@gmail.com>
M:	Jan Stancek <jstancek@redhat.com>
M:	Stanislav Kholmanskikh <stanislav.kholmanskikh@oracle.com>
M:	Alexey Kodanev <alexey.kodanev@oracle.com>
L:	ltp@lists.linux.it (subscribers-only)
W:	http://linux-test-project.github.io/
T:	git git://github.com/linux-test-project/ltp.git
S:	Maintained

M68K ARCHITECTURE
M:	Geert Uytterhoeven <geert@linux-m68k.org>
L:	linux-m68k@lists.linux-m68k.org
W:	http://www.linux-m68k.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/geert/linux-m68k.git
S:	Maintained
F:	arch/m68k/
F:	drivers/zorro/

M68K ON APPLE MACINTOSH
M:	Joshua Thompson <funaho@jurai.org>
W:	http://www.mac.linux-m68k.org/
L:	linux-m68k@lists.linux-m68k.org
S:	Maintained
F:	arch/m68k/mac/

M68K ON HP9000/300
M:	Philip Blundell <philb@gnu.org>
W:	http://www.tazenda.demon.co.uk/phil/linux-hp
S:	Maintained
F:	arch/m68k/hp300/

M88DS3103 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/m88ds3103*

M88RS2000 MEDIA DRIVER
M:	Malcolm Priestley <tvboxspy@gmail.com>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
S:	Maintained
F:	drivers/media/dvb-frontends/m88rs2000*

MA901 MASTERKIT USB FM RADIO DRIVER
M:	Alexey Klimov <klimov.linux@gmail.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/radio/radio-ma901.c

MAC80211
M:	Johannes Berg <johannes@sipsolutions.net>
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jberg/mac80211.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jberg/mac80211-next.git
S:	Maintained
F:	Documentation/networking/mac80211-injection.txt
F:	include/net/mac80211.h
F:	net/mac80211/
F:	drivers/net/wireless/mac80211_hwsim.[ch]
F:	Documentation/networking/mac80211_hwsim/README

MAILBOX API
M:	Jassi Brar <jassisinghbrar@gmail.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/mailbox/
F:	include/linux/mailbox_client.h
F:	include/linux/mailbox_controller.h

MAN-PAGES: MANUAL PAGES FOR LINUX -- Sections 2, 3, 4, 5, and 7
M:	Michael Kerrisk <mtk.manpages@gmail.com>
W:	http://www.kernel.org/doc/man-pages
L:	linux-man@vger.kernel.org
S:	Maintained

MARDUK (CREATOR CI40) DEVICE TREE SUPPORT
M:	Rahul Bedarkar <rahulbedarkar89@gmail.com>
L:	linux-mips@linux-mips.org
S:	Maintained
F:	arch/mips/boot/dts/img/pistachio_marduk.dts

MARVELL 88E6XXX ETHERNET SWITCH FABRIC DRIVER
M:	Andrew Lunn <andrew@lunn.ch>
M:	Vivien Didelot <vivien.didelot@savoirfairelinux.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/dsa/mv88e6xxx/
F:	linux/platform_data/mv88e6xxx.h
F:	Documentation/devicetree/bindings/net/dsa/marvell.txt

MARVELL ARMADA DRM SUPPORT
M:	Russell King <linux@armlinux.org.uk>
S:	Maintained
T:	git git://git.armlinux.org.uk/~rmk/linux-arm.git drm-armada-devel
T:	git git://git.armlinux.org.uk/~rmk/linux-arm.git drm-armada-fixes
F:	drivers/gpu/drm/armada/
F:	include/uapi/drm/armada_drm.h
F:	Documentation/devicetree/bindings/display/armada/

MARVELL CRYPTO DRIVER
M:	Boris Brezillon <boris.brezillon@bootlin.com>
M:	Arnaud Ebalard <arno@natisbad.org>
F:	drivers/crypto/marvell/
S:	Maintained
L:	linux-crypto@vger.kernel.org

MARVELL GIGABIT ETHERNET DRIVERS (skge/sky2)
M:	Mirko Lindner <mlindner@marvell.com>
M:	Stephen Hemminger <stephen@networkplumber.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/marvell/sk*

MARVELL LIBERTAS WIRELESS DRIVER
L:	libertas-dev@lists.infradead.org
S:	Orphan
F:	drivers/net/wireless/marvell/libertas/

MARVELL MACCHIATOBIN SUPPORT
M:	Russell King <linux@armlinux.org.uk>
L:	linux-arm-kernel@lists.infradead.org
S:	Maintained
F:	arch/arm64/boot/dts/marvell/armada-8040-mcbin.dts

MARVELL MV643XX ETHERNET DRIVER
M:	Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/marvell/mv643xx_eth.*
F:	include/linux/mv643xx.h

MARVELL MV88X3310 PHY DRIVER
M:	Russell King <linux@armlinux.org.uk>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/phy/marvell10g.c

MARVELL MVNETA ETHERNET DRIVER
M:	Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/marvell/mvneta.*

MARVELL MWIFIEX WIRELESS DRIVER
M:	Amitkumar Karwar <amitkarwar@gmail.com>
M:	Nishant Sarmukadam <nishants@marvell.com>
M:	Ganapathi Bhat <gbhat@marvell.com>
M:	Xinming Hu <huxm@marvell.com>
L:	linux-wireless@vger.kernel.org
S:	Maintained
F:	drivers/net/wireless/marvell/mwifiex/

MARVELL MWL8K WIRELESS DRIVER
M:	Lennert Buytenhek <buytenh@wantstofly.org>
L:	linux-wireless@vger.kernel.org
S:	Odd Fixes
F:	drivers/net/wireless/marvell/mwl8k.c

MARVELL NAND CONTROLLER DRIVER
M:	Miquel Raynal <miquel.raynal@bootlin.com>
L:	linux-mtd@lists.infradead.org
S:	Maintained
F:	drivers/mtd/nand/raw/marvell_nand.c
F:	Documentation/devicetree/bindings/mtd/marvell-nand.txt

MARVELL SOC MMC/SD/SDIO CONTROLLER DRIVER
M:	Nicolas Pitre <nico@fluxnic.net>
S:	Odd Fixes
F:	drivers/mmc/host/mvsdio.*

MARVELL XENON MMC/SD/SDIO HOST CONTROLLER DRIVER
M:	Hu Ziji <huziji@marvell.com>
L:	linux-mmc@vger.kernel.org
S:	Supported
F:	drivers/mmc/host/sdhci-xenon*
F:	Documentation/devicetree/bindings/mmc/marvell,xenon-sdhci.txt

MATROX FRAMEBUFFER DRIVER
L:	linux-fbdev@vger.kernel.org
S:	Orphan
F:	drivers/video/fbdev/matrox/matroxfb_*
F:	include/uapi/linux/matroxfb.h

MAX16065 HARDWARE MONITOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/max16065
F:	drivers/hwmon/max16065.c

MAX20751 HARDWARE MONITOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/max20751
F:	drivers/hwmon/max20751.c

MAX2175 SDR TUNER DRIVER
M:	Ramesh Shanmugasundaram <ramesh.shanmugasundaram@bp.renesas.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	Documentation/devicetree/bindings/media/i2c/max2175.txt
F:	Documentation/media/v4l-drivers/max2175.rst
F:	drivers/media/i2c/max2175*
F:	include/uapi/linux/max2175.h

MAX6650 HARDWARE MONITOR AND FAN CONTROLLER DRIVER
L:	linux-hwmon@vger.kernel.org
S:	Orphan
F:	Documentation/hwmon/max6650
F:	drivers/hwmon/max6650.c

MAX6697 HARDWARE MONITOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/max6697
F:	Documentation/devicetree/bindings/i2c/max6697.txt
F:	drivers/hwmon/max6697.c
F:	include/linux/platform_data/max6697.h

MAX9860 MONO AUDIO VOICE CODEC DRIVER
M:	Peter Rosin <peda@axentia.se>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/sound/max9860.txt
F:	sound/soc/codecs/max9860.*

MAXIM MAX77802 PMIC REGULATOR DEVICE DRIVER
M:	Javier Martinez Canillas <javier@dowhile0.org>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	drivers/regulator/max77802-regulator.c
F:	Documentation/devicetree/bindings/*/*max77802.txt
F:	include/dt-bindings/*/*max77802.h

MAXIM MUIC CHARGER DRIVERS FOR EXYNOS BASED BOARDS
M:	Krzysztof Kozlowski <krzk@kernel.org>
M:	Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
L:	linux-pm@vger.kernel.org
S:	Supported
F:	drivers/power/supply/max14577_charger.c
F:	drivers/power/supply/max77693_charger.c

MAXIM PMIC AND MUIC DRIVERS FOR EXYNOS BASED BOARDS
M:	Chanwoo Choi <cw00.choi@samsung.com>
M:	Krzysztof Kozlowski <krzk@kernel.org>
M:	Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	drivers/*/max14577*.c
F:	drivers/*/max77686*.c
F:	drivers/*/max77693*.c
F:	drivers/extcon/extcon-max14577.c
F:	drivers/extcon/extcon-max77693.c
F:	drivers/rtc/rtc-max77686.c
F:	drivers/clk/clk-max77686.c
F:	Documentation/devicetree/bindings/mfd/max14577.txt
F:	Documentation/devicetree/bindings/*/max77686.txt
F:	Documentation/devicetree/bindings/mfd/max77693.txt
F:	Documentation/devicetree/bindings/clock/maxim,max77686.txt
F:	include/linux/mfd/max14577*.h
F:	include/linux/mfd/max77686*.h
F:	include/linux/mfd/max77693*.h

MAXIRADIO FM RADIO RECEIVER DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/radio/radio-maxiradio*

MCP4018 AND MCP4531 MICROCHIP DIGITAL POTENTIOMETER DRIVERS
M:	Peter Rosin <peda@axentia.se>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-iio-potentiometer-mcp4531
F:	drivers/iio/potentiometer/mcp4018.c
F:	drivers/iio/potentiometer/mcp4531.c

MCR20A IEEE-802.15.4 RADIO DRIVER
M:	Xue Liu <liuxuenetmail@gmail.com>
L:	linux-wpan@vger.kernel.org
W:	https://github.com/xueliu/mcr20a-linux
S:	Maintained
F:	drivers/net/ieee802154/mcr20a.c
F:	drivers/net/ieee802154/mcr20a.h
F:	Documentation/devicetree/bindings/net/ieee802154/mcr20a.txt

MEASUREMENT COMPUTING CIO-DAC IIO DRIVER
M:	William Breathitt Gray <vilhelm.gray@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	drivers/iio/dac/cio-dac.c

MEDIA DRIVERS FOR ASCOT2E
M:	Sergey Kozlov <serjk@netup.ru>
M:	Abylay Ospan <aospan@netup.ru>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://netup.tv/
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	drivers/media/dvb-frontends/ascot2e*

MEDIA DRIVERS FOR CXD2099AR CI CONTROLLERS
M:	Jasmin Jessich <jasmin@anw.at>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/cxd2099*

MEDIA DRIVERS FOR CXD2841ER
M:	Sergey Kozlov <serjk@netup.ru>
M:	Abylay Ospan <aospan@netup.ru>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://netup.tv/
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	drivers/media/dvb-frontends/cxd2841er*

MEDIA DRIVERS FOR CXD2880
M:	Yasunari Takiguchi <Yasunari.Takiguchi@sony.com>
L:	linux-media@vger.kernel.org
W:	http://linuxtv.org/
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	drivers/media/dvb-frontends/cxd2880/*
F:	drivers/media/spi/cxd2880*

MEDIA DRIVERS FOR DIGITAL DEVICES PCIE DEVICES
M:	Daniel Scheller <d.scheller.oss@gmail.com>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/pci/ddbridge/*

MEDIA DRIVERS FOR FREESCALE IMX
M:	Steve Longerbeam <slongerbeam@gmail.com>
M:	Philipp Zabel <p.zabel@pengutronix.de>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	Documentation/devicetree/bindings/media/imx.txt
F:	Documentation/media/v4l-drivers/imx.rst
F:	drivers/staging/media/imx/
F:	include/linux/imx-media.h
F:	include/media/imx.h

MEDIA DRIVERS FOR HELENE
M:	Abylay Ospan <aospan@netup.ru>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://netup.tv/
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	drivers/media/dvb-frontends/helene*

MEDIA DRIVERS FOR HORUS3A
M:	Sergey Kozlov <serjk@netup.ru>
M:	Abylay Ospan <aospan@netup.ru>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://netup.tv/
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	drivers/media/dvb-frontends/horus3a*

MEDIA DRIVERS FOR LNBH25
M:	Sergey Kozlov <serjk@netup.ru>
M:	Abylay Ospan <aospan@netup.ru>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://netup.tv/
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	drivers/media/dvb-frontends/lnbh25*

MEDIA DRIVERS FOR MXL5XX TUNER DEMODULATORS
M:	Daniel Scheller <d.scheller.oss@gmail.com>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/mxl5xx*

MEDIA DRIVERS FOR NETUP PCI UNIVERSAL DVB devices
M:	Sergey Kozlov <serjk@netup.ru>
M:	Abylay Ospan <aospan@netup.ru>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://netup.tv/
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	drivers/media/pci/netup_unidvb/*

MEDIA DRIVERS FOR RENESAS - CEU
M:	Jacopo Mondi <jacopo@jmondi.org>
L:	linux-media@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	Documentation/devicetree/bindings/media/renesas,ceu.txt
F:	drivers/media/platform/renesas-ceu.c
F:	include/media/drv-intf/renesas-ceu.h

MEDIA DRIVERS FOR RENESAS - DRIF
M:	Ramesh Shanmugasundaram <ramesh.shanmugasundaram@bp.renesas.com>
L:	linux-media@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	Documentation/devicetree/bindings/media/renesas,drif.txt
F:	drivers/media/platform/rcar_drif.c

MEDIA DRIVERS FOR RENESAS - FCP
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-media@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	Documentation/devicetree/bindings/media/renesas,fcp.txt
F:	drivers/media/platform/rcar-fcp.c
F:	include/media/rcar-fcp.h

MEDIA DRIVERS FOR RENESAS - FDP1
M:	Kieran Bingham <kieran@bingham.xyz>
L:	linux-media@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	Documentation/devicetree/bindings/media/renesas,fdp1.txt
F:	drivers/media/platform/rcar_fdp1.c

MEDIA DRIVERS FOR RENESAS - VIN
M:	Niklas Söderlund <niklas.soderlund@ragnatech.se>
L:	linux-media@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	Documentation/devicetree/bindings/media/renesas,rcar-csi2.txt
F:	Documentation/devicetree/bindings/media/rcar_vin.txt
F:	drivers/media/platform/rcar-vin/

MEDIA DRIVERS FOR RENESAS - VSP1
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-media@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	Documentation/devicetree/bindings/media/renesas,vsp1.txt
F:	drivers/media/platform/vsp1/

MEDIA DRIVERS FOR ST STV0910 DEMODULATOR ICs
M:	Daniel Scheller <d.scheller.oss@gmail.com>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/stv0910*

MEDIA DRIVERS FOR ST STV6111 TUNER ICs
M:	Daniel Scheller <d.scheller.oss@gmail.com>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/stv6111*

MEDIA DRIVERS FOR NVIDIA TEGRA - VDE
M:	Dmitry Osipenko <digetx@gmail.com>
L:	linux-media@vger.kernel.org
L:	linux-tegra@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	Documentation/devicetree/bindings/media/nvidia,tegra-vde.txt
F:	drivers/staging/media/tegra-vde/

MEDIA INPUT INFRASTRUCTURE (V4L/DVB)
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
P:	LinuxTV.org Project
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
Q:	http://patchwork.kernel.org/project/linux-media/list/
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	Documentation/devicetree/bindings/media/
F:	Documentation/media/
F:	drivers/media/
F:	drivers/staging/media/
F:	include/linux/platform_data/media/
F:	include/media/
F:	include/uapi/linux/dvb/
F:	include/uapi/linux/videodev2.h
F:	include/uapi/linux/media.h
F:	include/uapi/linux/v4l2-*
F:	include/uapi/linux/meye.h
F:	include/uapi/linux/ivtv*
F:	include/uapi/linux/uvcvideo.h

MEDIATEK CIR DRIVER
M:	Sean Wang <sean.wang@mediatek.com>
S:	Maintained
F:	drivers/media/rc/mtk-cir.c

MEDIATEK DMA DRIVER
M:	Sean Wang <sean.wang@mediatek.com>
L:	dmaengine@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/dma/mtk-*
F:	drivers/dma/mediatek/

MEDIATEK PMIC LED DRIVER
M:	Sean Wang <sean.wang@mediatek.com>
S:	Maintained
F:	drivers/leds/leds-mt6323.c
F:	Documentation/devicetree/bindings/leds/leds-mt6323.txt

MEDIATEK ETHERNET DRIVER
M:	Felix Fietkau <nbd@openwrt.org>
M:	John Crispin <john@phrozen.org>
M:	Sean Wang <sean.wang@mediatek.com>
M:	Nelson Chang <nelson.chang@mediatek.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/mediatek/

MEDIATEK SWITCH DRIVER
M:	Sean Wang <sean.wang@mediatek.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/dsa/mt7530.*
F:	net/dsa/tag_mtk.c

MEDIATEK JPEG DRIVER
M:	Rick Chang <rick.chang@mediatek.com>
M:	Bin Liu <bin.liu@mediatek.com>
S:	Supported
F:	drivers/media/platform/mtk-jpeg/
F:	Documentation/devicetree/bindings/media/mediatek-jpeg-decoder.txt

MEDIATEK MDP DRIVER
M:	Minghsiu Tsai <minghsiu.tsai@mediatek.com>
M:	Houlong Wei <houlong.wei@mediatek.com>
M:	Andrew-CT Chen <andrew-ct.chen@mediatek.com>
S:	Supported
F:	drivers/media/platform/mtk-mdp/
F:	drivers/media/platform/mtk-vpu/
F:	Documentation/devicetree/bindings/media/mediatek-mdp.txt

MEDIATEK MEDIA DRIVER
M:	Tiffany Lin <tiffany.lin@mediatek.com>
M:	Andrew-CT Chen <andrew-ct.chen@mediatek.com>
S:	Supported
F:	drivers/media/platform/mtk-vcodec/
F:	drivers/media/platform/mtk-vpu/
F:	Documentation/devicetree/bindings/media/mediatek-vcodec.txt
F:	Documentation/devicetree/bindings/media/mediatek-vpu.txt

MEDIATEK MT7601U WIRELESS LAN DRIVER
M:	Jakub Kicinski <kubakici@wp.pl>
L:	linux-wireless@vger.kernel.org
S:	Maintained
F:	drivers/net/wireless/mediatek/mt7601u/

MEDIATEK NAND CONTROLLER DRIVER
M:	Xiaolei Li <xiaolei.li@mediatek.com>
L:	linux-mtd@lists.infradead.org
S:	Maintained
F:	drivers/mtd/nand/raw/mtk_*
F:	Documentation/devicetree/bindings/mtd/mtk-nand.txt

MEDIATEK RANDOM NUMBER GENERATOR SUPPORT
M:	Sean Wang <sean.wang@mediatek.com>
S:	Maintained
F:	drivers/char/hw_random/mtk-rng.c

MEDIATEK USB3 DRD IP DRIVER
M:	Chunfeng Yun <chunfeng.yun@mediatek.com>
L:	linux-usb@vger.kernel.org (moderated for non-subscribers)
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/usb/mtu3/

MEGACHIPS STDPXXXX-GE-B850V3-FW LVDS/DP++ BRIDGES
M:	Peter Senna Tschudin <peter.senna@collabora.com>
M:	Martin Donnelly <martin.donnelly@ge.com>
M:	Martyn Welch <martyn.welch@collabora.co.uk>
S:	Maintained
F:	drivers/gpu/drm/bridge/megachips-stdpxxxx-ge-b850v3-fw.c
F:	Documentation/devicetree/bindings/video/bridge/megachips-stdpxxxx-ge-b850v3-fw.txt

MEGARAID SCSI/SAS DRIVERS
M:	Kashyap Desai <kashyap.desai@broadcom.com>
M:	Sumit Saxena <sumit.saxena@broadcom.com>
M:	Shivasharan S <shivasharan.srikanteshwara@broadcom.com>
L:	megaraidlinux.pdl@broadcom.com
L:	linux-scsi@vger.kernel.org
W:	http://www.avagotech.com/support/
S:	Maintained
F:	Documentation/scsi/megaraid.txt
F:	drivers/scsi/megaraid.*
F:	drivers/scsi/megaraid/

MELEXIS MLX90614 DRIVER
M:	Crt Mori <cmo@melexis.com>
L:	linux-iio@vger.kernel.org
W:	http://www.melexis.com
S:	Supported
F:	drivers/iio/temperature/mlx90614.c

MELEXIS MLX90632 DRIVER
M:	Crt Mori <cmo@melexis.com>
L:	linux-iio@vger.kernel.org
W:	http://www.melexis.com
S:	Supported
F:	drivers/iio/temperature/mlx90632.c

MELFAS MIP4 TOUCHSCREEN DRIVER
M:	Sangwon Jee <jeesw@melfas.com>
W:	http://www.melfas.com
S:	Supported
F:	drivers/input/touchscreen/melfas_mip4.c
F:	Documentation/devicetree/bindings/input/touchscreen/melfas_mip4.txt

MELLANOX ETHERNET DRIVER (mlx4_en)
M:	Tariq Toukan <tariqt@mellanox.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	http://patchwork.ozlabs.org/project/netdev/list/
F:	drivers/net/ethernet/mellanox/mlx4/en_*

MELLANOX ETHERNET DRIVER (mlx5e)
M:	Saeed Mahameed <saeedm@mellanox.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	http://patchwork.ozlabs.org/project/netdev/list/
F:	drivers/net/ethernet/mellanox/mlx5/core/en_*

MELLANOX ETHERNET INNOVA DRIVERS
R:	Boris Pismenny <borisp@mellanox.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	http://patchwork.ozlabs.org/project/netdev/list/
F:	drivers/net/ethernet/mellanox/mlx5/core/en_accel/*
F:	drivers/net/ethernet/mellanox/mlx5/core/accel/*
F:	drivers/net/ethernet/mellanox/mlx5/core/fpga/*
F:	include/linux/mlx5/mlx5_ifc_fpga.h

MELLANOX ETHERNET INNOVA IPSEC DRIVER
R:	Boris Pismenny <borisp@mellanox.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	http://patchwork.ozlabs.org/project/netdev/list/
F:	drivers/net/ethernet/mellanox/mlx5/core/en_ipsec/*
F:	drivers/net/ethernet/mellanox/mlx5/core/ipsec*

MELLANOX ETHERNET SWITCH DRIVERS
M:	Jiri Pirko <jiri@mellanox.com>
M:	Ido Schimmel <idosch@mellanox.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	http://patchwork.ozlabs.org/project/netdev/list/
F:	drivers/net/ethernet/mellanox/mlxsw/

MELLANOX FIRMWARE FLASH LIBRARY (mlxfw)
M:	mlxsw@mellanox.com
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	http://patchwork.ozlabs.org/project/netdev/list/
F:	drivers/net/ethernet/mellanox/mlxfw/

MELLANOX HARDWARE PLATFORM SUPPORT
M:	Andy Shevchenko <andy@infradead.org>
M:	Darren Hart <dvhart@infradead.org>
M:	Vadim Pasternak <vadimp@mellanox.com>
L:	platform-driver-x86@vger.kernel.org
S:	Supported
F:	drivers/platform/mellanox/

MELLANOX MLX4 core VPI driver
M:	Tariq Toukan <tariqt@mellanox.com>
L:	netdev@vger.kernel.org
L:	linux-rdma@vger.kernel.org
W:	http://www.mellanox.com
Q:	http://patchwork.ozlabs.org/project/netdev/list/
S:	Supported
F:	drivers/net/ethernet/mellanox/mlx4/
F:	include/linux/mlx4/

MELLANOX MLX4 IB driver
M:	Yishai Hadas <yishaih@mellanox.com>
L:	linux-rdma@vger.kernel.org
W:	http://www.mellanox.com
Q:	http://patchwork.kernel.org/project/linux-rdma/list/
S:	Supported
F:	drivers/infiniband/hw/mlx4/
F:	include/linux/mlx4/
F:	include/uapi/rdma/mlx4-abi.h

MELLANOX MLX5 core VPI driver
M:	Saeed Mahameed <saeedm@mellanox.com>
M:	Leon Romanovsky <leonro@mellanox.com>
L:	netdev@vger.kernel.org
L:	linux-rdma@vger.kernel.org
W:	http://www.mellanox.com
Q:	http://patchwork.ozlabs.org/project/netdev/list/
S:	Supported
F:	drivers/net/ethernet/mellanox/mlx5/core/
F:	include/linux/mlx5/

MELLANOX MLX5 IB driver
M:	Leon Romanovsky <leonro@mellanox.com>
L:	linux-rdma@vger.kernel.org
W:	http://www.mellanox.com
Q:	http://patchwork.kernel.org/project/linux-rdma/list/
S:	Supported
F:	drivers/infiniband/hw/mlx5/
F:	include/linux/mlx5/
F:	include/uapi/rdma/mlx5-abi.h

MELLANOX MLXCPLD I2C AND MUX DRIVER
M:	Vadim Pasternak <vadimp@mellanox.com>
M:	Michael Shych <michaelsh@mellanox.com>
L:	linux-i2c@vger.kernel.org
S:	Supported
F:	drivers/i2c/busses/i2c-mlxcpld.c
F:	drivers/i2c/muxes/i2c-mux-mlxcpld.c
F:	Documentation/i2c/busses/i2c-mlxcpld

MELLANOX MLXCPLD LED DRIVER
M:	Vadim Pasternak <vadimp@mellanox.com>
L:	linux-leds@vger.kernel.org
S:	Supported
F:	drivers/leds/leds-mlxcpld.c
F:	drivers/leds/leds-mlxreg.c
F:	Documentation/leds/leds-mlxcpld.txt

MELLANOX PLATFORM DRIVER
M:	Vadim Pasternak <vadimp@mellanox.com>
L:	platform-driver-x86@vger.kernel.org
S:	Supported
F:	drivers/platform/x86/mlx-platform.c

MEMBARRIER SUPPORT
M:	Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
M:	"Paul E. McKenney" <paulmck@linux.vnet.ibm.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	kernel/sched/membarrier.c
F:	include/uapi/linux/membarrier.h
F:	arch/powerpc/include/asm/membarrier.h

MEMORY MANAGEMENT
L:	linux-mm@kvack.org
W:	http://www.linux-mm.org
S:	Maintained
F:	include/linux/mm.h
F:	include/linux/gfp.h
F:	include/linux/mmzone.h
F:	include/linux/memory_hotplug.h
F:	include/linux/vmalloc.h
F:	mm/

MEMORY TECHNOLOGY DEVICES (MTD)
M:	David Woodhouse <dwmw2@infradead.org>
M:	Brian Norris <computersforpeace@gmail.com>
M:	Boris Brezillon <boris.brezillon@bootlin.com>
M:	Marek Vasut <marek.vasut@gmail.com>
M:	Richard Weinberger <richard@nod.at>
L:	linux-mtd@lists.infradead.org
W:	http://www.linux-mtd.infradead.org/
Q:	http://patchwork.ozlabs.org/project/linux-mtd/list/
T:	git git://git.infradead.org/linux-mtd.git master
T:	git git://git.infradead.org/linux-mtd.git mtd/next
S:	Maintained
F:	Documentation/devicetree/bindings/mtd/
F:	drivers/mtd/
F:	include/linux/mtd/
F:	include/uapi/mtd/

MEN A21 WATCHDOG DRIVER
M:	Johannes Thumshirn <morbidrsa@gmail.com>
L:	linux-watchdog@vger.kernel.org
S:	Maintained
F:	drivers/watchdog/mena21_wdt.c

MEN CHAMELEON BUS (mcb)
M:	Johannes Thumshirn <morbidrsa@gmail.com>
S:	Maintained
F:	drivers/mcb/
F:	include/linux/mcb.h
F:	Documentation/men-chameleon-bus.txt

MEN F21BMC (Board Management Controller)
M:	Andreas Werner <andreas.werner@men.de>
S:	Supported
F:	drivers/mfd/menf21bmc.c
F:	drivers/watchdog/menf21bmc_wdt.c
F:	drivers/leds/leds-menf21bmc.c
F:	drivers/hwmon/menf21bmc_hwmon.c
F:	Documentation/hwmon/menf21bmc

MESON AO CEC DRIVER FOR AMLOGIC SOCS
M:	Neil Armstrong <narmstrong@baylibre.com>
L:	linux-media@lists.freedesktop.org
L:	linux-amlogic@lists.infradead.org
W:	http://linux-meson.com/
S:	Supported
F:	drivers/media/platform/meson/ao-cec.c
F:	Documentation/devicetree/bindings/media/meson-ao-cec.txt
T:	git git://linuxtv.org/media_tree.git

MICROBLAZE ARCHITECTURE
M:	Michal Simek <monstr@monstr.eu>
W:	http://www.monstr.eu/fdt/
T:	git git://git.monstr.eu/linux-2.6-microblaze.git
S:	Supported
F:	arch/microblaze/

MICROCHIP / ATMEL AT91 SERIAL DRIVER
M:	Richard Genoud <richard.genoud@gmail.com>
S:	Maintained
F:	drivers/tty/serial/atmel_serial.c
F:	drivers/tty/serial/atmel_serial.h

MICROCHIP / ATMEL DMA DRIVER
M:	Ludovic Desroches <ludovic.desroches@microchip.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	dmaengine@vger.kernel.org
S:	Supported
F:	drivers/dma/at_hdmac.c
F:	drivers/dma/at_hdmac_regs.h
F:	include/linux/platform_data/dma-atmel.h

MICROCHIP / ATMEL ECC DRIVER
M:	Tudor Ambarus <tudor.ambarus@microchip.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	drivers/crypto/atmel-ecc.*

MICROCHIP / ATMEL ISC DRIVER
M:	Songjun Wu <songjun.wu@microchip.com>
L:	linux-media@vger.kernel.org
S:	Supported
F:	drivers/media/platform/atmel/atmel-isc.c
F:	drivers/media/platform/atmel/atmel-isc-regs.h
F:	devicetree/bindings/media/atmel-isc.txt

MICROCHIP / ATMEL NAND DRIVER
M:	Wenyou Yang <wenyou.yang@microchip.com>
M:	Josh Wu <rainyfeeling@outlook.com>
L:	linux-mtd@lists.infradead.org
S:	Supported
F:	drivers/mtd/nand/raw/atmel/*
F:	Documentation/devicetree/bindings/mtd/atmel-nand.txt

MICROCHIP KSZ SERIES ETHERNET SWITCH DRIVER
M:	Woojung Huh <Woojung.Huh@microchip.com>
M:	Microchip Linux Driver Support <UNGLinuxDriver@microchip.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	net/dsa/tag_ksz.c
F:	drivers/net/dsa/microchip/*
F:	include/linux/platform_data/microchip-ksz.h
F:	Documentation/devicetree/bindings/net/dsa/ksz.txt

MICROCHIP LAN743X ETHERNET DRIVER
M:	Bryan Whitehead <bryan.whitehead@microchip.com>
M:	Microchip Linux Driver Support <UNGLinuxDriver@microchip.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/microchip/lan743x_*

MICROCHIP USB251XB DRIVER
M:	Richard Leitner <richard.leitner@skidata.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/misc/usb251xb.c
F:	Documentation/devicetree/bindings/usb/usb251xb.txt

MICROSEMI MIPS SOCS
M:	Alexandre Belloni <alexandre.belloni@bootlin.com>
L:	linux-mips@linux-mips.org
S:	Maintained
F:	arch/mips/generic/board-ocelot.c
F:	arch/mips/configs/generic/board-ocelot.config
F:	arch/mips/boot/dts/mscc/
F:	Documentation/devicetree/bindings/mips/mscc.txt

MICROSEMI SMART ARRAY SMARTPQI DRIVER (smartpqi)
M:	Don Brace <don.brace@microsemi.com>
L:	esc.storagedev@microsemi.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/smartpqi/smartpqi*.[ch]
F:	drivers/scsi/smartpqi/Kconfig
F:	drivers/scsi/smartpqi/Makefile
F:	include/linux/cciss*.h
F:	include/uapi/linux/cciss*.h
F:	Documentation/scsi/smartpqi.txt

MICROSEMI ETHERNET SWITCH DRIVER
M:	Alexandre Belloni <alexandre.belloni@bootlin.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/mscc/

MICROSOFT SURFACE PRO 3 BUTTON DRIVER
M:	Chen Yu <yu.c.chen@intel.com>
L:	platform-driver-x86@vger.kernel.org
S:	Supported
F:	drivers/platform/x86/surfacepro3_button.c

MICROTEK X6 SCANNER
M:	Oliver Neukum <oliver@neukum.org>
S:	Maintained
F:	drivers/usb/image/microtek.*

MIPS
M:	Ralf Baechle <ralf@linux-mips.org>
M:	Paul Burton <paul.burton@mips.com>
M:	James Hogan <jhogan@kernel.org>
L:	linux-mips@linux-mips.org
W:	http://www.linux-mips.org/
T:	git git://git.linux-mips.org/pub/scm/ralf/linux.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mips/linux.git
Q:	http://patchwork.linux-mips.org/project/linux-mips/list/
S:	Supported
F:	Documentation/devicetree/bindings/mips/
F:	Documentation/mips/
F:	arch/mips/
F:	drivers/platform/mips/

MIPS BOSTON DEVELOPMENT BOARD
M:	Paul Burton <paul.burton@mips.com>
L:	linux-mips@linux-mips.org
S:	Maintained
F:	Documentation/devicetree/bindings/clock/img,boston-clock.txt
F:	arch/mips/boot/dts/img/boston.dts
F:	arch/mips/configs/generic/board-boston.config
F:	drivers/clk/imgtec/clk-boston.c
F:	include/dt-bindings/clock/boston-clock.h

MIPS GENERIC PLATFORM
M:	Paul Burton <paul.burton@mips.com>
L:	linux-mips@linux-mips.org
S:	Supported
F:	Documentation/devicetree/bindings/power/mti,mips-cpc.txt
F:	arch/mips/generic/
F:	arch/mips/tools/generic-board-config.sh

MIPS/LOONGSON1 ARCHITECTURE
M:	Keguang Zhang <keguang.zhang@gmail.com>
L:	linux-mips@linux-mips.org
S:	Maintained
F:	arch/mips/loongson32/
F:	arch/mips/include/asm/mach-loongson32/
F:	drivers/*/*loongson1*
F:	drivers/*/*/*loongson1*

MIPS/LOONGSON2 ARCHITECTURE
M:	Jiaxun Yang <jiaxun.yang@flygoat.com>
L:	linux-mips@linux-mips.org
S:	Maintained
F:	arch/mips/loongson64/*{2e/2f}*
F:	arch/mips/include/asm/mach-loongson64/
F:	drivers/*/*loongson2*
F:	drivers/*/*/*loongson2*

MIPS/LOONGSON3 ARCHITECTURE
M:	Huacai Chen <chenhc@lemote.com>
L:	linux-mips@linux-mips.org
S:	Maintained
F:	arch/mips/loongson64/
F:	arch/mips/include/asm/mach-loongson64/
F:	drivers/platform/mips/cpu_hwmon.c
F:	drivers/*/*loongson3*
F:	drivers/*/*/*loongson3*

MIPS RINT INSTRUCTION EMULATION
M:	Aleksandar Markovic <aleksandar.markovic@mips.com>
L:	linux-mips@linux-mips.org
S:	Supported
F:	arch/mips/math-emu/sp_rint.c
F:	arch/mips/math-emu/dp_rint.c

MIROSOUND PCM20 FM RADIO RECEIVER DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Odd Fixes
F:	drivers/media/radio/radio-miropcm20*

MMP SUPPORT
M:	Eric Miao <eric.y.miao@gmail.com>
M:	Haojian Zhuang <haojian.zhuang@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://github.com/hzhuang1/linux.git
T:	git git://git.linaro.org/people/ycmiao/pxa-linux.git
S:	Maintained
F:	arch/arm/boot/dts/mmp*
F:	arch/arm/mach-mmp/

MN88472 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
S:	Maintained
F:	drivers/media/dvb-frontends/mn88472*

MN88473 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
S:	Maintained
F:	drivers/media/dvb-frontends/mn88473*

PCI DRIVER FOR MOBIVEIL PCIE IP
M:	Subrahmanya Lingappa <l.subrahmanya@mobiveil.co.in>
L:	linux-pci@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/pci/mobiveil-pcie.txt
F:	drivers/pci/controller/pcie-mobiveil.c

MODULE SUPPORT
M:	Jessica Yu <jeyu@kernel.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jeyu/linux.git modules-next
S:	Maintained
F:	include/linux/module.h
F:	kernel/module.c

MOTION EYE VAIO PICTUREBOOK CAMERA DRIVER
W:	http://popies.net/meye/
S:	Orphan
F:	Documentation/media/v4l-drivers/meye*
F:	drivers/media/pci/meye/
F:	include/uapi/linux/meye.h

MOXA SMARTIO/INDUSTIO/INTELLIO SERIAL CARD
M:	Jiri Slaby <jirislaby@gmail.com>
S:	Maintained
F:	Documentation/serial/moxa-smartio
F:	drivers/tty/mxser.*

MR800 AVERMEDIA USB FM RADIO DRIVER
M:	Alexey Klimov <klimov.linux@gmail.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/radio/radio-mr800.c

MRF24J40 IEEE 802.15.4 RADIO DRIVER
M:	Alan Ott <alan@signal11.us>
L:	linux-wpan@vger.kernel.org
S:	Maintained
F:	drivers/net/ieee802154/mrf24j40.c
F:	Documentation/devicetree/bindings/net/ieee802154/mrf24j40.txt

MSI LAPTOP SUPPORT
M:	"Lee, Chun-Yi" <jlee@suse.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/msi-laptop.c

MSI WMI SUPPORT
L:	platform-driver-x86@vger.kernel.org
S:	Orphan
F:	drivers/platform/x86/msi-wmi.c

MSI001 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/tuners/msi001*

MSI2500 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/usb/msi2500/

MSYSTEMS DISKONCHIP G3 MTD DRIVER
M:	Robert Jarzmik <robert.jarzmik@free.fr>
L:	linux-mtd@lists.infradead.org
S:	Maintained
F:	drivers/mtd/devices/docg3*

MT9M032 APTINA SENSOR DRIVER
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/mt9m032.c
F:	include/media/i2c/mt9m032.h

MT9P031 APTINA CAMERA SENSOR
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/mt9p031.c
F:	include/media/i2c/mt9p031.h

MT9T001 APTINA CAMERA SENSOR
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/mt9t001.c
F:	include/media/i2c/mt9t001.h

MT9T112 APTINA CAMERA SENSOR
M:	Jacopo Mondi <jacopo@jmondi.org>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Odd Fixes
F:	drivers/media/i2c/mt9t112.c
F:	include/media/i2c/mt9t112.h

MT9V032 APTINA CAMERA SENSOR
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	Documentation/devicetree/bindings/media/i2c/mt9v032.txt
F:	drivers/media/i2c/mt9v032.c
F:	include/media/i2c/mt9v032.h

MULTIFUNCTION DEVICES (MFD)
M:	Lee Jones <lee.jones@linaro.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd.git
S:	Supported
F:	Documentation/devicetree/bindings/mfd/
F:	drivers/mfd/
F:	include/linux/mfd/
F:	include/dt-bindings/mfd/

MULTIMEDIA CARD (MMC) ETC. OVER SPI
S:	Orphan
F:	drivers/mmc/host/mmc_spi.c
F:	include/linux/spi/mmc_spi.h

MULTIMEDIA CARD (MMC), SECURE DIGITAL (SD) AND SDIO SUBSYSTEM
M:	Ulf Hansson <ulf.hansson@linaro.org>
L:	linux-mmc@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ulfh/mmc.git
S:	Maintained
F:	Documentation/devicetree/bindings/mmc/
F:	drivers/mmc/
F:	include/linux/mmc/
F:	include/uapi/linux/mmc/

MULTIPLEXER SUBSYSTEM
M:	Peter Rosin <peda@axentia.se>
S:	Maintained
F:	Documentation/ABI/testing/mux/sysfs-class-mux*
F:	Documentation/devicetree/bindings/mux/
F:	include/linux/dt-bindings/mux/
F:	include/linux/mux/
F:	drivers/mux/

MULTITECH MULTIPORT CARD (ISICOM)
S:	Orphan
F:	drivers/tty/isicom.c
F:	include/linux/isicom.h

MUSB MULTIPOINT HIGH SPEED DUAL-ROLE CONTROLLER
M:	Bin Liu <b-liu@ti.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/musb/

MXL5007T MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://github.com/mkrufky
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/mkrufky/tuners.git
S:	Maintained
F:	drivers/media/tuners/mxl5007t.*

MXSFB DRM DRIVER
M:	Marek Vasut <marex@denx.de>
S:	Supported
F:	drivers/gpu/drm/mxsfb/
F:	Documentation/devicetree/bindings/display/mxsfb-drm.txt

MYRICOM MYRI-10G 10GbE DRIVER (MYRI10GE)
M:	Chris Lee <christopher.lee@cspi.com>
L:	netdev@vger.kernel.org
W:	https://www.cspi.com/ethernet-products/support/downloads/
S:	Supported
F:	drivers/net/ethernet/myricom/myri10ge/

NAND FLASH SUBSYSTEM
M:	Boris Brezillon <boris.brezillon@bootlin.com>
M:	Miquel Raynal <miquel.raynal@bootlin.com>
R:	Richard Weinberger <richard@nod.at>
L:	linux-mtd@lists.infradead.org
W:	http://www.linux-mtd.infradead.org/
Q:	http://patchwork.ozlabs.org/project/linux-mtd/list/
T:	git git://git.infradead.org/linux-mtd.git nand/fixes
T:	git git://git.infradead.org/linux-mtd.git nand/next
S:	Maintained
F:	drivers/mtd/nand/
F:	include/linux/mtd/*nand*.h

NATIVE INSTRUMENTS USB SOUND INTERFACE DRIVER
M:	Daniel Mack <zonque@gmail.com>
S:	Maintained
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
W:	http://www.native-instruments.com
F:	sound/usb/caiaq/

NATSEMI ETHERNET DRIVER (DP8381x)
S:	Orphan
F:	drivers/net/ethernet/natsemi/natsemi.c

NCP FILESYSTEM
M:	Petr Vandrovec <petr@vandrovec.name>
S:	Obsolete
F:	drivers/staging/ncpfs/

NCR 5380 SCSI DRIVERS
M:	Finn Thain <fthain@telegraphics.com.au>
M:	Michael Schmitz <schmitzmic@gmail.com>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	Documentation/scsi/g_NCR5380.txt
F:	drivers/scsi/NCR5380.*
F:	drivers/scsi/arm/cumana_1.c
F:	drivers/scsi/arm/oak.c
F:	drivers/scsi/atari_scsi.*
F:	drivers/scsi/dmx3191d.c
F:	drivers/scsi/g_NCR5380.*
F:	drivers/scsi/mac_scsi.*
F:	drivers/scsi/sun3_scsi.*
F:	drivers/scsi/sun3_scsi_vme.c

NCR DUAL 700 SCSI DRIVER (MICROCHANNEL)
M:	"James E.J. Bottomley" <James.Bottomley@HansenPartnership.com>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	drivers/scsi/NCR_D700.*

NCT6775 HARDWARE MONITOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/nct6775
F:	drivers/hwmon/nct6775.c

NET_FAILOVER MODULE
M:	Sridhar Samudrala <sridhar.samudrala@intel.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	driver/net/net_failover.c
F:	include/net/net_failover.h
F:	Documentation/networking/net_failover.rst

NETEFFECT IWARP RNIC DRIVER (IW_NES)
M:	Faisal Latif <faisal.latif@intel.com>
L:	linux-rdma@vger.kernel.org
W:	http://www.intel.com/Products/Server/Adapters/Server-Cluster/Server-Cluster-overview.htm
S:	Supported
F:	drivers/infiniband/hw/nes/
F:	include/uapi/rdma/nes-abi.h

NETEM NETWORK EMULATOR
M:	Stephen Hemminger <stephen@networkplumber.org>
L:	netem@lists.linux-foundation.org (moderated for non-subscribers)
S:	Maintained
F:	net/sched/sch_netem.c

NETERION 10GbE DRIVERS (s2io/vxge)
M:	Jon Mason <jdmason@kudzu.us>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/s2io.txt
F:	Documentation/networking/vxge.txt
F:	drivers/net/ethernet/neterion/

NETFILTER
M:	Pablo Neira Ayuso <pablo@netfilter.org>
M:	Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
M:	Florian Westphal <fw@strlen.de>
L:	netfilter-devel@vger.kernel.org
L:	coreteam@netfilter.org
W:	http://www.netfilter.org/
W:	http://www.iptables.org/
W:	http://www.nftables.org/
Q:	http://patchwork.ozlabs.org/project/netfilter-devel/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf-next.git
S:	Maintained
F:	include/linux/netfilter*
F:	include/linux/netfilter/
F:	include/net/netfilter/
F:	include/uapi/linux/netfilter*
F:	include/uapi/linux/netfilter/
F:	net/*/netfilter.c
F:	net/*/netfilter/
F:	net/netfilter/
F:	net/bridge/br_netfilter*.c

NETROM NETWORK LAYER
M:	Ralf Baechle <ralf@linux-mips.org>
L:	linux-hams@vger.kernel.org
W:	http://www.linux-ax25.org/
S:	Maintained
F:	include/net/netrom.h
F:	include/uapi/linux/netrom.h
F:	net/netrom/

NETRONOME ETHERNET DRIVERS
M:	Jakub Kicinski <jakub.kicinski@netronome.com>
L:	oss-drivers@netronome.com
S:	Maintained
F:	drivers/net/ethernet/netronome/

NETWORK BLOCK DEVICE (NBD)
M:	Josef Bacik <josef@toxicpanda.com>
S:	Maintained
L:	linux-block@vger.kernel.org
L:	nbd@other.debian.org
F:	Documentation/blockdev/nbd.txt
F:	drivers/block/nbd.c
F:	include/uapi/linux/nbd.h

NETWORK DROP MONITOR
M:	Neil Horman <nhorman@tuxdriver.com>
L:	netdev@vger.kernel.org
S:	Maintained
W:	https://fedorahosted.org/dropwatch/
F:	net/core/drop_monitor.c

NETWORKING DRIVERS
M:	"David S. Miller" <davem@davemloft.net>
L:	netdev@vger.kernel.org
W:	http://www.linuxfoundation.org/en/Net
Q:	http://patchwork.ozlabs.org/project/netdev/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next.git
S:	Odd Fixes
F:	Documentation/devicetree/bindings/net/
F:	drivers/net/
F:	include/linux/if_*
F:	include/linux/netdevice.h
F:	include/linux/etherdevice.h
F:	include/linux/fcdevice.h
F:	include/linux/fddidevice.h
F:	include/linux/hippidevice.h
F:	include/linux/inetdevice.h
F:	include/uapi/linux/if_*
F:	include/uapi/linux/netdevice.h

NETWORKING DRIVERS (WIRELESS)
M:	Kalle Valo <kvalo@codeaurora.org>
L:	linux-wireless@vger.kernel.org
Q:	http://patchwork.kernel.org/project/linux-wireless/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/wireless-drivers.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/wireless-drivers-next.git
S:	Maintained
F:	Documentation/devicetree/bindings/net/wireless/
F:	drivers/net/wireless/

NETWORKING [DSA]
M:	Andrew Lunn <andrew@lunn.ch>
M:	Vivien Didelot <vivien.didelot@savoirfairelinux.com>
M:	Florian Fainelli <f.fainelli@gmail.com>
S:	Maintained
F:	net/dsa/
F:	include/net/dsa.h
F:	include/linux/dsa/
F:	drivers/net/dsa/

NETWORKING [GENERAL]
M:	"David S. Miller" <davem@davemloft.net>
L:	netdev@vger.kernel.org
W:	http://www.linuxfoundation.org/en/Net
Q:	http://patchwork.ozlabs.org/project/netdev/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next.git
B:	mailto:netdev@vger.kernel.org
S:	Maintained
F:	net/
F:	include/net/
F:	include/linux/in.h
F:	include/linux/net.h
F:	include/linux/netdevice.h
F:	include/uapi/linux/in.h
F:	include/uapi/linux/net.h
F:	include/uapi/linux/netdevice.h
F:	include/uapi/linux/net_namespace.h
F:	tools/testing/selftests/net/
F:	lib/net_utils.c
F:	lib/random32.c
F:	Documentation/networking/

NETWORKING [IPSEC]
M:	Steffen Klassert <steffen.klassert@secunet.com>
M:	Herbert Xu <herbert@gondor.apana.org.au>
M:	"David S. Miller" <davem@davemloft.net>
L:	netdev@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/klassert/ipsec.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/klassert/ipsec-next.git
S:	Maintained
F:	net/core/flow.c
F:	net/xfrm/
F:	net/key/
F:	net/ipv4/xfrm*
F:	net/ipv4/esp4*
F:	net/ipv4/ah4.c
F:	net/ipv4/ipcomp.c
F:	net/ipv4/ip_vti.c
F:	net/ipv6/xfrm*
F:	net/ipv6/esp6*
F:	net/ipv6/ah6.c
F:	net/ipv6/ipcomp6.c
F:	net/ipv6/ip6_vti.c
F:	include/uapi/linux/xfrm.h
F:	include/net/xfrm.h

NETWORKING [IPv4/IPv6]
M:	"David S. Miller" <davem@davemloft.net>
M:	Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
M:	Hideaki YOSHIFUJI <yoshfuji@linux-ipv6.org>
L:	netdev@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git
S:	Maintained
F:	net/ipv4/
F:	net/ipv6/
F:	include/net/ip*
F:	arch/x86/net/*

NETWORKING [LABELED] (NetLabel, Labeled IPsec, SECMARK)
M:	Paul Moore <paul@paul-moore.com>
W:	https://github.com/netlabel
L:	netdev@vger.kernel.org
L:	linux-security-module@vger.kernel.org
S:	Maintained
F:	Documentation/netlabel/
F:	include/net/calipso.h
F:	include/net/cipso_ipv4.h
F:	include/net/netlabel.h
F:	include/uapi/linux/netfilter/xt_SECMARK.h
F:	include/uapi/linux/netfilter/xt_CONNSECMARK.h
F:	net/netlabel/
F:	net/ipv4/cipso_ipv4.c
F:	net/ipv6/calipso.c
F:	net/netfilter/xt_CONNSECMARK.c
F:	net/netfilter/xt_SECMARK.c

NETWORKING [TCP]
M:	Eric Dumazet <edumazet@google.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	net/ipv4/tcp*.c
F:	net/ipv4/syncookies.c
F:	net/ipv6/tcp*.c
F:	net/ipv6/syncookies.c
F:	include/uapi/linux/tcp.h
F:	include/net/tcp.h
F:	include/linux/tcp.h
F:	include/trace/events/tcp.h

NETWORKING [TLS]
M:	Boris Pismenny <borisp@mellanox.com>
M:	Aviad Yehezkel <aviadye@mellanox.com>
M:	Dave Watson <davejwatson@fb.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	net/tls/*
F:	include/uapi/linux/tls.h
F:	include/net/tls.h

NETWORKING [WIRELESS]
L:	linux-wireless@vger.kernel.org
Q:	http://patchwork.kernel.org/project/linux-wireless/list/

NETDEVSIM
M:	Jakub Kicinski <jakub.kicinski@netronome.com>
S:	Maintained
F:	drivers/net/netdevsim/*

NETXEN (1/10) GbE SUPPORT
M:	Manish Chopra <manish.chopra@cavium.com>
M:	Rahul Verma <rahul.verma@cavium.com>
M:	Dept-GELinuxNICDev@cavium.com
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/qlogic/netxen/

NFC SUBSYSTEM
M:	Samuel Ortiz <sameo@linux.intel.com>
L:	linux-wireless@vger.kernel.org
L:	linux-nfc@lists.01.org (subscribers-only)
S:	Supported
F:	net/nfc/
F:	include/net/nfc/
F:	include/uapi/linux/nfc.h
F:	drivers/nfc/
F:	include/linux/platform_data/nfcmrvl.h
F:	include/linux/platform_data/nxp-nci.h
F:	Documentation/devicetree/bindings/net/nfc/

NFS, SUNRPC, AND LOCKD CLIENTS
M:	Trond Myklebust <trond.myklebust@hammerspace.com>
M:	Anna Schumaker <anna.schumaker@netapp.com>
L:	linux-nfs@vger.kernel.org
W:	http://client.linux-nfs.org
T:	git git://git.linux-nfs.org/projects/trondmy/linux-nfs.git
S:	Maintained
F:	fs/lockd/
F:	fs/nfs/
F:	fs/nfs_common/
F:	net/sunrpc/
F:	include/linux/lockd/
F:	include/linux/nfs*
F:	include/linux/sunrpc/
F:	include/uapi/linux/nfs*
F:	include/uapi/linux/sunrpc/

NILFS2 FILESYSTEM
M:	Ryusuke Konishi <konishi.ryusuke@lab.ntt.co.jp>
L:	linux-nilfs@vger.kernel.org
W:	https://nilfs.sourceforge.io/
W:	https://nilfs.osdn.jp/
T:	git git://github.com/konis/nilfs2.git
S:	Supported
F:	Documentation/filesystems/nilfs2.txt
F:	fs/nilfs2/
F:	include/trace/events/nilfs2.h
F:	include/uapi/linux/nilfs2_api.h
F:	include/uapi/linux/nilfs2_ondisk.h

NINJA SCSI-3 / NINJA SCSI-32Bi (16bit/CardBus) PCMCIA SCSI HOST ADAPTER DRIVER
M:	YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp>
W:	http://www.netlab.is.tsukuba.ac.jp/~yokota/izumi/ninja/
S:	Maintained
F:	Documentation/scsi/NinjaSCSI.txt
F:	drivers/scsi/pcmcia/nsp_*

NINJA SCSI-32Bi/UDE PCI/CARDBUS SCSI HOST ADAPTER DRIVER
M:	GOTO Masanori <gotom@debian.or.jp>
M:	YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp>
W:	http://www.netlab.is.tsukuba.ac.jp/~yokota/izumi/ninja/
S:	Maintained
F:	Documentation/scsi/NinjaSCSI.txt
F:	drivers/scsi/nsp32*

NIOS2 ARCHITECTURE
M:	Ley Foon Tan <lftan@altera.com>
L:	nios2-dev@lists.rocketboards.org (moderated for non-subscribers)
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lftan/nios2.git
S:	Maintained
F:	arch/nios2/

NOHZ, DYNTICKS SUPPORT
M:	Frederic Weisbecker <fweisbec@gmail.com>
M:	Thomas Gleixner <tglx@linutronix.de>
M:	Ingo Molnar <mingo@kernel.org>
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/nohz
S:	Maintained
F:	kernel/time/tick*.*
F:	include/linux/tick.h
F:	include/linux/sched/nohz.h

NOKIA N900 CAMERA SUPPORT (ET8EK8 SENSOR, AD5820 FOCUS)
M:	Pavel Machek <pavel@ucw.cz>
M:	Sakari Ailus <sakari.ailus@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/et8ek8
F:	drivers/media/i2c/ad5820.c

NOKIA N900 POWER SUPPLY DRIVERS
R:	Pali Rohár <pali.rohar@gmail.com>
F:	include/linux/power/bq2415x_charger.h
F:	include/linux/power/bq27xxx_battery.h
F:	include/linux/power/isp1704_charger.h
F:	drivers/power/supply/bq2415x_charger.c
F:	drivers/power/supply/bq27xxx_battery.c
F:	drivers/power/supply/bq27xxx_battery_i2c.c
F:	drivers/power/supply/isp1704_charger.c
F:	drivers/power/supply/rx51_battery.c

NTB AMD DRIVER
M:	Shyam Sundar S K <Shyam-sundar.S-k@amd.com>
L:	linux-ntb@googlegroups.com
S:	Supported
F:	drivers/ntb/hw/amd/

NTB DRIVER CORE
M:	Jon Mason <jdmason@kudzu.us>
M:	Dave Jiang <dave.jiang@intel.com>
M:	Allen Hubbe <allenbh@gmail.com>
L:	linux-ntb@googlegroups.com
S:	Supported
W:	https://github.com/jonmason/ntb/wiki
T:	git git://github.com/jonmason/ntb.git
F:	drivers/ntb/
F:	drivers/net/ntb_netdev.c
F:	include/linux/ntb.h
F:	include/linux/ntb_transport.h
F:	tools/testing/selftests/ntb/

NTB IDT DRIVER
M:	Serge Semin <fancer.lancer@gmail.com>
L:	linux-ntb@googlegroups.com
S:	Supported
F:	drivers/ntb/hw/idt/

NTB INTEL DRIVER
M:	Dave Jiang <dave.jiang@intel.com>
L:	linux-ntb@googlegroups.com
S:	Supported
W:	https://github.com/davejiang/linux/wiki
T:	git https://github.com/davejiang/linux.git
F:	drivers/ntb/hw/intel/

NTFS FILESYSTEM
M:	Anton Altaparmakov <anton@tuxera.com>
L:	linux-ntfs-dev@lists.sourceforge.net
W:	http://www.tuxera.com/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/aia21/ntfs.git
S:	Supported
F:	Documentation/filesystems/ntfs.txt
F:	fs/ntfs/

NUBUS SUBSYSTEM
M:	Finn Thain <fthain@telegraphics.com.au>
L:	linux-m68k@lists.linux-m68k.org
S:	Maintained
F:	arch/*/include/asm/nubus.h
F:	drivers/nubus/
F:	include/linux/nubus.h
F:	include/uapi/linux/nubus.h

NVIDIA (rivafb and nvidiafb) FRAMEBUFFER DRIVER
M:	Antonino Daplas <adaplas@gmail.com>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	drivers/video/fbdev/riva/
F:	drivers/video/fbdev/nvidia/

NVM EXPRESS DRIVER
M:	Keith Busch <keith.busch@intel.com>
M:	Jens Axboe <axboe@fb.com>
M:	Christoph Hellwig <hch@lst.de>
M:	Sagi Grimberg <sagi@grimberg.me>
L:	linux-nvme@lists.infradead.org
T:	git://git.infradead.org/nvme.git
W:	http://git.infradead.org/nvme.git
S:	Supported
F:	drivers/nvme/host/
F:	include/linux/nvme.h
F:	include/uapi/linux/nvme_ioctl.h

NVM EXPRESS FC TRANSPORT DRIVERS
M:	James Smart <james.smart@broadcom.com>
L:	linux-nvme@lists.infradead.org
S:	Supported
F:	include/linux/nvme-fc.h
F:	include/linux/nvme-fc-driver.h
F:	drivers/nvme/host/fc.c
F:	drivers/nvme/target/fc.c
F:	drivers/nvme/target/fcloop.c

NVM EXPRESS TARGET DRIVER
M:	Christoph Hellwig <hch@lst.de>
M:	Sagi Grimberg <sagi@grimberg.me>
L:	linux-nvme@lists.infradead.org
T:	git://git.infradead.org/nvme.git
W:	http://git.infradead.org/nvme.git
S:	Supported
F:	drivers/nvme/target/

NVMEM FRAMEWORK
M:	Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
S:	Maintained
F:	drivers/nvmem/
F:	Documentation/devicetree/bindings/nvmem/
F:	Documentation/ABI/stable/sysfs-bus-nvmem
F:	include/linux/nvmem-consumer.h
F:	include/linux/nvmem-provider.h

NXP SGTL5000 DRIVER
M:	Fabio Estevam <fabio.estevam@nxp.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/sound/sgtl5000.txt
F:	sound/soc/codecs/sgtl5000*

NXP TDA998X DRM DRIVER
M:	Russell King <linux@armlinux.org.uk>
S:	Supported
T:	git git://git.armlinux.org.uk/~rmk/linux-arm.git drm-tda998x-devel
T:	git git://git.armlinux.org.uk/~rmk/linux-arm.git drm-tda998x-fixes
F:	drivers/gpu/drm/i2c/tda998x_drv.c
F:	include/drm/i2c/tda998x.h

NXP TFA9879 DRIVER
M:	Peter Rosin <peda@axentia.se>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/sound/tfa9879.txt
F:	sound/soc/codecs/tfa9879*

NXP-NCI NFC DRIVER
M:	Clément Perrochaud <clement.perrochaud@effinnov.com>
R:	Charles Gorand <charles.gorand@effinnov.com>
L:	linux-nfc@lists.01.org (moderated for non-subscribers)
S:	Supported
F:	drivers/nfc/nxp-nci

OBJTOOL
M:	Josh Poimboeuf <jpoimboe@redhat.com>
M:	Peter Zijlstra <peterz@infradead.org>
S:	Supported
F:	tools/objtool/

OCXL (Open Coherent Accelerator Processor Interface OpenCAPI) DRIVER
M:	Frederic Barrat <fbarrat@linux.vnet.ibm.com>
M:	Andrew Donnellan <andrew.donnellan@au1.ibm.com>
L:	linuxppc-dev@lists.ozlabs.org
S:	Supported
F:	arch/powerpc/platforms/powernv/ocxl.c
F:	arch/powerpc/include/asm/pnv-ocxl.h
F:	drivers/misc/ocxl/
F:	include/misc/ocxl*
F:	include/uapi/misc/ocxl.h
F:	Documentation/accelerators/ocxl.txt

OMAP AUDIO SUPPORT
M:	Peter Ujfalusi <peter.ujfalusi@ti.com>
M:	Jarkko Nikula <jarkko.nikula@bitmer.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	sound/soc/omap/

OMAP CLOCK FRAMEWORK SUPPORT
M:	Paul Walmsley <paul@pwsan.com>
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	arch/arm/*omap*/*clock*

OMAP DEVICE TREE SUPPORT
M:	Benoît Cousson <bcousson@baylibre.com>
M:	Tony Lindgren <tony@atomide.com>
L:	linux-omap@vger.kernel.org
L:	devicetree@vger.kernel.org
S:	Maintained
F:	arch/arm/boot/dts/*omap*
F:	arch/arm/boot/dts/*am3*
F:	arch/arm/boot/dts/*am4*
F:	arch/arm/boot/dts/*am5*
F:	arch/arm/boot/dts/*dra7*

OMAP DISPLAY SUBSYSTEM and FRAMEBUFFER SUPPORT (DSS2)
L:	linux-omap@vger.kernel.org
L:	linux-fbdev@vger.kernel.org
S:	Orphan
F:	drivers/video/fbdev/omap2/
F:	Documentation/arm/OMAP/DSS

OMAP FRAMEBUFFER SUPPORT
L:	linux-fbdev@vger.kernel.org
L:	linux-omap@vger.kernel.org
S:	Orphan
F:	drivers/video/fbdev/omap/

OMAP GENERAL PURPOSE MEMORY CONTROLLER SUPPORT
M:	Roger Quadros <rogerq@ti.com>
M:	Tony Lindgren <tony@atomide.com>
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	drivers/memory/omap-gpmc.c
F:	arch/arm/mach-omap2/*gpmc*

OMAP GPIO DRIVER
M:	Grygorii Strashko <grygorii.strashko@ti.com>
M:	Santosh Shilimkar <ssantosh@kernel.org>
M:	Kevin Hilman <khilman@kernel.org>
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/gpio/gpio-omap.txt
F:	drivers/gpio/gpio-omap.c

OMAP HARDWARE SPINLOCK SUPPORT
M:	Ohad Ben-Cohen <ohad@wizery.com>
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	drivers/hwspinlock/omap_hwspinlock.c

OMAP HS MMC SUPPORT
L:	linux-mmc@vger.kernel.org
L:	linux-omap@vger.kernel.org
S:	Orphan
F:	drivers/mmc/host/omap_hsmmc.c

OMAP HWMOD DATA
M:	Paul Walmsley <paul@pwsan.com>
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	arch/arm/mach-omap2/omap_hwmod*data*

OMAP HWMOD DATA FOR OMAP4-BASED DEVICES
M:	Benoît Cousson <bcousson@baylibre.com>
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	arch/arm/mach-omap2/omap_hwmod_44xx_data.c

OMAP HWMOD SUPPORT
M:	Benoît Cousson <bcousson@baylibre.com>
M:	Paul Walmsley <paul@pwsan.com>
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	arch/arm/mach-omap2/omap_hwmod.*

OMAP IMAGING SUBSYSTEM (OMAP3 ISP and OMAP4 ISS)
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/ti,omap3isp.txt
F:	drivers/media/platform/omap3isp/
F:	drivers/staging/media/omap4iss/

OMAP MMC SUPPORT
M:	Jarkko Lavinen <jarkko.lavinen@nokia.com>
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	drivers/mmc/host/omap.c

OMAP POWER MANAGEMENT SUPPORT
M:	Kevin Hilman <khilman@kernel.org>
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	arch/arm/*omap*/*pm*
F:	drivers/cpufreq/omap-cpufreq.c

OMAP POWERDOMAIN SOC ADAPTATION LAYER SUPPORT
M:	Rajendra Nayak <rnayak@codeaurora.org>
M:	Paul Walmsley <paul@pwsan.com>
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	arch/arm/mach-omap2/prm*

OMAP RANDOM NUMBER GENERATOR SUPPORT
M:	Deepak Saxena <dsaxena@plexity.net>
S:	Maintained
F:	drivers/char/hw_random/omap-rng.c

OMAP USB SUPPORT
L:	linux-usb@vger.kernel.org
L:	linux-omap@vger.kernel.org
S:	Orphan
F:	drivers/usb/*/*omap*
F:	arch/arm/*omap*/usb*

OMAP/NEWFLOW NANOBONE MACHINE SUPPORT
M:	Mark Jackson <mpfj@newflow.co.uk>
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	arch/arm/boot/dts/am335x-nano.dts

OMAP1 SUPPORT
M:	Aaro Koskinen <aaro.koskinen@iki.fi>
M:	Tony Lindgren <tony@atomide.com>
L:	linux-omap@vger.kernel.org
Q:	http://patchwork.kernel.org/project/linux-omap/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tmlind/linux-omap.git
S:	Maintained
F:	arch/arm/mach-omap1/
F:	arch/arm/plat-omap/
F:	arch/arm/configs/omap1_defconfig
F:	drivers/i2c/busses/i2c-omap.c
F:	include/linux/platform_data/i2c-omap.h

OMAP2+ SUPPORT
M:	Tony Lindgren <tony@atomide.com>
L:	linux-omap@vger.kernel.org
W:	http://www.muru.com/linux/omap/
W:	http://linux.omap.com/
Q:	http://patchwork.kernel.org/project/linux-omap/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tmlind/linux-omap.git
S:	Maintained
F:	arch/arm/mach-omap2/
F:	arch/arm/plat-omap/
F:	arch/arm/configs/omap2plus_defconfig
F:	drivers/i2c/busses/i2c-omap.c
F:	drivers/irqchip/irq-omap-intc.c
F:	drivers/mfd/*omap*.c
F:	drivers/mfd/menelaus.c
F:	drivers/mfd/palmas.c
F:	drivers/mfd/tps65217.c
F:	drivers/mfd/tps65218.c
F:	drivers/mfd/tps65910.c
F:	drivers/mfd/twl-core.[ch]
F:	drivers/mfd/twl4030*.c
F:	drivers/mfd/twl6030*.c
F:	drivers/mfd/twl6040*.c
F:	drivers/regulator/palmas-regulator*.c
F:	drivers/regulator/pbias-regulator.c
F:	drivers/regulator/tps65217-regulator.c
F:	drivers/regulator/tps65218-regulator.c
F:	drivers/regulator/tps65910-regulator.c
F:	drivers/regulator/twl-regulator.c
F:	drivers/regulator/twl6030-regulator.c
F:	include/linux/platform_data/i2c-omap.h

ONION OMEGA2+ BOARD
M:	Harvey Hunt <harveyhuntnexus@gmail.com>
L:	linux-mips@linux-mips.org
S:	Maintained
F:	arch/mips/boot/dts/ralink/omega2p.dts

OMFS FILESYSTEM
M:	Bob Copeland <me@bobcopeland.com>
L:	linux-karma-devel@lists.sourceforge.net
S:	Maintained
F:	Documentation/filesystems/omfs.txt
F:	fs/omfs/

OMNIKEY CARDMAN 4000 DRIVER
M:	Harald Welte <laforge@gnumonks.org>
S:	Maintained
F:	drivers/char/pcmcia/cm4000_cs.c
F:	include/linux/cm4000_cs.h
F:	include/uapi/linux/cm4000_cs.h

OMNIKEY CARDMAN 4040 DRIVER
M:	Harald Welte <laforge@gnumonks.org>
S:	Maintained
F:	drivers/char/pcmcia/cm4040_cs.*

OMNIVISION OV13858 SENSOR DRIVER
M:	Sakari Ailus <sakari.ailus@linux.intel.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/ov13858.c

OMNIVISION OV2685 SENSOR DRIVER
M:	Shunqian Zheng <zhengsq@rock-chips.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/ov2685.c

OMNIVISION OV5640 SENSOR DRIVER
M:	Steve Longerbeam <slongerbeam@gmail.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/ov5640.c

OMNIVISION OV5647 SENSOR DRIVER
M:	Luis Oliveira <lolivei@synopsys.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/ov5647.c

OMNIVISION OV5695 SENSOR DRIVER
M:	Shunqian Zheng <zhengsq@rock-chips.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/ov5695.c

OMNIVISION OV7670 SENSOR DRIVER
M:	Jonathan Corbet <corbet@lwn.net>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/ov7670.c
F:	Documentation/devicetree/bindings/media/i2c/ov7670.txt

OMNIVISION OV772x SENSOR DRIVER
M:	Jacopo Mondi <jacopo@jmondi.org>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Odd fixes
F:	drivers/media/i2c/ov772x.c
F:	include/media/i2c/ov772x.h
F:	Documentation/devicetree/bindings/media/i2c/ov772x.txt

OMNIVISION OV7740 SENSOR DRIVER
M:	Wenyou Yang <wenyou.yang@microchip.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/ov7740.c
F:	Documentation/devicetree/bindings/media/i2c/ov7740.txt

OMNIVISION OV9650 SENSOR DRIVER
M:	Sakari Ailus <sakari.ailus@linux.intel.com>
R:	Akinobu Mita <akinobu.mita@gmail.com>
R:	Sylwester Nawrocki <s.nawrocki@samsung.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/ov9650.c
F:	Documentation/devicetree/bindings/media/i2c/ov9650.txt

ONENAND FLASH DRIVER
M:	Kyungmin Park <kyungmin.park@samsung.com>
L:	linux-mtd@lists.infradead.org
S:	Maintained
F:	drivers/mtd/nand/onenand/
F:	include/linux/mtd/onenand*.h

ONSTREAM SCSI TAPE DRIVER
M:	Willem Riede <osst@riede.org>
L:	osst-users@lists.sourceforge.net
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	Documentation/scsi/osst.txt
F:	drivers/scsi/osst.*
F:	drivers/scsi/osst_*.h
F:	drivers/scsi/st.h

OP-TEE DRIVER
M:	Jens Wiklander <jens.wiklander@linaro.org>
S:	Maintained
F:	drivers/tee/optee/

OPA-VNIC DRIVER
M:	Dennis Dalessandro <dennis.dalessandro@intel.com>
M:	Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
F:	drivers/infiniband/ulp/opa_vnic

OPEN FIRMWARE AND DEVICE TREE OVERLAYS
M:	Pantelis Antoniou <pantelis.antoniou@konsulko.com>
M:	Frank Rowand <frowand.list@gmail.com>
L:	devicetree@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/dynamic-resolution-notes.txt
F:	Documentation/devicetree/overlay-notes.txt
F:	drivers/of/overlay.c
F:	drivers/of/resolver.c
K:	of_overlay_notifier_

OPEN FIRMWARE AND FLATTENED DEVICE TREE
M:	Rob Herring <robh+dt@kernel.org>
M:	Frank Rowand <frowand.list@gmail.com>
L:	devicetree@vger.kernel.org
W:	http://www.devicetree.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git
S:	Maintained
F:	drivers/of/
F:	include/linux/of*.h
F:	scripts/dtc/
F:	Documentation/ABI/testing/sysfs-firmware-ofw

OPEN FIRMWARE AND FLATTENED DEVICE TREE BINDINGS
M:	Rob Herring <robh+dt@kernel.org>
M:	Mark Rutland <mark.rutland@arm.com>
L:	devicetree@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git
Q:	http://patchwork.ozlabs.org/project/devicetree-bindings/list/
S:	Maintained
F:	Documentation/devicetree/
F:	arch/*/boot/dts/
F:	include/dt-bindings/

OPENCORES I2C BUS DRIVER
M:	Peter Korsgaard <jacmet@sunsite.dk>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/i2c/busses/i2c-ocores
F:	drivers/i2c/busses/i2c-ocores.c

OPENRISC ARCHITECTURE
M:	Jonas Bonn <jonas@southpole.se>
M:	Stefan Kristiansson <stefan.kristiansson@saunalahti.fi>
M:	Stafford Horne <shorne@gmail.com>
T:	git git://github.com/openrisc/linux.git
L:	openrisc@lists.librecores.org
W:	http://openrisc.io
S:	Maintained
F:	Documentation/devicetree/bindings/openrisc/
F:	Documentation/openrisc/
F:	arch/openrisc/
F:	drivers/irqchip/irq-ompic.c
F:	drivers/irqchip/irq-or1k-*

OPENVSWITCH
M:	Pravin B Shelar <pshelar@ovn.org>
L:	netdev@vger.kernel.org
L:	dev@openvswitch.org
W:	http://openvswitch.org
S:	Maintained
F:	net/openvswitch/
F:	include/uapi/linux/openvswitch.h

OPERATING PERFORMANCE POINTS (OPP)
M:	Viresh Kumar <vireshk@kernel.org>
M:	Nishanth Menon <nm@ti.com>
M:	Stephen Boyd <sboyd@kernel.org>
L:	linux-pm@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/vireshk/pm.git
F:	drivers/opp/
F:	include/linux/pm_opp.h
F:	Documentation/power/opp.txt
F:	Documentation/devicetree/bindings/opp/

OPL4 DRIVER
M:	Clemens Ladisch <clemens@ladisch.de>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
T:	git git://git.alsa-project.org/alsa-kernel.git
S:	Maintained
F:	sound/drivers/opl4/

OPROFILE
M:	Robert Richter <rric@kernel.org>
L:	oprofile-list@lists.sf.net
S:	Maintained
F:	arch/*/include/asm/oprofile*.h
F:	arch/*/oprofile/
F:	drivers/oprofile/
F:	include/linux/oprofile.h

ORACLE CLUSTER FILESYSTEM 2 (OCFS2)
M:	Mark Fasheh <mark@fasheh.com>
M:	Joel Becker <jlbec@evilplan.org>
L:	ocfs2-devel@oss.oracle.com (moderated for non-subscribers)
W:	http://ocfs2.wiki.kernel.org
S:	Supported
F:	Documentation/filesystems/ocfs2.txt
F:	Documentation/filesystems/dlmfs.txt
F:	fs/ocfs2/

ORANGEFS FILESYSTEM
M:	Mike Marshall <hubcap@omnibond.com>
R:	Martin Brandenburg <martin@omnibond.com>
L:	devel@lists.orangefs.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/hubcap/linux.git
S:	Supported
F:	fs/orangefs/
F:	Documentation/filesystems/orangefs.txt

ORINOCO DRIVER
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/en/users/Drivers/orinoco
W:	http://www.nongnu.org/orinoco/
S:	Orphan
F:	drivers/net/wireless/intersil/orinoco/

OSD LIBRARY and FILESYSTEM
M:	Boaz Harrosh <ooo@electrozaur.com>
S:	Maintained
F:	drivers/scsi/osd/
F:	include/scsi/osd_*
F:	fs/exofs/

OV2659 OMNIVISION SENSOR DRIVER
M:	"Lad, Prabhakar" <prabhakar.csengg@gmail.com>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/mhadli/v4l-dvb-davinci_devices.git
S:	Maintained
F:	drivers/media/i2c/ov2659.c
F:	include/media/i2c/ov2659.h

OVERLAY FILESYSTEM
M:	Miklos Szeredi <miklos@szeredi.hu>
L:	linux-unionfs@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/vfs.git
S:	Supported
F:	fs/overlayfs/
F:	Documentation/filesystems/overlayfs.txt

P54 WIRELESS DRIVER
M:	Christian Lamparter <chunkeey@googlemail.com>
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/en/users/Drivers/p54
S:	Maintained
F:	drivers/net/wireless/intersil/p54/

PA SEMI ETHERNET DRIVER
L:	netdev@vger.kernel.org
S:	Orphan
F:	drivers/net/ethernet/pasemi/*

PA SEMI SMBUS DRIVER
L:	linux-i2c@vger.kernel.org
S:	Orphan
F:	drivers/i2c/busses/i2c-pasemi.c

PADATA PARALLEL EXECUTION MECHANISM
M:	Steffen Klassert <steffen.klassert@secunet.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	kernel/padata.c
F:	include/linux/padata.h
F:	Documentation/padata.txt

PANASONIC LAPTOP ACPI EXTRAS DRIVER
M:	Harald Welte <laforge@gnumonks.org>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/panasonic-laptop.c

PARALLEL LCD/KEYPAD PANEL DRIVER
M:	Willy Tarreau <willy@haproxy.com>
M:	Ksenija Stanojevic <ksenija.stanojevic@gmail.com>
S:	Odd Fixes
F:	Documentation/misc-devices/lcd-panel-cgram.txt
F:	drivers/misc/panel.c

PARALLEL PORT SUBSYSTEM
M:	Sudip Mukherjee <sudipm.mukherjee@gmail.com>
M:	Sudip Mukherjee <sudip.mukherjee@codethink.co.uk>
L:	linux-parport@lists.infradead.org (subscribers-only)
S:	Maintained
F:	drivers/parport/
F:	include/linux/parport*.h
F:	drivers/char/ppdev.c
F:	include/uapi/linux/ppdev.h
F:	Documentation/parport*.txt

PARAVIRT_OPS INTERFACE
M:	Juergen Gross <jgross@suse.com>
M:	Alok Kataria <akataria@vmware.com>
L:	virtualization@lists.linux-foundation.org
S:	Supported
F:	Documentation/virtual/paravirt_ops.txt
F:	arch/*/kernel/paravirt*
F:	arch/*/include/asm/paravirt*.h
F:	include/linux/hypervisor.h

PARIDE DRIVERS FOR PARALLEL PORT IDE DEVICES
M:	Tim Waugh <tim@cyberelk.net>
L:	linux-parport@lists.infradead.org (subscribers-only)
S:	Maintained
F:	Documentation/blockdev/paride.txt
F:	drivers/block/paride/

PARISC ARCHITECTURE
M:	"James E.J. Bottomley" <jejb@parisc-linux.org>
M:	Helge Deller <deller@gmx.de>
L:	linux-parisc@vger.kernel.org
W:	http://www.parisc-linux.org/
Q:	http://patchwork.kernel.org/project/linux-parisc/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jejb/parisc-2.6.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/deller/parisc-linux.git
S:	Maintained
F:	arch/parisc/
F:	Documentation/parisc/
F:	drivers/parisc/
F:	drivers/char/agp/parisc-agp.c
F:	drivers/input/serio/gscps2.c
F:	drivers/parport/parport_gsc.*
F:	drivers/tty/serial/8250/8250_gsc.c
F:	drivers/video/fbdev/sti*
F:	drivers/video/console/sti*
F:	drivers/video/logo/logo_parisc*

PARMAN
M:	Jiri Pirko <jiri@mellanox.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	lib/parman.c
F:	lib/test_parman.c
F:	include/linux/parman.h

PC87360 HARDWARE MONITORING DRIVER
M:	Jim Cromie <jim.cromie@gmail.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/pc87360
F:	drivers/hwmon/pc87360.c

PC8736x GPIO DRIVER
M:	Jim Cromie <jim.cromie@gmail.com>
S:	Maintained
F:	drivers/char/pc8736x_gpio.c

PC87427 HARDWARE MONITORING DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/pc87427
F:	drivers/hwmon/pc87427.c

PCA9532 LED DRIVER
M:	Riku Voipio <riku.voipio@iki.fi>
S:	Maintained
F:	drivers/leds/leds-pca9532.c
F:	include/linux/leds-pca9532.h

PCA9541 I2C BUS MASTER SELECTOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	drivers/i2c/muxes/i2c-mux-pca9541.c

PCDP - PRIMARY CONSOLE AND DEBUG PORT
M:	Khalid Aziz <khalid@gonehiking.org>
S:	Maintained
F:	drivers/firmware/pcdp.*

PCI DRIVER FOR AARDVARK (Marvell Armada 3700)
M:	Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/pci/aardvark-pci.txt
F:	drivers/pci/controller/pci-aardvark.c

PCI DRIVER FOR ALTERA PCIE IP
M:	Ley Foon Tan <lftan@altera.com>
L:	rfi@lists.rocketboards.org (moderated for non-subscribers)
L:	linux-pci@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/pci/altera-pcie.txt
F:	drivers/pci/controller/pcie-altera.c

PCI DRIVER FOR APPLIEDMICRO XGENE
M:	Tanmay Inamdar <tinamdar@apm.com>
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/xgene-pci.txt
F:	drivers/pci/controller/pci-xgene.c

PCI DRIVER FOR ARM VERSATILE PLATFORM
M:	Rob Herring <robh@kernel.org>
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/versatile.txt
F:	drivers/pci/controller/pci-versatile.c

PCI DRIVER FOR ARMADA 8K
M:	Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/pci-armada8k.txt
F:	drivers/pci/controller/dwc/pcie-armada8k.c

PCI DRIVER FOR CADENCE PCIE IP
M:	Alan Douglas <adouglas@cadence.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/cdns,*.txt
F:	drivers/pci/controller/pcie-cadence*

PCI DRIVER FOR FREESCALE LAYERSCAPE
M:	Minghuan Lian <minghuan.Lian@nxp.com>
M:	Mingkai Hu <mingkai.hu@nxp.com>
M:	Roy Zang <roy.zang@nxp.com>
L:	linuxppc-dev@lists.ozlabs.org
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org
S:	Maintained
F:	drivers/pci/controller/dwc/*layerscape*

PCI DRIVER FOR GENERIC OF HOSTS
M:	Will Deacon <will.deacon@arm.com>
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/pci/controller-generic-pci.txt
F:	drivers/pci/controller/pci-host-common.c
F:	drivers/pci/controller/pci-host-generic.c

PCI DRIVER FOR IMX6
M:	Richard Zhu <hongxing.zhu@nxp.com>
M:	Lucas Stach <l.stach@pengutronix.de>
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/pci/fsl,imx6q-pcie.txt
F:	drivers/pci/controller/dwc/*imx6*

PCI DRIVER FOR INTEL VOLUME MANAGEMENT DEVICE (VMD)
M:	Keith Busch <keith.busch@intel.com>
M:	Jonathan Derrick <jonathan.derrick@intel.com>
L:	linux-pci@vger.kernel.org
S:	Supported
F:	drivers/pci/controller/vmd.c

PCI DRIVER FOR MICROSEMI SWITCHTEC
M:	Kurt Schwemmer <kurt.schwemmer@microsemi.com>
M:	Logan Gunthorpe <logang@deltatee.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/switchtec.txt
F:	Documentation/ABI/testing/sysfs-class-switchtec
F:	drivers/pci/switch/switchtec*
F:	include/uapi/linux/switchtec_ioctl.h
F:	include/linux/switchtec.h
F:	drivers/ntb/hw/mscc/

PCI DRIVER FOR MVEBU (Marvell Armada 370 and Armada XP SOC support)
M:	Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
M:	Jason Cooper <jason@lakedaemon.net>
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/pci/controller/*mvebu*

PCI DRIVER FOR NVIDIA TEGRA
M:	Thierry Reding <thierry.reding@gmail.com>
L:	linux-tegra@vger.kernel.org
L:	linux-pci@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/pci/nvidia,tegra20-pcie.txt
F:	drivers/pci/controller/pci-tegra.c

PCI DRIVER FOR RENESAS R-CAR
M:	Simon Horman <horms@verge.net.au>
L:	linux-pci@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
S:	Maintained
F:	drivers/pci/controller/*rcar*

PCI DRIVER FOR SAMSUNG EXYNOS
M:	Jingoo Han <jingoohan1@gmail.com>
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-samsung-soc@vger.kernel.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/pci/controller/dwc/pci-exynos.c

PCI DRIVER FOR SYNOPSYS DESIGNWARE
M:	Jingoo Han <jingoohan1@gmail.com>
M:	Joao Pinto <Joao.Pinto@synopsys.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/designware-pcie.txt
F:	drivers/pci/controller/dwc/*designware*

PCI DRIVER FOR TI DRA7XX
M:	Kishon Vijay Abraham I <kishon@ti.com>
L:	linux-omap@vger.kernel.org
L:	linux-pci@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/pci/ti-pci.txt
F:	drivers/pci/controller/dwc/pci-dra7xx.c

PCI DRIVER FOR TI KEYSTONE
M:	Murali Karicheri <m-karicheri2@ti.com>
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/pci/controller/dwc/*keystone*

PCI ENDPOINT SUBSYSTEM
M:	Kishon Vijay Abraham I <kishon@ti.com>
M:	Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
L:	linux-pci@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kishon/pci-endpoint.git
S:	Supported
F:	drivers/pci/endpoint/
F:	drivers/misc/pci_endpoint_test.c
F:	tools/pci/

PCI ENHANCED ERROR HANDLING (EEH) FOR POWERPC
M:	Russell Currey <ruscur@russell.cc>
L:	linuxppc-dev@lists.ozlabs.org
S:	Supported
F:	Documentation/powerpc/eeh-pci-error-recovery.txt
F:	arch/powerpc/kernel/eeh*.c
F:	arch/powerpc/platforms/*/eeh*.c
F:	arch/powerpc/include/*/eeh*.h

PCI ERROR RECOVERY
M:	Linas Vepstas <linasvepstas@gmail.com>
L:	linux-pci@vger.kernel.org
S:	Supported
F:	Documentation/PCI/pci-error-recovery.txt

PCI MSI DRIVER FOR ALTERA MSI IP
M:	Ley Foon Tan <lftan@altera.com>
L:	rfi@lists.rocketboards.org (moderated for non-subscribers)
L:	linux-pci@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/pci/altera-pcie-msi.txt
F:	drivers/pci/controller/pcie-altera-msi.c

PCI MSI DRIVER FOR APPLIEDMICRO XGENE
M:	Duc Dang <dhdang@apm.com>
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/xgene-pci-msi.txt
F:	drivers/pci/controller/pci-xgene-msi.c

PCI SUBSYSTEM
M:	Bjorn Helgaas <bhelgaas@google.com>
L:	linux-pci@vger.kernel.org
Q:	http://patchwork.ozlabs.org/project/linux-pci/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci.git
S:	Supported
F:	Documentation/devicetree/bindings/pci/
F:	Documentation/PCI/
F:	drivers/acpi/pci*
F:	drivers/pci/
F:	include/asm-generic/pci*
F:	include/linux/pci*
F:	include/linux/of_pci.h
F:	include/uapi/linux/pci*
F:	lib/pci*
F:	arch/x86/pci/
F:	arch/x86/kernel/quirks.c

PCI NATIVE HOST BRIDGE AND ENDPOINT DRIVERS
M:	Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
L:	linux-pci@vger.kernel.org
Q:	http://patchwork.ozlabs.org/project/linux-pci/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lpieralisi/pci.git/
S:	Supported
F:	drivers/pci/controller/

PCIE DRIVER FOR AXIS ARTPEC
M:	Jesper Nilsson <jesper.nilsson@axis.com>
L:	linux-arm-kernel@axis.com
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/axis,artpec*
F:	drivers/pci/controller/dwc/*artpec*

PCIE DRIVER FOR CAVIUM THUNDERX
M:	David Daney <david.daney@cavium.com>
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	Documentation/devicetree/bindings/pci/pci-thunder-*
F:	drivers/pci/controller/pci-thunder-*

PCIE DRIVER FOR HISILICON
M:	Zhou Wang <wangzhou1@hisilicon.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/hisilicon-pcie.txt
F:	drivers/pci/controller/dwc/pcie-hisi.c

PCIE DRIVER FOR HISILICON KIRIN
M:	Xiaowei Song <songxiaowei@hisilicon.com>
M:	Binghui Wang <wangbinghui@hisilicon.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/pcie-kirin.txt
F:	drivers/pci/controller/dwc/pcie-kirin.c

PCIE DRIVER FOR HISILICON STB
M:	Jianguo Sun <sunjianguo1@huawei.com>
M:	Shawn Guo <shawn.guo@linaro.org>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/hisilicon-histb-pcie.txt
F:	drivers/pci/controller/dwc/pcie-histb.c

PCIE DRIVER FOR MEDIATEK
M:	Ryder Lee <ryder.lee@mediatek.com>
L:	linux-pci@vger.kernel.org
L:	linux-mediatek@lists.infradead.org
S:	Supported
F:	Documentation/devicetree/bindings/pci/mediatek*
F:	drivers/pci/controller/*mediatek*

PCIE DRIVER FOR QUALCOMM MSM
M:	Stanimir Varbanov <svarbanov@mm-sol.com>
L:	linux-pci@vger.kernel.org
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	drivers/pci/controller/dwc/*qcom*

PCIE DRIVER FOR ROCKCHIP
M:	Shawn Lin <shawn.lin@rock-chips.com>
L:	linux-pci@vger.kernel.org
L:	linux-rockchip@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/rockchip-pcie*
F:	drivers/pci/controller/pcie-rockchip*

PCI DRIVER FOR V3 SEMICONDUCTOR V360EPC
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/v3-v360epc-pci.txt
F:	drivers/pci/controller/pci-v3-semi.c

PCIE DRIVER FOR ST SPEAR13XX
M:	Pratyush Anand <pratyush.anand@gmail.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	drivers/pci/controller/dwc/*spear*

PCMCIA SUBSYSTEM
M:	Dominik Brodowski <linux@dominikbrodowski.net>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/brodo/pcmcia.git
S:	Odd Fixes
F:	Documentation/pcmcia/
F:	tools/pcmcia/
F:	drivers/pcmcia/
F:	include/pcmcia/

PCNET32 NETWORK DRIVER
M:	Don Fry <pcnet32@frontier.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/amd/pcnet32.c

PCRYPT PARALLEL CRYPTO ENGINE
M:	Steffen Klassert <steffen.klassert@secunet.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	crypto/pcrypt.c
F:	include/crypto/pcrypt.h

PEAQ WMI HOTKEYS DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/peaq-wmi.c

PER-CPU MEMORY ALLOCATOR
M:	Tejun Heo <tj@kernel.org>
M:	Christoph Lameter <cl@linux.com>
M:	Dennis Zhou <dennisszhou@gmail.com>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tj/percpu.git
S:	Maintained
F:	include/linux/percpu*.h
F:	mm/percpu*.c
F:	arch/*/include/asm/percpu.h

PER-TASK DELAY ACCOUNTING
M:	Balbir Singh <bsingharora@gmail.com>
S:	Maintained
F:	include/linux/delayacct.h
F:	kernel/delayacct.c

PERFORMANCE EVENTS SUBSYSTEM
M:	Peter Zijlstra <peterz@infradead.org>
M:	Ingo Molnar <mingo@redhat.com>
M:	Arnaldo Carvalho de Melo <acme@kernel.org>
R:	Alexander Shishkin <alexander.shishkin@linux.intel.com>
R:	Jiri Olsa <jolsa@redhat.com>
R:	Namhyung Kim <namhyung@kernel.org>
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git perf/core
S:	Supported
F:	kernel/events/*
F:	include/linux/perf_event.h
F:	include/uapi/linux/perf_event.h
F:	arch/*/kernel/perf_event*.c
F:	arch/*/kernel/*/perf_event*.c
F:	arch/*/kernel/*/*/perf_event*.c
F:	arch/*/include/asm/perf_event.h
F:	arch/*/kernel/perf_callchain.c
F:	arch/*/events/*
F:	tools/perf/

PERSONALITY HANDLING
M:	Christoph Hellwig <hch@infradead.org>
L:	linux-abi-devel@lists.sourceforge.net
S:	Maintained
F:	include/linux/personality.h
F:	include/uapi/linux/personality.h

PHONET PROTOCOL
M:	Remi Denis-Courmont <courmisch@gmail.com>
S:	Supported
F:	Documentation/networking/phonet.txt
F:	include/linux/phonet.h
F:	include/net/phonet/
F:	include/uapi/linux/phonet.h
F:	net/phonet/

PHRAM MTD DRIVER
M:	Joern Engel <joern@lazybastard.org>
L:	linux-mtd@lists.infradead.org
S:	Maintained
F:	drivers/mtd/devices/phram.c

PICOLCD HID DRIVER
M:	Bruno Prémont <bonbons@linux-vserver.org>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/hid/hid-picolcd*

PICOXCELL SUPPORT
M:	Jamie Iles <jamie@jamieiles.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://github.com/jamieiles/linux-2.6-ji.git
S:	Supported
F:	arch/arm/boot/dts/picoxcell*
F:	arch/arm/mach-picoxcell/
F:	drivers/crypto/picoxcell*

PIN CONTROL SUBSYSTEM
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-gpio@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-pinctrl.git
S:	Maintained
F:	Documentation/devicetree/bindings/pinctrl/
F:	Documentation/driver-api/pinctl.rst
F:	drivers/pinctrl/
F:	include/linux/pinctrl/

PIN CONTROLLER - ATMEL AT91
M:	Jean-Christophe Plagniol-Villard <plagnioj@jcrosoft.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/pinctrl/pinctrl-at91.*

PIN CONTROLLER - ATMEL AT91 PIO4
M:	Ludovic Desroches <ludovic.desroches@microchip.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-gpio@vger.kernel.org
S:	Supported
F:	drivers/pinctrl/pinctrl-at91-pio4.*

PIN CONTROLLER - FREESCALE
M:	Dong Aisheng <aisheng.dong@nxp.com>
M:	Fabio Estevam <festevam@gmail.com>
M:	Shawn Guo <shawnguo@kernel.org>
M:	Stefan Agner <stefan@agner.ch>
R:	Pengutronix Kernel Team <kernel@pengutronix.de>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/pinctrl/freescale/
F:	Documentation/devicetree/bindings/pinctrl/fsl,*

PIN CONTROLLER - INTEL
M:	Mika Westerberg <mika.westerberg@linux.intel.com>
M:	Heikki Krogerus <heikki.krogerus@linux.intel.com>
S:	Maintained
F:	drivers/pinctrl/intel/

PIN CONTROLLER - MEDIATEK
M:	Sean Wang <sean.wang@mediatek.com>
L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/pinctrl/pinctrl-mt65xx.txt
F:	Documentation/devicetree/bindings/pinctrl/pinctrl-mt7622.txt
F:	drivers/pinctrl/mediatek/mtk-eint.*
F:	drivers/pinctrl/mediatek/pinctrl-mtk-common.*
F:	drivers/pinctrl/mediatek/pinctrl-mt2701.c
F:	drivers/pinctrl/mediatek/pinctrl-mt7622.c

PIN CONTROLLER - QUALCOMM
M:	Bjorn Andersson <bjorn.andersson@linaro.org>
S:	Maintained
L:	linux-arm-msm@vger.kernel.org
F:	Documentation/devicetree/bindings/pinctrl/qcom,*.txt
F:	drivers/pinctrl/qcom/

PIN CONTROLLER - RENESAS
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
M:	Geert Uytterhoeven <geert+renesas@glider.be>
L:	linux-renesas-soc@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/geert/renesas-drivers.git sh-pfc
S:	Maintained
F:	drivers/pinctrl/sh-pfc/

PIN CONTROLLER - SAMSUNG
M:	Tomasz Figa <tomasz.figa@gmail.com>
M:	Krzysztof Kozlowski <krzk@kernel.org>
M:	Sylwester Nawrocki <s.nawrocki@samsung.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-samsung-soc@vger.kernel.org (moderated for non-subscribers)
Q:	https://patchwork.kernel.org/project/linux-samsung-soc/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pinctrl/samsung.git
S:	Maintained
F:	drivers/pinctrl/samsung/
F:	include/dt-bindings/pinctrl/samsung.h
F:	Documentation/devicetree/bindings/pinctrl/samsung-pinctrl.txt

PIN CONTROLLER - SINGLE
M:	Tony Lindgren <tony@atomide.com>
M:	Haojian Zhuang <haojian.zhuang@linaro.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	drivers/pinctrl/pinctrl-single.c

PIN CONTROLLER - ST SPEAR
M:	Viresh Kumar <vireshk@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.st.com/spear
S:	Maintained
F:	drivers/pinctrl/spear/

PISTACHIO SOC SUPPORT
M:	James Hartley <james.hartley@sondrel.com>
L:	linux-mips@linux-mips.org
S:	Odd Fixes
F:	arch/mips/pistachio/
F:	arch/mips/include/asm/mach-pistachio/
F:	arch/mips/boot/dts/img/pistachio*
F:	arch/mips/configs/pistachio*_defconfig

PKTCDVD DRIVER
S:	Orphan
M:	linux-block@vger.kernel.org
F:	drivers/block/pktcdvd.c
F:	include/linux/pktcdvd.h
F:	include/uapi/linux/pktcdvd.h

PKUNITY SOC DRIVERS
M:	Guan Xuetao <gxt@pku.edu.cn>
W:	http://mprc.pku.edu.cn/~guanxuetao/linux
S:	Maintained
T:	git git://github.com/gxt/linux.git
F:	drivers/input/serio/i8042-unicore32io.h
F:	drivers/i2c/busses/i2c-puv3.c
F:	drivers/video/fbdev/fb-puv3.c
F:	drivers/rtc/rtc-puv3.c

PMBUS HARDWARE MONITORING DRIVERS
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
W:	http://hwmon.wiki.kernel.org/
W:	http://www.roeck-us.net/linux/drivers/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging.git
S:	Maintained
F:	Documentation/hwmon/pmbus
F:	drivers/hwmon/pmbus/
F:	include/linux/pmbus.h

PMC SIERRA MaxRAID DRIVER
L:	linux-scsi@vger.kernel.org
W:	http://www.pmc-sierra.com/
S:	Orphan
F:	drivers/scsi/pmcraid.*

PMC SIERRA PM8001 DRIVER
M:	Jack Wang <jinpu.wang@profitbricks.com>
M:	lindar_liu@usish.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/pm8001/

PNP SUPPORT
M:	"Rafael J. Wysocki" <rafael.j.wysocki@intel.com>
S:	Maintained
F:	drivers/pnp/

POSIX CLOCKS and TIMERS
M:	Thomas Gleixner <tglx@linutronix.de>
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/core
S:	Maintained
F:	fs/timerfd.c
F:	include/linux/timer*
F:	kernel/time/*timer*

POWER MANAGEMENT CORE
M:	"Rafael J. Wysocki" <rjw@rjwysocki.net>
L:	linux-pm@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
B:	https://bugzilla.kernel.org
S:	Supported
F:	drivers/base/power/
F:	include/linux/pm.h
F:	include/linux/pm_*
F:	include/linux/powercap.h
F:	drivers/powercap/
F:	kernel/configs/nopm.config

POWER STATE COORDINATION INTERFACE (PSCI)
M:	Mark Rutland <mark.rutland@arm.com>
M:	Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
L:	linux-arm-kernel@lists.infradead.org
S:	Maintained
F:	drivers/firmware/psci*.c
F:	include/linux/psci.h
F:	include/uapi/linux/psci.h

POWER SUPPLY CLASS/SUBSYSTEM and DRIVERS
M:	Sebastian Reichel <sre@kernel.org>
L:	linux-pm@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sre/linux-power-supply.git
S:	Maintained
F:	Documentation/ABI/testing/sysfs-class-power
F:	Documentation/devicetree/bindings/power/supply/
F:	include/linux/power_supply.h
F:	drivers/power/supply/

POWERNV OPERATOR PANEL LCD DISPLAY DRIVER
M:	Suraj Jitindar Singh <sjitindarsingh@gmail.com>
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	drivers/char/powernv-op-panel.c

PPP OVER ATM (RFC 2364)
M:	Mitchell Blank Jr <mitch@sfgoth.com>
S:	Maintained
F:	net/atm/pppoatm.c
F:	include/uapi/linux/atmppp.h

PPP OVER ETHERNET
M:	Michal Ostrowski <mostrows@earthlink.net>
S:	Maintained
F:	drivers/net/ppp/pppoe.c
F:	drivers/net/ppp/pppox.c

PPP OVER L2TP
M:	James Chapman <jchapman@katalix.com>
S:	Maintained
F:	net/l2tp/l2tp_ppp.c
F:	include/linux/if_pppol2tp.h
F:	include/uapi/linux/if_pppol2tp.h

PPP PROTOCOL DRIVERS AND COMPRESSORS
M:	Paul Mackerras <paulus@samba.org>
L:	linux-ppp@vger.kernel.org
S:	Maintained
F:	drivers/net/ppp/ppp_*

PPS SUPPORT
M:	Rodolfo Giometti <giometti@enneenne.com>
W:	http://wiki.enneenne.com/index.php/LinuxPPS_support
L:	linuxpps@ml.enneenne.com (subscribers-only)
S:	Maintained
F:	Documentation/pps/
F:	Documentation/devicetree/bindings/pps/pps-gpio.txt
F:	Documentation/ABI/testing/sysfs-pps
F:	drivers/pps/
F:	include/linux/pps*.h
F:	include/uapi/linux/pps.h

PPTP DRIVER
M:	Dmitry Kozlov <xeb@mail.ru>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ppp/pptp.c
W:	http://sourceforge.net/projects/accel-pptp

PREEMPTIBLE KERNEL
M:	Robert Love <rml@tech9.net>
L:	kpreempt-tech@lists.sourceforge.net
W:	https://www.kernel.org/pub/linux/kernel/people/rml/preempt-kernel
S:	Supported
F:	Documentation/preempt-locking.txt
F:	include/linux/preempt.h

PRINTK
M:	Petr Mladek <pmladek@suse.com>
M:	Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
R:	Steven Rostedt <rostedt@goodmis.org>
S:	Maintained
F:	kernel/printk/
F:	include/linux/printk.h

PRISM54 WIRELESS DRIVER
M:	"Luis R. Rodriguez" <mcgrof@gmail.com>
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/en/users/Drivers/p54
S:	Obsolete
F:	drivers/net/wireless/intersil/prism54/

PROC SYSCTL
M:	"Luis R. Rodriguez" <mcgrof@kernel.org>
M:	Kees Cook <keescook@chromium.org>
L:	linux-kernel@vger.kernel.org
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
F:	fs/proc/proc_sysctl.c
F:	include/linux/sysctl.h
F:	kernel/sysctl.c
F:	tools/testing/selftests/sysctl/

PS3 NETWORK SUPPORT
M:	Geoff Levand <geoff@infradead.org>
L:	netdev@vger.kernel.org
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	drivers/net/ethernet/toshiba/ps3_gelic_net.*

PS3 PLATFORM SUPPORT
M:	Geoff Levand <geoff@infradead.org>
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	arch/powerpc/boot/ps3*
F:	arch/powerpc/include/asm/lv1call.h
F:	arch/powerpc/include/asm/ps3*.h
F:	arch/powerpc/platforms/ps3/
F:	drivers/*/ps3*
F:	drivers/ps3/
F:	drivers/rtc/rtc-ps3.c
F:	drivers/usb/host/*ps3.c
F:	sound/ppc/snd_ps3*

PS3VRAM DRIVER
M:	Jim Paris <jim@jtan.com>
M:	Geoff Levand <geoff@infradead.org>
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	drivers/block/ps3vram.c

PSAMPLE PACKET SAMPLING SUPPORT:
M:	Yotam Gigi <yotam.gi@gmail.com>
S:	Maintained
F:	net/psample
F:	include/net/psample.h
F:	include/uapi/linux/psample.h

PSTORE FILESYSTEM
M:	Kees Cook <keescook@chromium.org>
M:	Anton Vorontsov <anton@enomsg.org>
M:	Colin Cross <ccross@android.com>
M:	Tony Luck <tony.luck@intel.com>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/pstore
F:	fs/pstore/
F:	include/linux/pstore*
F:	drivers/firmware/efi/efi-pstore.c
F:	drivers/acpi/apei/erst.c
F:	Documentation/admin-guide/ramoops.rst
F:	Documentation/devicetree/bindings/reserved-memory/ramoops.txt
K:	\b(pstore|ramoops)

PTP HARDWARE CLOCK SUPPORT
M:	Richard Cochran <richardcochran@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
W:	http://linuxptp.sourceforge.net/
F:	Documentation/ABI/testing/sysfs-ptp
F:	Documentation/ptp/*
F:	drivers/net/phy/dp83640*
F:	drivers/ptp/*
F:	include/linux/ptp_cl*

PTRACE SUPPORT
M:	Oleg Nesterov <oleg@redhat.com>
S:	Maintained
F:	include/asm-generic/syscall.h
F:	include/linux/ptrace.h
F:	include/linux/regset.h
F:	include/linux/tracehook.h
F:	include/uapi/linux/ptrace.h
F:	include/uapi/linux/ptrace.h
F:	include/asm-generic/ptrace.h
F:	kernel/ptrace.c
F:	arch/*/ptrace*.c
F:	arch/*/*/ptrace*.c
F:	arch/*/include/asm/ptrace*.h

PULSE8-CEC DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/usb/pulse8-cec/*
F:	Documentation/media/cec-drivers/pulse8-cec.rst

PVRUSB2 VIDEO4LINUX DRIVER
M:	Mike Isely <isely@pobox.com>
L:	pvrusb2@isely.net	(subscribers-only)
L:	linux-media@vger.kernel.org
W:	http://www.isely.net/pvrusb2/
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	Documentation/media/v4l-drivers/pvrusb2*
F:	drivers/media/usb/pvrusb2/

PWC WEBCAM DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Odd Fixes
F:	drivers/media/usb/pwc/*

PWM FAN DRIVER
M:	Kamil Debski <kamil@wypas.org>
M:	Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
L:	linux-hwmon@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/hwmon/pwm-fan.txt
F:	Documentation/hwmon/pwm-fan
F:	drivers/hwmon/pwm-fan.c

PWM IR Transmitter
M:	Sean Young <sean@mess.org>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/rc/pwm-ir-tx.c

PWM SUBSYSTEM
M:	Thierry Reding <thierry.reding@gmail.com>
L:	linux-pwm@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/thierry.reding/linux-pwm.git
F:	Documentation/pwm.txt
F:	Documentation/devicetree/bindings/pwm/
F:	include/linux/pwm.h
F:	drivers/pwm/
F:	drivers/video/backlight/pwm_bl.c
F:	include/linux/pwm_backlight.h
F:	drivers/gpio/gpio-mvebu.c
F:	Documentation/devicetree/bindings/gpio/gpio-mvebu.txt

PXA GPIO DRIVER
M:	Robert Jarzmik <robert.jarzmik@free.fr>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-pxa.c

PXA MMCI DRIVER
S:	Orphan

PXA RTC DRIVER
M:	Robert Jarzmik <robert.jarzmik@free.fr>
L:	linux-rtc@vger.kernel.org
S:	Maintained

PXA2xx/PXA3xx SUPPORT
M:	Daniel Mack <daniel@zonque.org>
M:	Haojian Zhuang <haojian.zhuang@gmail.com>
M:	Robert Jarzmik <robert.jarzmik@free.fr>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://github.com/hzhuang1/linux.git
T:	git git://github.com/rjarzmik/linux.git
S:	Maintained
F:	arch/arm/boot/dts/pxa*
F:	arch/arm/mach-pxa/
F:	drivers/dma/pxa*
F:	drivers/pcmcia/pxa2xx*
F:	drivers/pinctrl/pxa/
F:	drivers/spi/spi-pxa2xx*
F:	drivers/usb/gadget/udc/pxa2*
F:	include/sound/pxa2xx-lib.h
F:	sound/arm/pxa*
F:	sound/soc/pxa/

QAT DRIVER
M:	Giovanni Cabiddu <giovanni.cabiddu@intel.com>
L:	qat-linux@intel.com
S:	Supported
F:	drivers/crypto/qat/

QCOM AUDIO (ASoC) DRIVERS
M:	Patrick Lai <plai@codeaurora.org>
M:	Banajit Goswami <bgoswami@codeaurora.org>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Supported
F:	sound/soc/qcom/

QEMU MACHINE EMULATOR AND VIRTUALIZER SUPPORT
M:	Gabriel Somlo <somlo@cmu.edu>
M:	"Michael S. Tsirkin" <mst@redhat.com>
L:	qemu-devel@nongnu.org
S:	Maintained
F:	drivers/firmware/qemu_fw_cfg.c
F:	include/uapi/linux/qemu_fw_cfg.h

QIB DRIVER
M:	Dennis Dalessandro <dennis.dalessandro@intel.com>
M:	Mike Marciniszyn <mike.marciniszyn@intel.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
F:	drivers/infiniband/hw/qib/

QLOGIC QL41xxx FCOE DRIVER
M:	QLogic-Storage-Upstream@cavium.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/qedf/

QLOGIC QL41xxx ISCSI DRIVER
M:	QLogic-Storage-Upstream@cavium.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/qedi/

QLOGIC QL4xxx ETHERNET DRIVER
M:	Ariel Elior <Ariel.Elior@cavium.com>
M:	everest-linux-l2@cavium.com
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/qlogic/qed/
F:	include/linux/qed/
F:	drivers/net/ethernet/qlogic/qede/

QLOGIC QL4xxx RDMA DRIVER
M:	Michal Kalderon <Michal.Kalderon@cavium.com>
M:	Ariel Elior <Ariel.Elior@cavium.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
F:	drivers/infiniband/hw/qedr/
F:	include/uapi/rdma/qedr-abi.h

QLOGIC QLA1280 SCSI DRIVER
M:	Michael Reed <mdr@sgi.com>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	drivers/scsi/qla1280.[ch]

QLOGIC QLA2XXX FC-SCSI DRIVER
M:	qla2xxx-upstream@qlogic.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	Documentation/scsi/LICENSE.qla2xxx
F:	drivers/scsi/qla2xxx/

QLOGIC QLA3XXX NETWORK DRIVER
M:	Dept-GELinuxNICDev@cavium.com
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/LICENSE.qla3xxx
F:	drivers/net/ethernet/qlogic/qla3xxx.*

QLOGIC QLA4XXX iSCSI DRIVER
M:	QLogic-Storage-Upstream@qlogic.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	Documentation/scsi/LICENSE.qla4xxx
F:	drivers/scsi/qla4xxx/

QLOGIC QLCNIC (1/10)Gb ETHERNET DRIVER
M:	Harish Patil <harish.patil@cavium.com>
M:	Manish Chopra <manish.chopra@cavium.com>
M:	Dept-GELinuxNICDev@cavium.com
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/qlogic/qlcnic/

QLOGIC QLGE 10Gb ETHERNET DRIVER
M:	Harish Patil <harish.patil@cavium.com>
M:	Manish Chopra <manish.chopra@cavium.com>
M:	Dept-GELinuxNICDev@cavium.com
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/qlogic/qlge/

QNX4 FILESYSTEM
M:	Anders Larsen <al@alarsen.net>
W:	http://www.alarsen.net/linux/qnx4fs/
S:	Maintained
F:	fs/qnx4/
F:	include/uapi/linux/qnx4_fs.h
F:	include/uapi/linux/qnxtypes.h

QORIQ DPAA2 FSL-MC BUS DRIVER
M:	Stuart Yoder <stuyoder@gmail.com>
M:	Laurentiu Tudor <laurentiu.tudor@nxp.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/bus/fsl-mc/
F:	Documentation/devicetree/bindings/misc/fsl,qoriq-mc.txt
F:	Documentation/networking/dpaa2/overview.rst

QT1010 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/tuners/qt1010*

QUALCOMM ATHEROS ATH10K WIRELESS DRIVER
M:	Kalle Valo <kvalo@codeaurora.org>
L:	ath10k@lists.infradead.org
W:	http://wireless.kernel.org/en/users/Drivers/ath10k
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git
S:	Supported
F:	drivers/net/wireless/ath/ath10k/

QUALCOMM ATHEROS ATH9K WIRELESS DRIVER
M:	QCA ath9k Development <ath9k-devel@qca.qualcomm.com>
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/en/users/Drivers/ath9k
S:	Supported
F:	drivers/net/wireless/ath/ath9k/

QUALCOMM CAMERA SUBSYSTEM DRIVER
M:	Todor Tomov <todor.tomov@linaro.org>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/qcom,camss.txt
F:	Documentation/media/v4l-drivers/qcom_camss.rst
F:	drivers/media/platform/qcom/camss-8x16/

QUALCOMM CPUFREQ DRIVER MSM8996/APQ8096
M:  Ilia Lin <ilia.lin@gmail.com>
L:  linux-pm@vger.kernel.org
S:  Maintained
F:  Documentation/devicetree/bindings/opp/kryo-cpufreq.txt
F:  drivers/cpufreq/qcom-cpufreq-kryo.c

QUALCOMM EMAC GIGABIT ETHERNET DRIVER
M:	Timur Tabi <timur@codeaurora.org>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/qualcomm/emac/

QUALCOMM HEXAGON ARCHITECTURE
M:	Richard Kuo <rkuo@codeaurora.org>
L:	linux-hexagon@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rkuo/linux-hexagon-kernel.git
S:	Supported
F:	arch/hexagon/

QUALCOMM HIDMA DRIVER
M:	Sinan Kaya <okaya@codeaurora.org>
L:	linux-arm-kernel@lists.infradead.org
L:	linux-arm-msm@vger.kernel.org
L:	dmaengine@vger.kernel.org
S:	Supported
F:	drivers/dma/qcom/hidma*

QUALCOMM IOMMU
M:	Rob Clark <robdclark@gmail.com>
L:	iommu@lists.linux-foundation.org
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	drivers/iommu/qcom_iommu.c

QUALCOMM VENUS VIDEO ACCELERATOR DRIVER
M:	Stanimir Varbanov <stanimir.varbanov@linaro.org>
L:	linux-media@vger.kernel.org
L:	linux-arm-msm@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/platform/qcom/venus/

QUALCOMM WCN36XX WIRELESS DRIVER
M:	Kalle Valo <kvalo@codeaurora.org>
L:	wcn36xx@lists.infradead.org
W:	http://wireless.kernel.org/en/users/Drivers/wcn36xx
T:	git git://github.com/KrasnikovEugene/wcn36xx.git
S:	Supported
F:	drivers/net/wireless/ath/wcn36xx/

QUANTENNA QTNFMAC WIRELESS DRIVER
M:	Igor Mitsyanko <imitsyanko@quantenna.com>
M:	Avinash Patil <avinashp@quantenna.com>
M:	Sergey Matyukevich <smatyukevich@quantenna.com>
L:	linux-wireless@vger.kernel.org
S:	Maintained
F:	drivers/net/wireless/quantenna

RADEON and AMDGPU DRM DRIVERS
M:	Alex Deucher <alexander.deucher@amd.com>
M:	Christian König <christian.koenig@amd.com>
M:	David (ChunMing) Zhou <David1.Zhou@amd.com>
L:	amd-gfx@lists.freedesktop.org
T:	git git://people.freedesktop.org/~agd5f/linux
S:	Supported
F:	drivers/gpu/drm/radeon/
F:	include/uapi/drm/radeon_drm.h
F:	drivers/gpu/drm/amd/
F:	include/uapi/drm/amdgpu_drm.h

RADEON FRAMEBUFFER DISPLAY DRIVER
M:	Benjamin Herrenschmidt <benh@kernel.crashing.org>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	drivers/video/fbdev/aty/radeon*
F:	include/uapi/linux/radeonfb.h

RADIOSHARK RADIO DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/radio/radio-shark.c

RADIOSHARK2 RADIO DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/radio/radio-shark2.c
F:	drivers/media/radio/radio-tea5777.c

RADOS BLOCK DEVICE (RBD)
M:	Ilya Dryomov <idryomov@gmail.com>
M:	Sage Weil <sage@redhat.com>
M:	Alex Elder <elder@kernel.org>
L:	ceph-devel@vger.kernel.org
W:	http://ceph.com/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client.git
T:	git git://github.com/ceph/ceph-client.git
S:	Supported
F:	Documentation/ABI/testing/sysfs-bus-rbd
F:	drivers/block/rbd.c
F:	drivers/block/rbd_types.h

RAGE128 FRAMEBUFFER DISPLAY DRIVER
M:	Paul Mackerras <paulus@samba.org>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	drivers/video/fbdev/aty/aty128fb.c

RAINSHADOW-CEC DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/usb/rainshadow-cec/*

RALINK MIPS ARCHITECTURE
M:	John Crispin <john@phrozen.org>
L:	linux-mips@linux-mips.org
S:	Maintained
F:	arch/mips/ralink

RALINK RT2X00 WIRELESS LAN DRIVER
P:	rt2x00 project
M:	Stanislaw Gruszka <sgruszka@redhat.com>
M:	Helmut Schaa <helmut.schaa@googlemail.com>
L:	linux-wireless@vger.kernel.org
S:	Maintained
F:	drivers/net/wireless/ralink/rt2x00/

RAMDISK RAM BLOCK DEVICE DRIVER
M:	Jens Axboe <axboe@kernel.dk>
S:	Maintained
F:	Documentation/blockdev/ramdisk.txt
F:	drivers/block/brd.c

RANCHU VIRTUAL BOARD FOR MIPS
M:	Miodrag Dinic <miodrag.dinic@mips.com>
L:	linux-mips@linux-mips.org
S:	Supported
F:	arch/mips/generic/board-ranchu.c
F:	arch/mips/configs/generic/board-ranchu.config

RANDOM NUMBER DRIVER
M:	"Theodore Ts'o" <tytso@mit.edu>
S:	Maintained
F:	drivers/char/random.c

RAPIDIO SUBSYSTEM
M:	Matt Porter <mporter@kernel.crashing.org>
M:	Alexandre Bounine <alex.bou9@gmail.com>
S:	Maintained
F:	drivers/rapidio/

RAYLINK/WEBGEAR 802.11 WIRELESS LAN DRIVER
L:	linux-wireless@vger.kernel.org
S:	Orphan
F:	drivers/net/wireless/ray*

RCUTORTURE TEST FRAMEWORK
M:	"Paul E. McKenney" <paulmck@linux.vnet.ibm.com>
M:	Josh Triplett <josh@joshtriplett.org>
R:	Steven Rostedt <rostedt@goodmis.org>
R:	Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
R:	Lai Jiangshan <jiangshanlai@gmail.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git
F:	tools/testing/selftests/rcutorture

RDC R-321X SoC
M:	Florian Fainelli <florian@openwrt.org>
S:	Maintained

RDC R6040 FAST ETHERNET DRIVER
M:	Florian Fainelli <f.fainelli@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/rdc/r6040.c

RDMAVT - RDMA verbs software
M:	Dennis Dalessandro <dennis.dalessandro@intel.com>
M:	Mike Marciniszyn <mike.marciniszyn@intel.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
F:	drivers/infiniband/sw/rdmavt

RDS - RELIABLE DATAGRAM SOCKETS
M:	Santosh Shilimkar <santosh.shilimkar@oracle.com>
L:	netdev@vger.kernel.org
L:	linux-rdma@vger.kernel.org
L:	rds-devel@oss.oracle.com (moderated for non-subscribers)
W:	https://oss.oracle.com/projects/rds/
S:	Supported
F:	net/rds/
F:	Documentation/networking/rds.txt

RDT - RESOURCE ALLOCATION
M:	Fenghua Yu <fenghua.yu@intel.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	arch/x86/kernel/cpu/intel_rdt*
F:	arch/x86/include/asm/intel_rdt_sched.h
F:	Documentation/x86/intel_rdt*

READ-COPY UPDATE (RCU)
M:	"Paul E. McKenney" <paulmck@linux.vnet.ibm.com>
M:	Josh Triplett <josh@joshtriplett.org>
R:	Steven Rostedt <rostedt@goodmis.org>
R:	Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
R:	Lai Jiangshan <jiangshanlai@gmail.com>
L:	linux-kernel@vger.kernel.org
W:	http://www.rdrop.com/users/paulmck/RCU/
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git
F:	Documentation/RCU/
X:	Documentation/RCU/torture.txt
F:	include/linux/rcu*
X:	include/linux/srcu.h
F:	kernel/rcu/
X:	kernel/torture.c

REAL TIME CLOCK (RTC) SUBSYSTEM
M:	Alessandro Zummo <a.zummo@towertech.it>
M:	Alexandre Belloni <alexandre.belloni@bootlin.com>
L:	linux-rtc@vger.kernel.org
Q:	http://patchwork.ozlabs.org/project/rtc-linux/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/abelloni/linux.git
S:	Maintained
F:	Documentation/devicetree/bindings/rtc/
F:	Documentation/rtc.txt
F:	drivers/rtc/
F:	include/linux/rtc.h
F:	include/uapi/linux/rtc.h
F:	include/linux/rtc/
F:	include/linux/platform_data/rtc-*
F:	tools/testing/selftests/rtc/

REALTEK AUDIO CODECS
M:	Bard Liao <bardliao@realtek.com>
M:	Oder Chiou <oder_chiou@realtek.com>
S:	Maintained
F:	sound/soc/codecs/rt*
F:	include/sound/rt*.h

REGISTER MAP ABSTRACTION
M:	Mark Brown <broonie@kernel.org>
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap.git
S:	Supported
F:	Documentation/devicetree/bindings/regmap/
F:	drivers/base/regmap/
F:	include/linux/regmap.h

REISERFS FILE SYSTEM
L:	reiserfs-devel@vger.kernel.org
S:	Supported
F:	fs/reiserfs/

REMOTE PROCESSOR (REMOTEPROC) SUBSYSTEM
M:	Ohad Ben-Cohen <ohad@wizery.com>
M:	Bjorn Andersson <bjorn.andersson@linaro.org>
L:	linux-remoteproc@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ohad/remoteproc.git
S:	Maintained
F:	Documentation/devicetree/bindings/remoteproc/
F:	Documentation/remoteproc.txt
F:	drivers/remoteproc/
F:	include/linux/remoteproc.h

REMOTE PROCESSOR MESSAGING (RPMSG) SUBSYSTEM
M:	Ohad Ben-Cohen <ohad@wizery.com>
M:	Bjorn Andersson <bjorn.andersson@linaro.org>
L:	linux-remoteproc@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ohad/rpmsg.git
S:	Maintained
F:	drivers/rpmsg/
F:	Documentation/rpmsg.txt
F:	include/linux/rpmsg.h
F:	include/linux/rpmsg/

RENESAS CLOCK DRIVERS
M:	Geert Uytterhoeven <geert+renesas@glider.be>
L:	linux-renesas-soc@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/geert/renesas-drivers.git clk-renesas
S:	Supported
F:	drivers/clk/renesas/

RENESAS EMEV2 I2C DRIVER
M:	Wolfram Sang <wsa+renesas@sang-engineering.com>
S:	Supported
F:	drivers/i2c/busses/i2c-emev2.c

RENESAS ETHERNET DRIVERS
R:	Sergei Shtylyov <sergei.shtylyov@cogentembedded.com>
L:	netdev@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
F:	Documentation/devicetree/bindings/net/renesas,*.txt
F:	Documentation/devicetree/bindings/net/sh_eth.txt
F:	drivers/net/ethernet/renesas/
F:	include/linux/sh_eth.h

RENESAS R-CAR GYROADC DRIVER
M:	Marek Vasut <marek.vasut@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Supported
F:	drivers/iio/adc/rcar_gyro_adc.c

RENESAS R-CAR I2C DRIVERS
M:	Wolfram Sang <wsa+renesas@sang-engineering.com>
S:	Supported
F:	drivers/i2c/busses/i2c-rcar.c
F:	drivers/i2c/busses/i2c-sh_mobile.c

RENESAS USB PHY DRIVER
M:	Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
L:	linux-renesas-soc@vger.kernel.org
S:	Maintained
F:	drivers/phy/renesas/phy-rcar-gen3-usb*.c

RESET CONTROLLER FRAMEWORK
M:	Philipp Zabel <p.zabel@pengutronix.de>
T:	git git://git.pengutronix.de/git/pza/linux
S:	Maintained
F:	drivers/reset/
F:	Documentation/devicetree/bindings/reset/
F:	include/dt-bindings/reset/
F:	include/linux/reset.h
F:	include/linux/reset-controller.h

RESTARTABLE SEQUENCES SUPPORT
M:	Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
M:	Peter Zijlstra <peterz@infradead.org>
M:	"Paul E. McKenney" <paulmck@linux.vnet.ibm.com>
M:	Boqun Feng <boqun.feng@gmail.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	kernel/rseq.c
F:	include/uapi/linux/rseq.h
F:	include/trace/events/rseq.h
F:	tools/testing/selftests/rseq/

RFKILL
M:	Johannes Berg <johannes@sipsolutions.net>
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jberg/mac80211.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jberg/mac80211-next.git
S:	Maintained
F:	Documentation/rfkill.txt
F:	Documentation/ABI/stable/sysfs-class-rfkill
F:	net/rfkill/

RHASHTABLE
M:	Thomas Graf <tgraf@suug.ch>
M:	Herbert Xu <herbert@gondor.apana.org.au>
L:	netdev@vger.kernel.org
S:	Maintained
F:	lib/rhashtable.c
F:	include/linux/rhashtable.h

RICOH R5C592 MEMORYSTICK DRIVER
M:	Maxim Levitsky <maximlevitsky@gmail.com>
S:	Maintained
F:	drivers/memstick/host/r592.*

RICOH SMARTMEDIA/XD DRIVER
M:	Maxim Levitsky <maximlevitsky@gmail.com>
S:	Maintained
F:	drivers/mtd/nand/raw/r852.c
F:	drivers/mtd/nand/raw/r852.h

RISC-V ARCHITECTURE
M:	Palmer Dabbelt <palmer@sifive.com>
M:	Albert Ou <aou@eecs.berkeley.edu>
L:	linux-riscv@lists.infradead.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/palmer/riscv-linux.git
S:	Supported
F:	arch/riscv/
K:	riscv
N:	riscv

ROCCAT DRIVERS
M:	Stefan Achatz <erazor_de@users.sourceforge.net>
W:	http://sourceforge.net/projects/roccat/
S:	Maintained
F:	drivers/hid/hid-roccat*
F:	include/linux/hid-roccat*
F:	Documentation/ABI/*/sysfs-driver-hid-roccat*

ROCKCHIP RASTER 2D GRAPHIC ACCELERATION UNIT DRIVER
M:	Jacob chen <jacob2.chen@rock-chips.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/platform/rockchip/rga/
F:	Documentation/devicetree/bindings/media/rockchip-rga.txt

ROCKER DRIVER
M:	Jiri Pirko <jiri@resnulli.us>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/rocker/

ROCKETPORT DRIVER
P:	Comtrol Corp.
W:	http://www.comtrol.com
S:	Maintained
F:	Documentation/serial/rocket.txt
F:	drivers/tty/rocket*

ROCKETPORT EXPRESS/INFINITY DRIVER
M:	Kevin Cernekee <cernekee@gmail.com>
L:	linux-serial@vger.kernel.org
S:	Odd Fixes
F:	drivers/tty/serial/rp2.*

ROHM MULTIFUNCTION BD9571MWV-M PMIC DEVICE DRIVERS
M:	Marek Vasut <marek.vasut+renesas@gmail.com>
L:	linux-kernel@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
F:	drivers/mfd/bd9571mwv.c
F:	drivers/regulator/bd9571mwv-regulator.c
F:	drivers/gpio/gpio-bd9571mwv.c
F:	include/linux/mfd/bd9571mwv.h
F:	Documentation/devicetree/bindings/mfd/bd9571mwv.txt

ROSE NETWORK LAYER
M:	Ralf Baechle <ralf@linux-mips.org>
L:	linux-hams@vger.kernel.org
W:	http://www.linux-ax25.org/
S:	Maintained
F:	include/net/rose.h
F:	include/uapi/linux/rose.h
F:	net/rose/

RTL2830 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/rtl2830*

RTL2832 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/rtl2832*

RTL2832_SDR MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/rtl2832_sdr*

RTL8180 WIRELESS DRIVER
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-testing.git
S:	Orphan
F:	drivers/net/wireless/realtek/rtl818x/rtl8180/

RTL8187 WIRELESS DRIVER
M:	Herton Ronaldo Krzesinski <herton@canonical.com>
M:	Hin-Tak Leung <htl10@users.sourceforge.net>
M:	Larry Finger <Larry.Finger@lwfinger.net>
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-testing.git
S:	Maintained
F:	drivers/net/wireless/realtek/rtl818x/rtl8187/

REALTEK WIRELESS DRIVER (rtlwifi family)
M:	Ping-Ke Shih <pkshih@realtek.com>
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-testing.git
S:	Maintained
F:	drivers/net/wireless/realtek/rtlwifi/

RTL8XXXU WIRELESS DRIVER (rtl8xxxu)
M:	Jes Sorensen <Jes.Sorensen@gmail.com>
L:	linux-wireless@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jes/linux.git rtl8xxxu-devel
S:	Maintained
F:	drivers/net/wireless/realtek/rtl8xxxu/

RXRPC SOCKETS (AF_RXRPC)
M:	David Howells <dhowells@redhat.com>
L:	linux-afs@lists.infradead.org
S:	Supported
F:	net/rxrpc/
F:	include/keys/rxrpc-type.h
F:	include/net/af_rxrpc.h
F:	include/trace/events/rxrpc.h
F:	include/uapi/linux/rxrpc.h
F:	Documentation/networking/rxrpc.txt
W:	https://www.infradead.org/~dhowells/kafs/

S3 SAVAGE FRAMEBUFFER DRIVER
M:	Antonino Daplas <adaplas@gmail.com>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	drivers/video/fbdev/savage/

S390
M:	Martin Schwidefsky <schwidefsky@de.ibm.com>
M:	Heiko Carstens <heiko.carstens@de.ibm.com>
L:	linux-s390@vger.kernel.org
W:	http://www.ibm.com/developerworks/linux/linux390/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux.git
S:	Supported
F:	arch/s390/
F:	drivers/s390/
F:	Documentation/s390/
F:	Documentation/driver-api/s390-drivers.rst

S390 COMMON I/O LAYER
M:	Sebastian Ott <sebott@linux.ibm.com>
M:	Peter Oberparleiter <oberpar@linux.ibm.com>
L:	linux-s390@vger.kernel.org
W:	http://www.ibm.com/developerworks/linux/linux390/
S:	Supported
F:	drivers/s390/cio/

S390 DASD DRIVER
M:	Stefan Haberland <sth@linux.ibm.com>
M:	Jan Hoeppner <hoeppner@linux.ibm.com>
L:	linux-s390@vger.kernel.org
W:	http://www.ibm.com/developerworks/linux/linux390/
S:	Supported
F:	drivers/s390/block/dasd*
F:	block/partitions/ibm.c

S390 IOMMU (PCI)
M:	Gerald Schaefer <gerald.schaefer@de.ibm.com>
L:	linux-s390@vger.kernel.org
W:	http://www.ibm.com/developerworks/linux/linux390/
S:	Supported
F:	drivers/iommu/s390-iommu.c

S390 IUCV NETWORK LAYER
M:	Julian Wiedmann <jwi@linux.ibm.com>
M:	Ursula Braun <ubraun@linux.ibm.com>
L:	linux-s390@vger.kernel.org
W:	http://www.ibm.com/developerworks/linux/linux390/
S:	Supported
F:	drivers/s390/net/*iucv*
F:	include/net/iucv/
F:	net/iucv/

S390 NETWORK DRIVERS
M:	Julian Wiedmann <jwi@linux.ibm.com>
M:	Ursula Braun <ubraun@linux.ibm.com>
L:	linux-s390@vger.kernel.org
W:	http://www.ibm.com/developerworks/linux/linux390/
S:	Supported
F:	drivers/s390/net/

S390 PCI SUBSYSTEM
M:	Sebastian Ott <sebott@linux.ibm.com>
M:	Gerald Schaefer <gerald.schaefer@de.ibm.com>
L:	linux-s390@vger.kernel.org
W:	http://www.ibm.com/developerworks/linux/linux390/
S:	Supported
F:	arch/s390/pci/
F:	drivers/pci/hotplug/s390_pci_hpc.c

S390 VFIO-CCW DRIVER
M:	Cornelia Huck <cohuck@redhat.com>
M:	Dong Jia Shi <bjsdjshi@linux.ibm.com>
M:	Halil Pasic <pasic@linux.ibm.com>
L:	linux-s390@vger.kernel.org
L:	kvm@vger.kernel.org
S:	Supported
F:	drivers/s390/cio/vfio_ccw*
F:	Documentation/s390/vfio-ccw.txt
F:	include/uapi/linux/vfio_ccw.h

S390 ZCRYPT DRIVER
M:	Harald Freudenberger <freude@linux.ibm.com>
L:	linux-s390@vger.kernel.org
W:	http://www.ibm.com/developerworks/linux/linux390/
S:	Supported
F:	drivers/s390/crypto/

S390 ZFCP DRIVER
M:	Steffen Maier <maier@linux.ibm.com>
M:	Benjamin Block <bblock@linux.ibm.com>
L:	linux-s390@vger.kernel.org
W:	http://www.ibm.com/developerworks/linux/linux390/
S:	Supported
F:	drivers/s390/scsi/zfcp_*

S3C24XX SD/MMC Driver
M:	Ben Dooks <ben-linux@fluff.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	drivers/mmc/host/s3cmci.*

SAA6588 RDS RECEIVER DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Odd Fixes
F:	drivers/media/i2c/saa6588*

SAA7134 VIDEO4LINUX DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Odd fixes
F:	Documentation/media/v4l-drivers/saa7134*
F:	drivers/media/pci/saa7134/

SAA7146 VIDEO4LINUX-2 DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/common/saa7146/
F:	drivers/media/pci/saa7146/
F:	include/media/saa7146*

SAMSUNG AUDIO (ASoC) DRIVERS
M:	Krzysztof Kozlowski <krzk@kernel.org>
M:	Sangbeom Kim <sbkim73@samsung.com>
M:	Sylwester Nawrocki <s.nawrocki@samsung.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Supported
F:	sound/soc/samsung/
F:	Documentation/devicetree/bindings/sound/samsung*

SAMSUNG EXYNOS PSEUDO RANDOM NUMBER GENERATOR (RNG) DRIVER
M:	Krzysztof Kozlowski <krzk@kernel.org>
L:	linux-crypto@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org
S:	Maintained
F:	drivers/crypto/exynos-rng.c
F:	Documentation/devicetree/bindings/crypto/samsung,exynos-rng4.txt

SAMSUNG EXYNOS TRUE RANDOM NUMBER GENERATOR (TRNG) DRIVER
M:	Łukasz Stelmach <l.stelmach@samsung.com>
L:	linux-samsung-soc@vger.kernel.org
S:	Maintained
F:	drivers/char/hw_random/exynos-trng.c
F:	Documentation/devicetree/bindings/rng/samsung,exynos5250-trng.txt

SAMSUNG FRAMEBUFFER DRIVER
M:	Jingoo Han <jingoohan1@gmail.com>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	drivers/video/fbdev/s3c-fb.c

SAMSUNG LAPTOP DRIVER
M:	Corentin Chary <corentin.chary@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/samsung-laptop.c

SAMSUNG MULTIFUNCTION PMIC DEVICE DRIVERS
M:	Sangbeom Kim <sbkim73@samsung.com>
M:	Krzysztof Kozlowski <krzk@kernel.org>
M:	Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
L:	linux-kernel@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org
S:	Supported
F:	drivers/mfd/sec*.c
F:	drivers/regulator/s2m*.c
F:	drivers/regulator/s5m*.c
F:	drivers/clk/clk-s2mps11.c
F:	drivers/rtc/rtc-s5m.c
F:	include/linux/mfd/samsung/
F:	Documentation/devicetree/bindings/mfd/samsung,sec-core.txt
F:	Documentation/devicetree/bindings/regulator/samsung,s2m*.txt
F:	Documentation/devicetree/bindings/regulator/samsung,s5m*.txt
F:	Documentation/devicetree/bindings/clock/samsung,s2mps11.txt

SAMSUNG S3C24XX/S3C64XX SOC SERIES CAMIF DRIVER
M:	Sylwester Nawrocki <sylvester.nawrocki@gmail.com>
L:	linux-media@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/media/platform/s3c-camif/
F:	include/media/drv-intf/s3c_camif.h

SAMSUNG S3FWRN5 NFC DRIVER
M:	Robert Baldyga <r.baldyga@samsung.com>
M:	Krzysztof Opasiak <k.opasiak@samsung.com>
L:	linux-nfc@lists.01.org (moderated for non-subscribers)
S:	Supported
F:	drivers/nfc/s3fwrn5

SAMSUNG S5C73M3 CAMERA DRIVER
M:	Kyungmin Park <kyungmin.park@samsung.com>
M:	Andrzej Hajda <a.hajda@samsung.com>
L:	linux-media@vger.kernel.org
S:	Supported
F:	drivers/media/i2c/s5c73m3/*

SAMSUNG S5K5BAF CAMERA DRIVER
M:	Kyungmin Park <kyungmin.park@samsung.com>
M:	Andrzej Hajda <a.hajda@samsung.com>
L:	linux-media@vger.kernel.org
S:	Supported
F:	drivers/media/i2c/s5k5baf.c

SAMSUNG S5P Security SubSystem (SSS) DRIVER
M:	Krzysztof Kozlowski <krzk@kernel.org>
M:	Vladimir Zapolskiy <vz@mleia.com>
M:	Kamil Konieczny <k.konieczny@partner.samsung.com>
L:	linux-crypto@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org
S:	Maintained
F:	drivers/crypto/s5p-sss.c

SAMSUNG S5P/EXYNOS4 SOC SERIES CAMERA SUBSYSTEM DRIVERS
M:	Kyungmin Park <kyungmin.park@samsung.com>
M:	Sylwester Nawrocki <s.nawrocki@samsung.com>
L:	linux-media@vger.kernel.org
Q:	https://patchwork.linuxtv.org/project/linux-media/list/
S:	Supported
F:	drivers/media/platform/exynos4-is/

SAMSUNG SOC CLOCK DRIVERS
M:	Sylwester Nawrocki <s.nawrocki@samsung.com>
M:	Tomasz Figa <tomasz.figa@gmail.com>
M:	Chanwoo Choi <cw00.choi@samsung.com>
S:	Supported
L:	linux-samsung-soc@vger.kernel.org (moderated for non-subscribers)
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/snawrocki/clk.git
F:	drivers/clk/samsung/
F:	include/dt-bindings/clock/exynos*.h
F:	Documentation/devicetree/bindings/clock/exynos*.txt

SAMSUNG SPI DRIVERS
M:	Kukjin Kim <kgene@kernel.org>
M:	Krzysztof Kozlowski <krzk@kernel.org>
M:	Andi Shyti <andi@etezian.org>
L:	linux-spi@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/spi/spi-samsung.txt
F:	drivers/spi/spi-s3c*
F:	include/linux/platform_data/spi-s3c64xx.h

SAMSUNG SXGBE DRIVERS
M:	Byungho An <bh74.an@samsung.com>
M:	Girish K S <ks.giri@samsung.com>
M:	Vipul Pandya <vipul.pandya@samsung.com>
S:	Supported
L:	netdev@vger.kernel.org
F:	drivers/net/ethernet/samsung/sxgbe/

SAMSUNG THERMAL DRIVER
M:	Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
L:	linux-pm@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org
S:	Supported
T:	git https://github.com/lmajewski/linux-samsung-thermal.git
F:	drivers/thermal/samsung/

SAMSUNG USB2 PHY DRIVER
M:	Kamil Debski <kamil@wypas.org>
M:	Sylwester Nawrocki <s.nawrocki@samsung.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/phy/samsung-phy.txt
F:	Documentation/phy/samsung-usb2.txt
F:	drivers/phy/samsung/phy-exynos4210-usb2.c
F:	drivers/phy/samsung/phy-exynos4x12-usb2.c
F:	drivers/phy/samsung/phy-exynos5250-usb2.c
F:	drivers/phy/samsung/phy-s5pv210-usb2.c
F:	drivers/phy/samsung/phy-samsung-usb2.c
F:	drivers/phy/samsung/phy-samsung-usb2.h

SC1200 WDT DRIVER
M:	Zwane Mwaikambo <zwanem@gmail.com>
S:	Maintained
F:	drivers/watchdog/sc1200wdt.c

SCHEDULER
M:	Ingo Molnar <mingo@redhat.com>
M:	Peter Zijlstra <peterz@infradead.org>
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git sched/core
S:	Maintained
F:	kernel/sched/
F:	include/linux/sched.h
F:	include/uapi/linux/sched.h
F:	include/linux/wait.h

SCR24X CHIP CARD INTERFACE DRIVER
M:	Lubomir Rintel <lkundrak@v3.sk>
S:	Supported
F:	drivers/char/pcmcia/scr24x_cs.c

SCSI CDROM DRIVER
M:	Jens Axboe <axboe@kernel.dk>
L:	linux-scsi@vger.kernel.org
W:	http://www.kernel.dk
S:	Maintained
F:	drivers/scsi/sr*

SCSI RDMA PROTOCOL (SRP) INITIATOR
M:	Bart Van Assche <bart.vanassche@sandisk.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
W:	http://www.openfabrics.org
Q:	http://patchwork.kernel.org/project/linux-rdma/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/dad/srp-initiator.git
F:	drivers/infiniband/ulp/srp/
F:	include/scsi/srp.h

SCSI SG DRIVER
M:	Doug Gilbert <dgilbert@interlog.com>
L:	linux-scsi@vger.kernel.org
W:	http://sg.danny.cz/sg
S:	Maintained
F:	Documentation/scsi/scsi-generic.txt
F:	drivers/scsi/sg.c
F:	include/scsi/sg.h

SCSI SUBSYSTEM
M:	"James E.J. Bottomley" <jejb@linux.vnet.ibm.com>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi.git
M:	"Martin K. Petersen" <martin.petersen@oracle.com>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mkp/scsi.git
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/scsi/
F:	drivers/scsi/
F:	include/scsi/

SCSI TAPE DRIVER
M:	Kai Mäkisara <Kai.Makisara@kolumbus.fi>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	Documentation/scsi/st.txt
F:	drivers/scsi/st.*
F:	drivers/scsi/st_*.h

SCTP PROTOCOL
M:	Vlad Yasevich <vyasevich@gmail.com>
M:	Neil Horman <nhorman@tuxdriver.com>
M:	Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
L:	linux-sctp@vger.kernel.org
W:	http://lksctp.sourceforge.net
S:	Maintained
F:	Documentation/networking/sctp.txt
F:	include/linux/sctp.h
F:	include/uapi/linux/sctp.h
F:	include/net/sctp/
F:	net/sctp/

SCx200 CPU SUPPORT
M:	Jim Cromie <jim.cromie@gmail.com>
S:	Odd Fixes
F:	Documentation/i2c/busses/scx200_acb
F:	arch/x86/platform/scx200/
F:	drivers/watchdog/scx200_wdt.c
F:	drivers/i2c/busses/scx200*
F:	drivers/mtd/maps/scx200_docflash.c
F:	include/linux/scx200.h

SCx200 GPIO DRIVER
M:	Jim Cromie <jim.cromie@gmail.com>
S:	Maintained
F:	drivers/char/scx200_gpio.c
F:	include/linux/scx200_gpio.h

SCx200 HRT CLOCKSOURCE DRIVER
M:	Jim Cromie <jim.cromie@gmail.com>
S:	Maintained
F:	drivers/clocksource/scx200_hrt.c

SDRICOH_CS MMC/SD HOST CONTROLLER INTERFACE DRIVER
M:	Sascha Sommer <saschasommer@freenet.de>
L:	sdricohcs-devel@lists.sourceforge.net (subscribers-only)
S:	Maintained
F:	drivers/mmc/host/sdricoh_cs.c

SECURE COMPUTING
M:	Kees Cook <keescook@chromium.org>
R:	Andy Lutomirski <luto@amacapital.net>
R:	Will Drewry <wad@chromium.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git seccomp
S:	Supported
F:	kernel/seccomp.c
F:	include/uapi/linux/seccomp.h
F:	include/linux/seccomp.h
F:	tools/testing/selftests/seccomp/*
F:	tools/testing/selftests/kselftest_harness.h
F:	Documentation/userspace-api/seccomp_filter.rst
K:	\bsecure_computing
K:	\bTIF_SECCOMP\b

SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) Broadcom BRCMSTB DRIVER
M:	Al Cooper <alcooperx@gmail.com>
L:	linux-mmc@vger.kernel.org
L:	bcm-kernel-feedback-list@broadcom.com
S:	Maintained
F:	drivers/mmc/host/sdhci-brcmstb*

SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) DRIVER
M:	Adrian Hunter <adrian.hunter@intel.com>
L:	linux-mmc@vger.kernel.org
T:	git git://git.infradead.org/users/ahunter/linux-sdhci.git
S:	Maintained
F:	drivers/mmc/host/sdhci*
F:	include/linux/mmc/sdhci*

SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) SAMSUNG DRIVER
M:	Ben Dooks <ben-linux@fluff.org>
M:	Jaehoon Chung <jh80.chung@samsung.com>
L:	linux-mmc@vger.kernel.org
S:	Maintained
F:	drivers/mmc/host/sdhci-s3c*

SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) ST SPEAR DRIVER
M:	Viresh Kumar <vireshk@kernel.org>
L:	linux-mmc@vger.kernel.org
S:	Maintained
F:	drivers/mmc/host/sdhci-spear.c

SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) TI OMAP DRIVER
M:	Kishon Vijay Abraham I <kishon@ti.com>
L:	linux-mmc@vger.kernel.org
S:	Maintained
F:	drivers/mmc/host/sdhci-omap.c

SECURE ENCRYPTING DEVICE (SED) OPAL DRIVER
M:	Scott Bauer <scott.bauer@intel.com>
M:	Jonathan Derrick <jonathan.derrick@intel.com>
L:	linux-block@vger.kernel.org
S:	Supported
F:	block/sed*
F:	block/opal_proto.h
F:	include/linux/sed*
F:	include/uapi/linux/sed*

SECURITY CONTACT
M:	Security Officers <security@kernel.org>
S:	Supported

SECURITY SUBSYSTEM
M:	James Morris <jmorris@namei.org>
M:	"Serge E. Hallyn" <serge@hallyn.com>
L:	linux-security-module@vger.kernel.org (suggested Cc:)
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security.git
W:	http://kernsec.org/
S:	Supported
F:	security/

SELINUX SECURITY MODULE
M:	Paul Moore <paul@paul-moore.com>
M:	Stephen Smalley <sds@tycho.nsa.gov>
M:	Eric Paris <eparis@parisplace.org>
L:	selinux@tycho.nsa.gov (moderated for non-subscribers)
W:	https://selinuxproject.org
W:	https://github.com/SELinuxProject
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pcmoore/selinux.git
S:	Supported
F:	include/linux/selinux*
F:	security/selinux/
F:	scripts/selinux/
F:	Documentation/admin-guide/LSM/SELinux.rst

SENSABLE PHANTOM
M:	Jiri Slaby <jirislaby@gmail.com>
S:	Maintained
F:	drivers/misc/phantom.c
F:	include/uapi/linux/phantom.h

SERIAL DEVICE BUS
M:	Rob Herring <robh@kernel.org>
L:	linux-serial@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/serial/slave-device.txt
F:	drivers/tty/serdev/
F:	include/linux/serdev.h

SERIAL DRIVERS
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
L:	linux-serial@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/serial/
F:	drivers/tty/serial/

SERIAL IR RECEIVER
M:	Sean Young <sean@mess.org>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/rc/serial_ir.c

SFC NETWORK DRIVER
M:	Solarflare linux maintainers <linux-net-drivers@solarflare.com>
M:	Edward Cree <ecree@solarflare.com>
M:	Bert Kenward <bkenward@solarflare.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/sfc/

SGI GRU DRIVER
M:	Dimitri Sivanich <sivanich@sgi.com>
S:	Maintained
F:	drivers/misc/sgi-gru/

SGI SN-IA64 (Altix) SERIAL CONSOLE DRIVER
M:	Pat Gefre <pfg@sgi.com>
L:	linux-ia64@vger.kernel.org
S:	Supported
F:	Documentation/ia64/serial.txt
F:	drivers/tty/serial/ioc?_serial.c
F:	include/linux/ioc?.h

SGI XP/XPC/XPNET DRIVER
M:	Cliff Whickman <cpw@sgi.com>
M:	Robin Holt <robinmholt@gmail.com>
S:	Maintained
F:	drivers/misc/sgi-xp/

SHARED MEMORY COMMUNICATIONS (SMC) SOCKETS
M:	Ursula Braun <ubraun@linux.ibm.com>
L:	linux-s390@vger.kernel.org
W:	http://www.ibm.com/developerworks/linux/linux390/
S:	Supported
F:	net/smc/

SH_VEU V4L2 MEM2MEM DRIVER
L:	linux-media@vger.kernel.org
S:	Orphan
F:	drivers/media/platform/sh_veu.c

SH_VOU V4L2 OUTPUT DRIVER
L:	linux-media@vger.kernel.org
S:	Orphan
F:	drivers/media/platform/sh_vou.c
F:	include/media/drv-intf/sh_vou.h

SI2157 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/tuners/si2157*

SI2165 MEDIA DRIVER
M:	Matthias Schwarzott <zzam@gentoo.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
S:	Maintained
F:	drivers/media/dvb-frontends/si2165*

SI2168 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/si2168*

SI470X FM RADIO RECEIVER I2C DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Odd Fixes
F:	drivers/media/radio/si470x/radio-si470x-i2c.c

SI470X FM RADIO RECEIVER USB DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/radio/si470x/radio-si470x-common.c
F:	drivers/media/radio/si470x/radio-si470x.h
F:	drivers/media/radio/si470x/radio-si470x-usb.c

SI4713 FM RADIO TRANSMITTER I2C DRIVER
M:	Eduardo Valentin <edubezval@gmail.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Odd Fixes
F:	drivers/media/radio/si4713/si4713.?

SI4713 FM RADIO TRANSMITTER PLATFORM DRIVER
M:	Eduardo Valentin <edubezval@gmail.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Odd Fixes
F:	drivers/media/radio/si4713/radio-platform-si4713.c

SI4713 FM RADIO TRANSMITTER USB DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/radio/si4713/radio-usb-si4713.c

SIANO DVB DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Odd fixes
F:	drivers/media/common/siano/
F:	drivers/media/usb/siano/
F:	drivers/media/usb/siano/
F:	drivers/media/mmc/siano/

SIFIVE DRIVERS
M:	Palmer Dabbelt <palmer@sifive.com>
L:	linux-riscv@lists.infradead.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/palmer/riscv-linux.git
S:	Supported
K:	sifive
N:	sifive

SILEAD TOUCHSCREEN DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-input@vger.kernel.org
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/input/touchscreen/silead.c
F:	drivers/platform/x86/silead_dmi.c

SILICON MOTION SM712 FRAME BUFFER DRIVER
M:	Sudip Mukherjee <sudipm.mukherjee@gmail.com>
M:	Teddy Wang <teddy.wang@siliconmotion.com>
M:	Sudip Mukherjee <sudip.mukherjee@codethink.co.uk>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	drivers/video/fbdev/sm712*
F:	Documentation/fb/sm712fb.txt

SIMPLE FIRMWARE INTERFACE (SFI)
M:	Len Brown <lenb@kernel.org>
L:	sfi-devel@simplefirmware.org
W:	http://simplefirmware.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux-sfi-2.6.git
S:	Supported
F:	arch/x86/platform/sfi/
F:	drivers/sfi/
F:	include/linux/sfi*.h

SIMPLEFB FB DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/display/simple-framebuffer.txt
F:	drivers/video/fbdev/simplefb.c
F:	include/linux/platform_data/simplefb.h

SIMTEC EB110ATX (Chalice CATS)
P:	Ben Dooks
P:	Vincent Sanders <vince@simtec.co.uk>
M:	Simtec Linux Team <linux@simtec.co.uk>
W:	http://www.simtec.co.uk/products/EB110ATX/
S:	Supported

SIMTEC EB2410ITX (BAST)
P:	Ben Dooks
P:	Vincent Sanders <vince@simtec.co.uk>
M:	Simtec Linux Team <linux@simtec.co.uk>
W:	http://www.simtec.co.uk/products/EB2410ITX/
S:	Supported
F:	arch/arm/mach-s3c24xx/mach-bast.c
F:	arch/arm/mach-s3c24xx/bast-ide.c
F:	arch/arm/mach-s3c24xx/bast-irq.c

SIPHASH PRF ROUTINES
M:	Jason A. Donenfeld <Jason@zx2c4.com>
S:	Maintained
F:	lib/siphash.c
F:	lib/test_siphash.c
F:	include/linux/siphash.h

SIOX
M:	Gavin Schenk <g.schenk@eckelmann.de>
M:	Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
R:	Pengutronix Kernel Team <kernel@pengutronix.de>
S:	Supported
F:	drivers/siox/*
F:	include/trace/events/siox.h

SIS 190 ETHERNET DRIVER
M:	Francois Romieu <romieu@fr.zoreil.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/sis/sis190.c

SIS 900/7016 FAST ETHERNET DRIVER
M:	Daniele Venzano <venza@brownhat.org>
W:	http://www.brownhat.org/sis900.html
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/sis/sis900.*

SIS FRAMEBUFFER DRIVER
M:	Thomas Winischhofer <thomas@winischhofer.net>
W:	http://www.winischhofer.net/linuxsisvga.shtml
S:	Maintained
F:	Documentation/fb/sisfb.txt
F:	drivers/video/fbdev/sis/
F:	include/video/sisfb.h

SIS USB2VGA DRIVER
M:	Thomas Winischhofer <thomas@winischhofer.net>
W:	http://www.winischhofer.at/linuxsisusbvga.shtml
S:	Maintained
F:	drivers/usb/misc/sisusbvga/

SLAB ALLOCATOR
M:	Christoph Lameter <cl@linux.com>
M:	Pekka Enberg <penberg@kernel.org>
M:	David Rientjes <rientjes@google.com>
M:	Joonsoo Kim <iamjoonsoo.kim@lge.com>
M:	Andrew Morton <akpm@linux-foundation.org>
L:	linux-mm@kvack.org
S:	Maintained
F:	include/linux/sl?b*.h
F:	mm/sl?b*

SLEEPABLE READ-COPY UPDATE (SRCU)
M:	Lai Jiangshan <jiangshanlai@gmail.com>
M:	"Paul E. McKenney" <paulmck@linux.vnet.ibm.com>
M:	Josh Triplett <josh@joshtriplett.org>
R:	Steven Rostedt <rostedt@goodmis.org>
R:	Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
L:	linux-kernel@vger.kernel.org
W:	http://www.rdrop.com/users/paulmck/RCU/
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git
F:	include/linux/srcu.h
F:	kernel/rcu/srcu.c

SERIAL LOW-POWER INTER-CHIP MEDIA BUS (SLIMbus)
M:	Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/slimbus/
F:	Documentation/devicetree/bindings/slimbus/
F:	include/linux/slimbus.h

SMACK SECURITY MODULE
M:	Casey Schaufler <casey@schaufler-ca.com>
L:	linux-security-module@vger.kernel.org
W:	http://schaufler-ca.com
T:	git git://github.com/cschaufler/smack-next
S:	Maintained
F:	Documentation/admin-guide/LSM/Smack.rst
F:	security/smack/

SMC91x ETHERNET DRIVER
M:	Nicolas Pitre <nico@fluxnic.net>
S:	Odd Fixes
F:	drivers/net/ethernet/smsc/smc91x.*

SMIA AND SMIA++ IMAGE SENSOR DRIVER
M:	Sakari Ailus <sakari.ailus@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/smiapp/
F:	include/media/i2c/smiapp.h
F:	drivers/media/i2c/smiapp-pll.c
F:	drivers/media/i2c/smiapp-pll.h
F:	include/uapi/linux/smiapp.h
F:	Documentation/devicetree/bindings/media/i2c/nokia,smia.txt

SMM665 HARDWARE MONITOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/smm665
F:	drivers/hwmon/smm665.c

SMSC EMC2103 HARDWARE MONITOR DRIVER
M:	Steve Glendinning <steve.glendinning@shawell.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/emc2103
F:	drivers/hwmon/emc2103.c

SMSC SCH5627 HARDWARE MONITOR DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-hwmon@vger.kernel.org
S:	Supported
F:	Documentation/hwmon/sch5627
F:	drivers/hwmon/sch5627.c

SMSC UFX6000 and UFX7000 USB to VGA DRIVER
M:	Steve Glendinning <steve.glendinning@shawell.net>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	drivers/video/fbdev/smscufx.c

SMSC47B397 HARDWARE MONITOR DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/smsc47b397
F:	drivers/hwmon/smsc47b397.c

SMSC911x ETHERNET DRIVER
M:	Steve Glendinning <steve.glendinning@shawell.net>
L:	netdev@vger.kernel.org
S:	Maintained
F:	include/linux/smsc911x.h
F:	drivers/net/ethernet/smsc/smsc911x.*

SMSC9420 PCI ETHERNET DRIVER
M:	Steve Glendinning <steve.glendinning@shawell.net>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/smsc/smsc9420.*

SOC-CAMERA V4L2 SUBSYSTEM
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Orphan
F:	include/media/soc*
F:	drivers/media/i2c/soc_camera/
F:	drivers/media/platform/soc_camera/

SOCIONEXT SYNQUACER I2C DRIVER
M:	Ard Biesheuvel <ard.biesheuvel@linaro.org>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	drivers/i2c/busses/i2c-synquacer.c
F:	Documentation/devicetree/bindings/i2c/i2c-synquacer.txt

SOCIONEXT UNIPHIER SOUND DRIVER
M:	Katsuhiro Suzuki <suzuki.katsuhiro@socionext.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	sound/soc/uniphier/

SOEKRIS NET48XX LED SUPPORT
M:	Chris Boot <bootc@bootc.net>
S:	Maintained
F:	drivers/leds/leds-net48xx.c

SOFT-ROCE DRIVER (rxe)
M:	Moni Shoua <monis@mellanox.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
W:	https://github.com/SoftRoCE/rxe-dev/wiki/rxe-dev:-Home
Q:	http://patchwork.kernel.org/project/linux-rdma/list/
F:	drivers/infiniband/sw/rxe/
F:	include/uapi/rdma/rdma_user_rxe.h

SOFTLOGIC 6x10 MPEG CODEC
M:	Bluecherry Maintainers <maintainers@bluecherrydvr.com>
M:	Anton Sviridenko <anton@corp.bluecherry.net>
M:	Andrey Utkin <andrey.utkin@corp.bluecherry.net>
M:	Andrey Utkin <andrey_utkin@fastmail.com>
M:	Ismael Luceno <ismael@iodev.co.uk>
L:	linux-media@vger.kernel.org
S:	Supported
F:	drivers/media/pci/solo6x10/

SOFTWARE DELEGATED EXCEPTION INTERFACE (SDEI)
M:	James Morse <james.morse@arm.com>
L:	linux-arm-kernel@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/arm/firmware/sdei.txt
F:	drivers/firmware/arm_sdei.c
F:	include/linux/sdei.h
F:	include/uapi/linux/sdei.h

SOFTWARE RAID (Multiple Disks) SUPPORT
M:	Shaohua Li <shli@kernel.org>
L:	linux-raid@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/shli/md.git
S:	Supported
F:	drivers/md/Makefile
F:	drivers/md/Kconfig
F:	drivers/md/md*
F:	drivers/md/raid*
F:	include/linux/raid/
F:	include/uapi/linux/raid/

SOCIONEXT (SNI) NETSEC NETWORK DRIVER
M:	Jassi Brar <jaswinder.singh@linaro.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/socionext/netsec.c
F:	Documentation/devicetree/bindings/net/socionext-netsec.txt

SOLIDRUN CLEARFOG SUPPORT
M:	Russell King <linux@armlinux.org.uk>
S:	Maintained
F:	arch/arm/boot/dts/armada-388-clearfog*
F:	arch/arm/boot/dts/armada-38x-solidrun-*

SOLIDRUN CUBOX-I/HUMMINGBOARD SUPPORT
M:	Russell King <linux@armlinux.org.uk>
S:	Maintained
F:	arch/arm/boot/dts/imx6*-cubox-i*
F:	arch/arm/boot/dts/imx6*-hummingboard*
F:	arch/arm/boot/dts/imx6*-sr-*

SONIC NETWORK DRIVER
M:	Thomas Bogendoerfer <tsbogend@alpha.franken.de>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/natsemi/sonic.*

SONICS SILICON BACKPLANE DRIVER (SSB)
M:	Michael Buesch <m@bues.ch>
L:	linux-wireless@vger.kernel.org
S:	Maintained
F:	drivers/ssb/
F:	include/linux/ssb/

SONY IMX258 SENSOR DRIVER
M:	Sakari Ailus <sakari.ailus@linux.intel.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/imx258.c

SONY IMX274 SENSOR DRIVER
M:	Leon Luo <leonl@leopardimaging.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/i2c/imx274.c
F:	Documentation/devicetree/bindings/media/i2c/imx274.txt

SONY MEMORYSTICK CARD SUPPORT
M:	Alex Dubov <oakad@yahoo.com>
W:	http://tifmxx.berlios.de/
S:	Maintained
F:	drivers/memstick/host/tifm_ms.c

SONY MEMORYSTICK STANDARD SUPPORT
M:	Maxim Levitsky <maximlevitsky@gmail.com>
S:	Maintained
F:	drivers/memstick/core/ms_block.*

SONY VAIO CONTROL DEVICE DRIVER
M:	Mattia Dongili <malattia@linux.it>
L:	platform-driver-x86@vger.kernel.org
W:	http://www.linux.it/~malattia/wiki/index.php/Sony_drivers
S:	Maintained
F:	Documentation/laptops/sony-laptop.txt
F:	drivers/char/sonypi.c
F:	drivers/platform/x86/sony-laptop.c
F:	include/linux/sony-laptop.h

SOUND
M:	Jaroslav Kysela <perex@perex.cz>
M:	Takashi Iwai <tiwai@suse.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
W:	http://www.alsa-project.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git
T:	git git://git.alsa-project.org/alsa-kernel.git
Q:	http://patchwork.kernel.org/project/alsa-devel/list/
S:	Maintained
F:	Documentation/sound/
F:	include/sound/
F:	include/uapi/sound/
F:	sound/

SOUND - COMPRESSED AUDIO
M:	Vinod Koul <vkoul@kernel.org>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git
S:	Supported
F:	Documentation/sound/alsa/compress_offload.txt
F:	include/sound/compress_driver.h
F:	include/uapi/sound/compress_*
F:	sound/core/compress_offload.c
F:	sound/soc/soc-compress.c

SOUND - DMAENGINE HELPERS
M:	Lars-Peter Clausen <lars@metafoo.de>
S:	Supported
F:	include/sound/dmaengine_pcm.h
F:	sound/core/pcm_dmaengine.c
F:	sound/soc/soc-generic-dmaengine-pcm.c

SOUND - SOC LAYER / DYNAMIC AUDIO POWER MANAGEMENT (ASoC)
M:	Liam Girdwood <lgirdwood@gmail.com>
M:	Mark Brown <broonie@kernel.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound.git
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
W:	http://alsa-project.org/main/index.php/ASoC
S:	Supported
F:	Documentation/devicetree/bindings/sound/
F:	Documentation/sound/alsa/soc/
F:	sound/soc/
F:	include/sound/soc*

SOUNDWIRE SUBSYSTEM
M:	Vinod Koul <vinod.koul@intel.com>
M:	Sanyog Kale <sanyog.r.kale@intel.com>
R:	Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Supported
F:	Documentation/driver-api/soundwire/
F:	drivers/soundwire/
F:	include/linux/soundwire/

SP2 MEDIA DRIVER
M:	Olli Salonen <olli.salonen@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
S:	Maintained
F:	drivers/media/dvb-frontends/sp2*

SPARC + UltraSPARC (sparc/sparc64)
M:	"David S. Miller" <davem@davemloft.net>
L:	sparclinux@vger.kernel.org
Q:	http://patchwork.ozlabs.org/project/sparclinux/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-next.git
S:	Maintained
F:	arch/sparc/
F:	drivers/sbus/

SPARC SERIAL DRIVERS
M:	"David S. Miller" <davem@davemloft.net>
L:	sparclinux@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-next.git
S:	Maintained
F:	include/linux/sunserialcore.h
F:	drivers/tty/serial/suncore.c
F:	drivers/tty/serial/sunhv.c
F:	drivers/tty/serial/sunsab.c
F:	drivers/tty/serial/sunsab.h
F:	drivers/tty/serial/sunsu.c
F:	drivers/tty/serial/sunzilog.c
F:	drivers/tty/serial/sunzilog.h
F:	drivers/tty/vcc.c

SPARSE CHECKER
M:	"Christopher Li" <sparse@chrisli.org>
L:	linux-sparse@vger.kernel.org
W:	https://sparse.wiki.kernel.org/
T:	git git://git.kernel.org/pub/scm/devel/sparse/sparse.git
T:	git git://git.kernel.org/pub/scm/devel/sparse/chrisl/sparse.git
S:	Maintained
F:	include/linux/compiler.h

SPEAR CLOCK FRAMEWORK SUPPORT
M:	Viresh Kumar <vireshk@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.st.com/spear
S:	Maintained
F:	drivers/clk/spear/

SPEAR PLATFORM SUPPORT
M:	Viresh Kumar <vireshk@kernel.org>
M:	Shiraz Hashim <shiraz.linux.kernel@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W:	http://www.st.com/spear
S:	Maintained
F:	arch/arm/boot/dts/spear*
F:	arch/arm/mach-spear/

SPI NOR SUBSYSTEM
M:	Marek Vasut <marek.vasut@gmail.com>
L:	linux-mtd@lists.infradead.org
W:	http://www.linux-mtd.infradead.org/
Q:	http://patchwork.ozlabs.org/project/linux-mtd/list/
T:	git git://git.infradead.org/linux-mtd.git spi-nor/fixes
T:	git git://git.infradead.org/linux-mtd.git spi-nor/next
S:	Maintained
F:	drivers/mtd/spi-nor/
F:	include/linux/mtd/spi-nor.h

SPI SUBSYSTEM
M:	Mark Brown <broonie@kernel.org>
L:	linux-spi@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/broonie/spi.git
Q:	http://patchwork.kernel.org/project/spi-devel-general/list/
S:	Maintained
F:	Documentation/devicetree/bindings/spi/
F:	Documentation/spi/
F:	drivers/spi/
F:	include/linux/spi/
F:	include/uapi/linux/spi/
F:	tools/spi/

SPIDERNET NETWORK DRIVER for CELL
M:	Ishizaki Kou <kou.ishizaki@toshiba.co.jp>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/spider_net.txt
F:	drivers/net/ethernet/toshiba/spider_net*

SPMI SUBSYSTEM
R:	Stephen Boyd <sboyd@kernel.org>
L:	linux-arm-msm@vger.kernel.org
F:	Documentation/devicetree/bindings/spmi/
F:	drivers/spmi/
F:	include/dt-bindings/spmi/spmi.h
F:	include/linux/spmi.h
F:	include/trace/events/spmi.h

SPU FILE SYSTEM
M:	Jeremy Kerr <jk@ozlabs.org>
L:	linuxppc-dev@lists.ozlabs.org
W:	http://www.ibm.com/developerworks/power/cell/
S:	Supported
F:	Documentation/filesystems/spufs.txt
F:	arch/powerpc/platforms/cell/spufs/

SQUASHFS FILE SYSTEM
M:	Phillip Lougher <phillip@squashfs.org.uk>
L:	squashfs-devel@lists.sourceforge.net (subscribers-only)
W:	http://squashfs.org.uk
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pkl/squashfs-next.git
S:	Maintained
F:	Documentation/filesystems/squashfs.txt
F:	fs/squashfs/

SRM (Alpha) environment access
M:	Jan-Benedict Glaw <jbglaw@lug-owl.de>
S:	Maintained
F:	arch/alpha/kernel/srm_env.c

ST STM32 I2C/SMBUS DRIVER
M:	Pierre-Yves MORDRET <pierre-yves.mordret@st.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	drivers/i2c/busses/i2c-stm32*

STABLE BRANCH
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
L:	stable@vger.kernel.org
S:	Supported
F:	Documentation/process/stable-kernel-rules.rst

STAGING - COMEDI
M:	Ian Abbott <abbotti@mev.co.uk>
M:	H Hartley Sweeten <hsweeten@visionengravers.com>
S:	Odd Fixes
F:	drivers/staging/comedi/

STAGING - FLARION FT1000 DRIVERS
M:	Marek Belisko <marek.belisko@gmail.com>
S:	Odd Fixes
F:	drivers/staging/ft1000/

STAGING - INDUSTRIAL IO
M:	Jonathan Cameron <jic23@kernel.org>
L:	linux-iio@vger.kernel.org
S:	Odd Fixes
F:	Documentation/devicetree/bindings/staging/iio/
F:	drivers/staging/iio/

STAGING - NVIDIA COMPLIANT EMBEDDED CONTROLLER INTERFACE (nvec)
M:	Marc Dietrich <marvin24@gmx.de>
L:	ac100@lists.launchpad.net (moderated for non-subscribers)
L:	linux-tegra@vger.kernel.org
S:	Maintained
F:	drivers/staging/nvec/

STAGING - OLPC SECONDARY DISPLAY CONTROLLER (DCON)
M:	Jens Frederich <jfrederich@gmail.com>
M:	Daniel Drake <dsd@laptop.org>
M:	Jon Nettleton <jon.nettleton@gmail.com>
W:	http://wiki.laptop.org/go/DCON
S:	Maintained
F:	drivers/staging/olpc_dcon/

STAGING - REALTEK RTL8712U DRIVERS
M:	Larry Finger <Larry.Finger@lwfinger.net>
M:	Florian Schilhabel <florian.c.schilhabel@googlemail.com>.
S:	Odd Fixes
F:	drivers/staging/rtl8712/

STAGING - SILICON MOTION SM750 FRAME BUFFER DRIVER
M:	Sudip Mukherjee <sudipm.mukherjee@gmail.com>
M:	Teddy Wang <teddy.wang@siliconmotion.com>
M:	Sudip Mukherjee <sudip.mukherjee@codethink.co.uk>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	drivers/staging/sm750fb/

STAGING - SPEAKUP CONSOLE SPEECH DRIVER
M:	William Hubbs <w.d.hubbs@gmail.com>
M:	Chris Brannon <chris@the-brannons.com>
M:	Kirk Reiser <kirk@reisers.ca>
M:	Samuel Thibault <samuel.thibault@ens-lyon.org>
L:	speakup@linux-speakup.org
W:	http://www.linux-speakup.org/
S:	Odd Fixes
F:	drivers/staging/speakup/

STAGING - VIA VT665X DRIVERS
M:	Forest Bond <forest@alittletooquiet.net>
S:	Odd Fixes
F:	drivers/staging/vt665?/

STAGING - WILC1000 WIFI DRIVER
M:	Aditya Shankar <aditya.shankar@microchip.com>
M:	Ganesh Krishna <ganesh.krishna@microchip.com>
L:	linux-wireless@vger.kernel.org
S:	Supported
F:	drivers/staging/wilc1000/

STAGING - XGI Z7,Z9,Z11 PCI DISPLAY DRIVER
M:	Arnaud Patard <arnaud.patard@rtp-net.org>
S:	Odd Fixes
F:	drivers/staging/xgifb/

STAGING SUBSYSTEM
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging.git
L:	devel@driverdev.osuosl.org
S:	Supported
F:	drivers/staging/

STARFIRE/DURALAN NETWORK DRIVER
M:	Ion Badulescu <ionut@badula.org>
S:	Odd Fixes
F:	drivers/net/ethernet/adaptec/starfire*

STEC S1220 SKD DRIVER
M:	Bart Van Assche <bart.vanassche@wdc.com>
L:	linux-block@vger.kernel.org
S:	Maintained
F:	drivers/block/skd*[ch]

STI CEC DRIVER
M:	Benjamin Gaignard <benjamin.gaignard@linaro.org>
S:	Maintained
F:	drivers/staging/media/st-cec/
F:	Documentation/devicetree/bindings/media/stih-cec.txt

STK1160 USB VIDEO CAPTURE DRIVER
M:	Ezequiel Garcia <ezequiel@vanguardiasur.com.ar>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/usb/stk1160/

STM32 TIMER/LPTIMER DRIVERS
M:	Fabrice Gasnier <fabrice.gasnier@st.com>
S:	Maintained
F:	drivers/*/stm32-*timer*
F:	drivers/pwm/pwm-stm32*
F:	include/linux/*/stm32-*tim*
F:	Documentation/ABI/testing/*timer-stm32
F:	Documentation/devicetree/bindings/*/stm32-*timer
F:	Documentation/devicetree/bindings/pwm/pwm-stm32*

STMMAC ETHERNET DRIVER
M:	Giuseppe Cavallaro <peppe.cavallaro@st.com>
M:	Alexandre Torgue <alexandre.torgue@st.com>
M:	Jose Abreu <joabreu@synopsys.com>
L:	netdev@vger.kernel.org
W:	http://www.stlinux.com
S:	Supported
F:	drivers/net/ethernet/stmicro/stmmac/

SUN3/3X
M:	Sam Creasey <sammy@sammy.net>
W:	http://sammy.net/sun3/
S:	Maintained
F:	arch/m68k/kernel/*sun3*
F:	arch/m68k/sun3*/
F:	arch/m68k/include/asm/sun3*
F:	drivers/net/ethernet/i825xx/sun3*

SUN4I LOW RES ADC ATTACHED TABLET KEYS DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/input/sun4i-lradc-keys.txt
F:	drivers/input/keyboard/sun4i-lradc-keys.c

SUNDANCE NETWORK DRIVER
M:	Denis Kirjanov <kda@linux-powerpc.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/dlink/sundance.c

SUPERH
M:	Yoshinori Sato <ysato@users.sourceforge.jp>
M:	Rich Felker <dalias@libc.org>
L:	linux-sh@vger.kernel.org
Q:	http://patchwork.kernel.org/project/linux-sh/list/
S:	Maintained
F:	Documentation/sh/
F:	arch/sh/
F:	drivers/sh/

SUSPEND TO RAM
M:	"Rafael J. Wysocki" <rjw@rjwysocki.net>
M:	Len Brown <len.brown@intel.com>
M:	Pavel Machek <pavel@ucw.cz>
L:	linux-pm@vger.kernel.org
B:	https://bugzilla.kernel.org
S:	Supported
F:	Documentation/power/
F:	arch/x86/kernel/acpi/
F:	drivers/base/power/
F:	kernel/power/
F:	include/linux/suspend.h
F:	include/linux/freezer.h
F:	include/linux/pm.h

SVGA HANDLING
M:	Martin Mares <mj@ucw.cz>
L:	linux-video@atrey.karlin.mff.cuni.cz
S:	Maintained
F:	Documentation/svga.txt
F:	arch/x86/boot/video*

SWIOTLB SUBSYSTEM
M:	Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
L:	iommu@lists.linux-foundation.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/konrad/swiotlb.git
S:	Supported
F:	lib/swiotlb.c
F:	arch/*/kernel/pci-swiotlb.c
F:	include/linux/swiotlb.h

SWITCHDEV
M:	Jiri Pirko <jiri@resnulli.us>
M:	Ivan Vecera <ivecera@redhat.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	net/switchdev/
F:	include/net/switchdev.h

SY8106A REGULATOR DRIVER
M:	Icenowy Zheng <icenowy@aosc.io>
S:	Maintained
F:	drivers/regulator/sy8106a-regulator.c
F:	Documentation/devicetree/bindings/regulator/sy8106a-regulator.txt

SYNC FILE FRAMEWORK
M:	Sumit Semwal <sumit.semwal@linaro.org>
R:	Gustavo Padovan <gustavo@padovan.org>
S:	Maintained
L:	linux-media@vger.kernel.org
L:	dri-devel@lists.freedesktop.org
F:	drivers/dma-buf/sync_*
F:	drivers/dma-buf/dma-fence*
F:	drivers/dma-buf/sw_sync.c
F:	include/linux/sync_file.h
F:	include/uapi/linux/sync_file.h
F:	Documentation/sync_file.txt
T:	git git://anongit.freedesktop.org/drm/drm-misc

SYNOPSYS ARC ARCHITECTURE
M:	Vineet Gupta <vgupta@synopsys.com>
L:	linux-snps-arc@lists.infradead.org
S:	Supported
F:	arch/arc/
F:	Documentation/devicetree/bindings/arc/*
F:	Documentation/devicetree/bindings/interrupt-controller/snps,arc*
F:	drivers/clocksource/arc_timer.c
F:	drivers/tty/serial/arc_uart.c
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/vgupta/arc.git

SYNOPSYS ARC HSDK SDP pll clock driver
M:	Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
S:	Supported
F:	drivers/clk/clk-hsdk-pll.c
F:	Documentation/devicetree/bindings/clock/snps,hsdk-pll-clock.txt

SYNOPSYS ARC SDP clock driver
M:	Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
S:	Supported
F:	drivers/clk/axs10x/*
F:	Documentation/devicetree/bindings/clock/snps,pll-clock.txt

SYNOPSYS ARC SDP platform support
M:	Alexey Brodkin <abrodkin@synopsys.com>
S:	Supported
F:	arch/arc/plat-axs10x
F:	arch/arc/boot/dts/ax*
F:	Documentation/devicetree/bindings/arc/axs10*

SYNOPSYS AXS10x RESET CONTROLLER DRIVER
M:	Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
S:	Supported
F:	drivers/reset/reset-axs10x.c
F:	Documentation/devicetree/bindings/reset/snps,axs10x-reset.txt

SYNOPSYS DESIGNWARE 8250 UART DRIVER
R:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
S:	Maintained
F:	drivers/tty/serial/8250/8250_dw.c

SYNOPSYS DESIGNWARE APB GPIO DRIVER
M:	Hoan Tran <hotran@apm.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-dwapb.c
F:	Documentation/devicetree/bindings/gpio/snps-dwapb-gpio.txt

SYNOPSYS DESIGNWARE AXI DMAC DRIVER
M:	Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
S:	Maintained
F:	drivers/dma/dwi-axi-dmac/
F:	Documentation/devicetree/bindings/dma/snps,dw-axi-dmac.txt

SYNOPSYS DESIGNWARE DMAC DRIVER
M:	Viresh Kumar <vireshk@kernel.org>
R:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
S:	Maintained
F:	include/linux/dma/dw.h
F:	include/linux/platform_data/dma-dw.h
F:	drivers/dma/dw/

SYNOPSYS DESIGNWARE ENTERPRISE ETHERNET DRIVER
M:	Jose Abreu <Jose.Abreu@synopsys.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/synopsys/

SYNOPSYS DESIGNWARE I2C DRIVER
M:	Jarkko Nikula <jarkko.nikula@linux.intel.com>
R:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
R:	Mika Westerberg <mika.westerberg@linux.intel.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	drivers/i2c/busses/i2c-designware-*
F:	include/linux/platform_data/i2c-designware.h

SYNOPSYS DESIGNWARE MMC/SD/SDIO DRIVER
M:	Jaehoon Chung <jh80.chung@samsung.com>
L:	linux-mmc@vger.kernel.org
S:	Maintained
F:	drivers/mmc/host/dw_mmc*

SYNOPSYS HSDK RESET CONTROLLER DRIVER
M:	Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
S:	Supported
F:	drivers/reset/reset-hsdk.c
F:	include/dt-bindings/reset/snps,hsdk-reset.h
F:	Documentation/devicetree/bindings/reset/snps,hsdk-reset.txt

SYSTEM CONFIGURATION (SYSCON)
M:	Lee Jones <lee.jones@linaro.org>
M:	Arnd Bergmann <arnd@arndb.de>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd.git
S:	Supported
F:	drivers/mfd/syscon.c

SYSTEM CONTROL & POWER/MANAGEMENT INTERFACE (SCPI/SCMI) Message Protocol drivers
M:	Sudeep Holla <sudeep.holla@arm.com>
L:	linux-arm-kernel@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/arm/arm,sc[mp]i.txt
F:	drivers/clk/clk-sc[mp]i.c
F:	drivers/cpufreq/sc[mp]i-cpufreq.c
F:	drivers/firmware/arm_scpi.c
F:	drivers/firmware/arm_scmi/
F:	include/linux/sc[mp]i_protocol.h

SYSTEM RESET/SHUTDOWN DRIVERS
M:	Sebastian Reichel <sre@kernel.org>
L:	linux-pm@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sre/linux-power-supply.git
S:	Maintained
F:	Documentation/devicetree/bindings/power/reset/
F:	drivers/power/reset/

SYSTEM TRACE MODULE CLASS
M:	Alexander Shishkin <alexander.shishkin@linux.intel.com>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ash/stm.git
F:	Documentation/trace/stm.txt
F:	drivers/hwtracing/stm/
F:	include/linux/stm.h
F:	include/uapi/linux/stm.h

SYSV FILESYSTEM
M:	Christoph Hellwig <hch@infradead.org>
S:	Maintained
F:	Documentation/filesystems/sysv-fs.txt
F:	fs/sysv/
F:	include/linux/sysv_fs.h

TARGET SUBSYSTEM
M:	"Nicholas A. Bellinger" <nab@linux-iscsi.org>
L:	linux-scsi@vger.kernel.org
L:	target-devel@vger.kernel.org
W:	http://www.linux-iscsi.org
W:	http://groups.google.com/group/linux-iscsi-target-dev
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending.git master
S:	Supported
F:	drivers/target/
F:	include/target/
F:	Documentation/target/

TASKSTATS STATISTICS INTERFACE
M:	Balbir Singh <bsingharora@gmail.com>
S:	Maintained
F:	Documentation/accounting/taskstats*
F:	include/linux/taskstats*
F:	kernel/taskstats.c

TC subsystem
M:	Jamal Hadi Salim <jhs@mojatatu.com>
M:	Cong Wang <xiyou.wangcong@gmail.com>
M:	Jiri Pirko <jiri@resnulli.us>
L:	netdev@vger.kernel.org
S:	Maintained
F:	include/net/pkt_cls.h
F:	include/net/pkt_sched.h
F:	include/net/tc_act/
F:	include/uapi/linux/pkt_cls.h
F:	include/uapi/linux/pkt_sched.h
F:	include/uapi/linux/tc_act/
F:	include/uapi/linux/tc_ematch/
F:	net/sched/

TCP LOW PRIORITY MODULE
M:	"Wong Hoi Sing, Edison" <hswong3i@gmail.com>
M:	"Hung Hing Lun, Mike" <hlhung3i@gmail.com>
W:	http://tcp-lp-mod.sourceforge.net/
S:	Maintained
F:	net/ipv4/tcp_lp.c

TDA10071 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/dvb-frontends/tda10071*

TDA18212 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/tuners/tda18212*

TDA18218 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/tuners/tda18218*

TDA18250 MEDIA DRIVER
M:	Olli Salonen <olli.salonen@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/tuners/tda18250*

TDA18271 MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://github.com/mkrufky
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/mkrufky/tuners.git
S:	Maintained
F:	drivers/media/tuners/tda18271*

TDA1997x MEDIA DRIVER
M:	Tim Harvey <tharvey@gateworks.com>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
S:	Maintained
F:	drivers/media/i2c/tda1997x.*

TDA827x MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://github.com/mkrufky
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/mkrufky/tuners.git
S:	Maintained
F:	drivers/media/tuners/tda8290.*

TDA8290 MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://github.com/mkrufky
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/mkrufky/tuners.git
S:	Maintained
F:	drivers/media/tuners/tda8290.*

TDA9840 MEDIA DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/i2c/tda9840*

TEA5761 TUNER DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Odd fixes
F:	drivers/media/tuners/tea5761.*

TEA5767 TUNER DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/tuners/tea5767.*

TEA6415C MEDIA DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/i2c/tea6415c*

TEA6420 MEDIA DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/i2c/tea6420*

TEAM DRIVER
M:	Jiri Pirko <jiri@resnulli.us>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/team/
F:	include/linux/if_team.h
F:	include/uapi/linux/if_team.h

TECHNOLOGIC SYSTEMS TS-5500 PLATFORM SUPPORT
M:	"Savoir-faire Linux Inc." <kernel@savoirfairelinux.com>
S:	Maintained
F:	arch/x86/platform/ts5500/

TECHNOTREND USB IR RECEIVER
M:	Sean Young <sean@mess.org>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/rc/ttusbir.c

TECHWELL TW9910 VIDEO DECODER
L:	linux-media@vger.kernel.org
S:	Orphan
F:	drivers/media/i2c/tw9910.c
F:	include/media/i2c/tw9910.h

TEE SUBSYSTEM
M:	Jens Wiklander <jens.wiklander@linaro.org>
S:	Maintained
F:	include/linux/tee_drv.h
F:	include/uapi/linux/tee.h
F:	drivers/tee/
F:	Documentation/tee.txt

TEGRA ARCHITECTURE SUPPORT
M:	Thierry Reding <thierry.reding@gmail.com>
M:	Jonathan Hunter <jonathanh@nvidia.com>
L:	linux-tegra@vger.kernel.org
Q:	http://patchwork.ozlabs.org/project/linux-tegra/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tegra/linux.git
S:	Supported
N:	[^a-z]tegra

TEGRA CLOCK DRIVER
M:	Peter De Schrijver <pdeschrijver@nvidia.com>
M:	Prashant Gaikwad <pgaikwad@nvidia.com>
S:	Supported
F:	drivers/clk/tegra/

TEGRA DMA DRIVERS
M:	Laxman Dewangan <ldewangan@nvidia.com>
M:	Jon Hunter <jonathanh@nvidia.com>
S:	Supported
F:	drivers/dma/tegra*

TEGRA I2C DRIVER
M:	Laxman Dewangan <ldewangan@nvidia.com>
S:	Supported
F:	drivers/i2c/busses/i2c-tegra.c

TEGRA IOMMU DRIVERS
M:	Thierry Reding <thierry.reding@gmail.com>
L:	linux-tegra@vger.kernel.org
S:	Supported
F:	drivers/iommu/tegra*

TEGRA KBC DRIVER
M:	Laxman Dewangan <ldewangan@nvidia.com>
S:	Supported
F:	drivers/input/keyboard/tegra-kbc.c

TEGRA PWM DRIVER
M:	Thierry Reding <thierry.reding@gmail.com>
S:	Supported
F:	drivers/pwm/pwm-tegra.c

TEGRA SERIAL DRIVER
M:	Laxman Dewangan <ldewangan@nvidia.com>
S:	Supported
F:	drivers/tty/serial/serial-tegra.c

TEGRA SPI DRIVER
M:	Laxman Dewangan <ldewangan@nvidia.com>
S:	Supported
F:	drivers/spi/spi-tegra*

TEHUTI ETHERNET DRIVER
M:	Andy Gospodarek <andy@greyhouse.net>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/tehuti/*

Telecom Clock Driver for MCPL0010
M:	Mark Gross <mark.gross@intel.com>
S:	Supported
F:	drivers/char/tlclk.c

TENSILICA XTENSA PORT (xtensa)
M:	Chris Zankel <chris@zankel.net>
M:	Max Filippov <jcmvbkbc@gmail.com>
L:	linux-xtensa@linux-xtensa.org
T:	git git://github.com/czankel/xtensa-linux.git
S:	Maintained
F:	arch/xtensa/
F:	drivers/irqchip/irq-xtensa-*

Texas Instruments' System Control Interface (TISCI) Protocol Driver
M:	Nishanth Menon <nm@ti.com>
M:	Tero Kristo <t-kristo@ti.com>
M:	Santosh Shilimkar <ssantosh@kernel.org>
L:	linux-arm-kernel@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/arm/keystone/ti,sci.txt
F:	drivers/firmware/ti_sci*
F:	include/linux/soc/ti/ti_sci_protocol.h
F:	Documentation/devicetree/bindings/soc/ti/sci-pm-domain.txt
F:	include/dt-bindings/genpd/k2g.h
F:	drivers/soc/ti/ti_sci_pm_domains.c
F:	Documentation/devicetree/bindings/reset/ti,sci-reset.txt
F:	Documentation/devicetree/bindings/clock/ti,sci-clk.txt
F:	drivers/clk/keystone/sci-clk.c
F:	drivers/reset/reset-ti-sci.c

THANKO'S RAREMONO AM/FM/SW RADIO RECEIVER USB DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/radio/radio-raremono.c

THERMAL
M:	Zhang Rui <rui.zhang@intel.com>
M:	Eduardo Valentin <edubezval@gmail.com>
L:	linux-pm@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rzhang/linux.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/evalenti/linux-soc-thermal.git
Q:	https://patchwork.kernel.org/project/linux-pm/list/
S:	Supported
F:	drivers/thermal/
F:	include/linux/thermal.h
F:	include/uapi/linux/thermal.h
F:	include/linux/cpu_cooling.h
F:	Documentation/devicetree/bindings/thermal/

THERMAL/CPU_COOLING
M:	Amit Daniel Kachhap <amit.kachhap@gmail.com>
M:	Viresh Kumar <viresh.kumar@linaro.org>
M:	Javi Merino <javi.merino@kernel.org>
L:	linux-pm@vger.kernel.org
S:	Supported
F:	Documentation/thermal/cpu-cooling-api.txt
F:	drivers/thermal/cpu_cooling.c
F:	include/linux/cpu_cooling.h

THINKPAD ACPI EXTRAS DRIVER
M:	Henrique de Moraes Holschuh <ibm-acpi@hmh.eng.br>
L:	ibm-acpi-devel@lists.sourceforge.net
L:	platform-driver-x86@vger.kernel.org
W:	http://ibm-acpi.sourceforge.net
W:	http://thinkwiki.org/wiki/Ibm-acpi
T:	git git://repo.or.cz/linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git
S:	Maintained
F:	drivers/platform/x86/thinkpad_acpi.c

THUNDERBOLT DRIVER
M:	Andreas Noever <andreas.noever@gmail.com>
M:	Michael Jamet <michael.jamet@intel.com>
M:	Mika Westerberg <mika.westerberg@linux.intel.com>
M:	Yehezkel Bernat <YehezkelShB@gmail.com>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/westeri/thunderbolt.git
S:	Maintained
F:	Documentation/admin-guide/thunderbolt.rst
F:	drivers/thunderbolt/
F:	include/linux/thunderbolt.h

THUNDERBOLT NETWORK DRIVER
M:	Michael Jamet <michael.jamet@intel.com>
M:	Mika Westerberg <mika.westerberg@linux.intel.com>
M:	Yehezkel Bernat <YehezkelShB@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/thunderbolt.c

THUNDERX GPIO DRIVER
M:	David Daney <david.daney@cavium.com>
S:	Maintained
F:	drivers/gpio/gpio-thunderx.c

TI AM437X VPFE DRIVER
M:	"Lad, Prabhakar" <prabhakar.csengg@gmail.com>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/mhadli/v4l-dvb-davinci_devices.git
S:	Maintained
F:	drivers/media/platform/am437x/

TI BANDGAP AND THERMAL DRIVER
M:	Eduardo Valentin <edubezval@gmail.com>
M:	Keerthy <j-keerthy@ti.com>
L:	linux-pm@vger.kernel.org
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	drivers/thermal/ti-soc-thermal/

TI BQ27XXX POWER SUPPLY DRIVER
R:	Andrew F. Davis <afd@ti.com>
F:	include/linux/power/bq27xxx_battery.h
F:	drivers/power/supply/bq27xxx_battery.c
F:	drivers/power/supply/bq27xxx_battery_i2c.c

TI CDCE706 CLOCK DRIVER
M:	Max Filippov <jcmvbkbc@gmail.com>
S:	Maintained
F:	drivers/clk/clk-cdce706.c

TI CLOCK DRIVER
M:	Tero Kristo <t-kristo@ti.com>
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	drivers/clk/ti/
F:	include/linux/clk/ti.h

TI DAVINCI MACHINE SUPPORT
M:	Sekhar Nori <nsekhar@ti.com>
M:	Kevin Hilman <khilman@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/nsekhar/linux-davinci.git
S:	Supported
F:	arch/arm/mach-davinci/
F:	drivers/i2c/busses/i2c-davinci.c
F:	arch/arm/boot/dts/da850*

TI DAVINCI SERIES CLOCK DRIVER
M:	David Lechner <david@lechnology.com>
R:	Sekhar Nori <nsekhar@ti.com>
S:	Maintained
F:	Documentation/devicetree/bindings/clock/ti/davinci/
F:	drivers/clk/davinci/

TI DAVINCI SERIES GPIO DRIVER
M:	Keerthy <j-keerthy@ti.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/gpio/gpio-davinci.txt
F:	drivers/gpio/gpio-davinci.c

TI DAVINCI SERIES MEDIA DRIVER
M:	"Lad, Prabhakar" <prabhakar.csengg@gmail.com>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/mhadli/v4l-dvb-davinci_devices.git
S:	Maintained
F:	drivers/media/platform/davinci/
F:	include/media/davinci/

TI ETHERNET SWITCH DRIVER (CPSW)
R:	Grygorii Strashko <grygorii.strashko@ti.com>
L:	linux-omap@vger.kernel.org
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/ti/cpsw*
F:	drivers/net/ethernet/ti/davinci*

TI FLASH MEDIA INTERFACE DRIVER
M:	Alex Dubov <oakad@yahoo.com>
S:	Maintained
F:	drivers/misc/tifm*
F:	drivers/mmc/host/tifm_sd.c
F:	include/linux/tifm.h

TI KEYSTONE MULTICORE NAVIGATOR DRIVERS
M:	Santosh Shilimkar <ssantosh@kernel.org>
L:	linux-kernel@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/soc/ti/*
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ssantosh/linux-keystone.git

TI LM49xxx FAMILY ASoC CODEC DRIVERS
M:	M R Swami Reddy <mr.swami.reddy@ti.com>
M:	Vishwas A Deshpande <vishwas.a.deshpande@ti.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	sound/soc/codecs/lm49453*
F:	sound/soc/codecs/isabelle*

TI LP855x BACKLIGHT DRIVER
M:	Milo Kim <milo.kim@ti.com>
S:	Maintained
F:	Documentation/backlight/lp855x-driver.txt
F:	drivers/video/backlight/lp855x_bl.c
F:	include/linux/platform_data/lp855x.h

TI LP8727 CHARGER DRIVER
M:	Milo Kim <milo.kim@ti.com>
S:	Maintained
F:	drivers/power/supply/lp8727_charger.c
F:	include/linux/platform_data/lp8727.h

TI LP8788 MFD DRIVER
M:	Milo Kim <milo.kim@ti.com>
S:	Maintained
F:	drivers/iio/adc/lp8788_adc.c
F:	drivers/leds/leds-lp8788.c
F:	drivers/mfd/lp8788*.c
F:	drivers/power/supply/lp8788-charger.c
F:	drivers/regulator/lp8788-*.c
F:	include/linux/mfd/lp8788*.h

TI NETCP ETHERNET DRIVER
M:	Wingman Kwok <w-kwok2@ti.com>
M:	Murali Karicheri <m-karicheri2@ti.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/ti/netcp*

TI TAS571X FAMILY ASoC CODEC DRIVER
M:	Kevin Cernekee <cernekee@chromium.org>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Odd Fixes
F:	sound/soc/codecs/tas571x*

TI TRF7970A NFC DRIVER
M:	Mark Greer <mgreer@animalcreek.com>
L:	linux-wireless@vger.kernel.org
L:	linux-nfc@lists.01.org (moderated for non-subscribers)
S:	Supported
F:	drivers/nfc/trf7970a.c
F:	Documentation/devicetree/bindings/net/nfc/trf7970a.txt

TI TWL4030 SERIES SOC CODEC DRIVER
M:	Peter Ujfalusi <peter.ujfalusi@ti.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	sound/soc/codecs/twl4030*

TI VPE/CAL DRIVERS
M:	Benoit Parrot <bparrot@ti.com>
L:	linux-media@vger.kernel.org
W:	http://linuxtv.org/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
S:	Maintained
F:	drivers/media/platform/ti-vpe/

TI WILINK WIRELESS DRIVERS
L:	linux-wireless@vger.kernel.org
W:	http://wireless.kernel.org/en/users/Drivers/wl12xx
W:	http://wireless.kernel.org/en/users/Drivers/wl1251
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/luca/wl12xx.git
S:	Orphan
F:	drivers/net/wireless/ti/
F:	include/linux/wl12xx.h

TIMEKEEPING, CLOCKSOURCE CORE, NTP, ALARMTIMER
M:	John Stultz <john.stultz@linaro.org>
M:	Thomas Gleixner <tglx@linutronix.de>
R:	Stephen Boyd <sboyd@kernel.org>
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/core
S:	Supported
F:	include/linux/clocksource.h
F:	include/linux/time.h
F:	include/linux/timex.h
F:	include/uapi/linux/time.h
F:	include/uapi/linux/timex.h
F:	kernel/time/clocksource.c
F:	kernel/time/time*.c
F:	kernel/time/alarmtimer.c
F:	kernel/time/ntp.c
F:	tools/testing/selftests/timers/

TIPC NETWORK LAYER
M:	Jon Maloy <jon.maloy@ericsson.com>
M:	Ying Xue <ying.xue@windriver.com>
L:	netdev@vger.kernel.org (core kernel code)
L:	tipc-discussion@lists.sourceforge.net (user apps, general discussion)
W:	http://tipc.sourceforge.net/
S:	Maintained
F:	include/uapi/linux/tipc*.h
F:	net/tipc/

TLAN NETWORK DRIVER
M:	Samuel Chessman <chessman@tux.org>
L:	tlan-devel@lists.sourceforge.net (subscribers-only)
W:	http://sourceforge.net/projects/tlan/
S:	Maintained
F:	Documentation/networking/tlan.txt
F:	drivers/net/ethernet/ti/tlan.*

TM6000 VIDEO4LINUX DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Odd fixes
F:	drivers/media/usb/tm6000/
F:	Documentation/media/v4l-drivers/tm6000*

TMIO/SDHI MMC DRIVER
M:	Wolfram Sang <wsa+renesas@sang-engineering.com>
L:	linux-mmc@vger.kernel.org
S:	Supported
F:	drivers/mmc/host/tmio_mmc*
F:	drivers/mmc/host/renesas_sdhi*
F:	include/linux/mfd/tmio.h

TMP401 HARDWARE MONITOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/tmp401
F:	drivers/hwmon/tmp401.c

TMPFS (SHMEM FILESYSTEM)
M:	Hugh Dickins <hughd@google.com>
L:	linux-mm@kvack.org
S:	Maintained
F:	include/linux/shmem_fs.h
F:	mm/shmem.c

TOMOYO SECURITY MODULE
M:	Kentaro Takeda <takedakn@nttdata.co.jp>
M:	Tetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp>
L:	tomoyo-dev-en@lists.sourceforge.jp (subscribers-only, for developers in English)
L:	tomoyo-users-en@lists.sourceforge.jp (subscribers-only, for users in English)
L:	tomoyo-dev@lists.sourceforge.jp (subscribers-only, for developers in Japanese)
L:	tomoyo-users@lists.sourceforge.jp (subscribers-only, for users in Japanese)
W:	http://tomoyo.sourceforge.jp/
T:	quilt http://svn.sourceforge.jp/svnroot/tomoyo/trunk/2.5.x/tomoyo-lsm/patches/
S:	Maintained
F:	security/tomoyo/

TOPSTAR LAPTOP EXTRAS DRIVER
M:	Herton Ronaldo Krzesinski <herton@canonical.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/topstar-laptop.c

TORTURE-TEST MODULES
M:	Davidlohr Bueso <dave@stgolabs.net>
M:	"Paul E. McKenney" <paulmck@linux.vnet.ibm.com>
M:	Josh Triplett <josh@joshtriplett.org>
L:	linux-kernel@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git
F:	Documentation/RCU/torture.txt
F:	kernel/torture.c
F:	kernel/rcu/rcutorture.c
F:	kernel/locking/locktorture.c

TOSHIBA ACPI EXTRAS DRIVER
M:	Azael Avalos <coproscefalo@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/toshiba_acpi.c

TOSHIBA BLUETOOTH DRIVER
M:	Azael Avalos <coproscefalo@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/toshiba_bluetooth.c

TOSHIBA HDD ACTIVE PROTECTION SENSOR DRIVER
M:	Azael Avalos <coproscefalo@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/toshiba_haps.c

TOSHIBA SMM DRIVER
M:	Jonathan Buzzard <jonathan@buzzard.org.uk>
W:	http://www.buzzard.org.uk/toshiba/
S:	Maintained
F:	drivers/char/toshiba.c
F:	include/linux/toshiba.h
F:	include/uapi/linux/toshiba.h

TOSHIBA TC358743 DRIVER
M:	Mats Randgaard <matrandg@cisco.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/tc358743*
F:	include/media/i2c/tc358743.h

TOSHIBA WMI HOTKEYS DRIVER
M:	Azael Avalos <coproscefalo@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/toshiba-wmi.c

TPM DEVICE DRIVER
M:	Peter Huewe <peterhuewe@gmx.de>
M:	Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com>
R:	Jason Gunthorpe <jgg@ziepe.ca>
L:	linux-integrity@vger.kernel.org
Q:	https://patchwork.kernel.org/project/linux-integrity/list/
W:	https://kernsec.org/wiki/index.php/Linux_Kernel_Integrity
T:	git git://git.infradead.org/users/jjs/linux-tpmdd.git
S:	Maintained
F:	drivers/char/tpm/

TRACING
M:	Steven Rostedt <rostedt@goodmis.org>
M:	Ingo Molnar <mingo@redhat.com>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git perf/core
S:	Maintained
F:	Documentation/trace/ftrace.txt
F:	arch/*/*/*/ftrace.h
F:	arch/*/kernel/ftrace.c
F:	include/*/ftrace.h
F:	include/linux/trace*.h
F:	include/trace/
F:	kernel/trace/
F:	tools/testing/selftests/ftrace/

TRACING MMIO ACCESSES (MMIOTRACE)
M:	Steven Rostedt <rostedt@goodmis.org>
M:	Ingo Molnar <mingo@kernel.org>
R:	Karol Herbst <karolherbst@gmail.com>
R:	Pekka Paalanen <ppaalanen@gmail.com>
S:	Maintained
L:	linux-kernel@vger.kernel.org
L:	nouveau@lists.freedesktop.org
F:	kernel/trace/trace_mmiotrace.c
F:	include/linux/mmiotrace.h
F:	arch/x86/mm/kmmio.c
F:	arch/x86/mm/mmio-mod.c
F:	arch/x86/mm/testmmiotrace.c

TRIVIAL PATCHES
M:	Jiri Kosina <trivial@kernel.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial.git
S:	Maintained
K:	^Subject:.*(?i)trivial

TEMPO SEMICONDUCTOR DRIVERS
M:	Steven Eckhoff <steven.eckhoff.opensource@gmail.com>
S:	Maintained
F:	sound/soc/codecs/tscs*.c
F:	sound/soc/codecs/tscs*.h
F:	Documentation/devicetree/bindings/sound/tscs*.txt

TTY LAYER
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
M:	Jiri Slaby <jslaby@suse.com>
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty.git
F:	Documentation/serial/
F:	drivers/tty/
F:	drivers/tty/serial/serial_core.c
F:	include/linux/serial_core.h
F:	include/linux/serial.h
F:	include/linux/tty.h
F:	include/uapi/linux/serial_core.h
F:	include/uapi/linux/serial.h
F:	include/uapi/linux/tty.h

TUA9001 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
W:	http://palosaari.fi/linux/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
S:	Maintained
F:	drivers/media/tuners/tua9001*

TULIP NETWORK DRIVERS
L:	netdev@vger.kernel.org
L:	linux-parisc@vger.kernel.org
S:	Orphan
F:	drivers/net/ethernet/dec/tulip/

TUN/TAP driver
M:	Maxim Krasnyansky <maxk@qti.qualcomm.com>
W:	http://vtun.sourceforge.net/tun
S:	Maintained
F:	Documentation/networking/tuntap.txt
F:	arch/um/os-Linux/drivers/

TURBOCHANNEL SUBSYSTEM
M:	"Maciej W. Rozycki" <macro@linux-mips.org>
M:	Ralf Baechle <ralf@linux-mips.org>
L:	linux-mips@linux-mips.org
Q:	http://patchwork.linux-mips.org/project/linux-mips/list/
S:	Maintained
F:	drivers/tc/
F:	include/linux/tc.h

TURBOSTAT UTILITY
M:	"Len Brown" <lenb@kernel.org>
L:	linux-pm@vger.kernel.org
B:	https://bugzilla.kernel.org
Q:	https://patchwork.kernel.org/project/linux-pm/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux.git turbostat
S:	Supported
F:	tools/power/x86/turbostat/

TW5864 VIDEO4LINUX DRIVER
M:	Bluecherry Maintainers <maintainers@bluecherrydvr.com>
M:	Anton Sviridenko <anton@corp.bluecherry.net>
M:	Andrey Utkin <andrey.utkin@corp.bluecherry.net>
M:	Andrey Utkin <andrey_utkin@fastmail.com>
L:	linux-media@vger.kernel.org
S:	Supported
F:	drivers/media/pci/tw5864/

TW68 VIDEO4LINUX DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Odd Fixes
F:	drivers/media/pci/tw68/

TW686X VIDEO4LINUX DRIVER
M:	Ezequiel Garcia <ezequiel@vanguardiasur.com.ar>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	http://linuxtv.org
S:	Maintained
F:	drivers/media/pci/tw686x/

UBI FILE SYSTEM (UBIFS)
M:	Richard Weinberger <richard@nod.at>
M:	Artem Bityutskiy <dedekind1@gmail.com>
M:	Adrian Hunter <adrian.hunter@intel.com>
L:	linux-mtd@lists.infradead.org
T:	git git://git.infradead.org/ubifs-2.6.git
W:	http://www.linux-mtd.infradead.org/doc/ubifs.html
S:	Supported
F:	Documentation/filesystems/ubifs.txt
F:	fs/ubifs/

UCLINUX (M68KNOMMU AND COLDFIRE)
M:	Greg Ungerer <gerg@linux-m68k.org>
W:	http://www.linux-m68k.org/
W:	http://www.uclinux.org/
L:	linux-m68k@lists.linux-m68k.org
L:	uclinux-dev@uclinux.org  (subscribers-only)
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gerg/m68knommu.git
S:	Maintained
F:	arch/m68k/coldfire/
F:	arch/m68k/68*/
F:	arch/m68k/*/*_no.*
F:	arch/m68k/include/asm/*_no.*

UDF FILESYSTEM
M:	Jan Kara <jack@suse.com>
S:	Maintained
F:	Documentation/filesystems/udf.txt
F:	fs/udf/

UDRAW TABLET
M:	Bastien Nocera <hadess@hadess.net>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/hid/hid-udraw-ps3.c

UFS FILESYSTEM
M:	Evgeniy Dushistov <dushistov@mail.ru>
S:	Maintained
F:	Documentation/filesystems/ufs.txt
F:	fs/ufs/

UHID USERSPACE HID IO DRIVER:
M:	David Herrmann <dh.herrmann@googlemail.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/hid/uhid.c
F:	include/uapi/linux/uhid.h

ULPI BUS
M:	Heikki Krogerus <heikki.krogerus@linux.intel.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/common/ulpi.c
F:	include/linux/ulpi/

ULTRA-WIDEBAND (UWB) SUBSYSTEM:
L:	linux-usb@vger.kernel.org
S:	Orphan
F:	drivers/uwb/
F:	include/linux/uwb.h
F:	include/linux/uwb/

UNICORE32 ARCHITECTURE:
M:	Guan Xuetao <gxt@pku.edu.cn>
W:	http://mprc.pku.edu.cn/~guanxuetao/linux
S:	Maintained
T:	git git://github.com/gxt/linux.git
F:	arch/unicore32/

UNIFDEF
M:	Tony Finch <dot@dotat.at>
W:	http://dotat.at/prog/unifdef
S:	Maintained
F:	scripts/unifdef.c

UNIFORM CDROM DRIVER
M:	Jens Axboe <axboe@kernel.dk>
W:	http://www.kernel.dk
S:	Maintained
F:	Documentation/cdrom/
F:	drivers/cdrom/cdrom.c
F:	include/linux/cdrom.h
F:	include/uapi/linux/cdrom.h

UNISYS S-PAR DRIVERS
M:	David Kershner <david.kershner@unisys.com>
L:	sparmaintainer@unisys.com (Unisys internal)
S:	Supported
F:	include/linux/visorbus.h
F:	drivers/visorbus/
F:	drivers/staging/unisys/

UNIVERSAL FLASH STORAGE HOST CONTROLLER DRIVER
M:	Vinayak Holikatti <vinholikatti@gmail.com>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	Documentation/scsi/ufs.txt
F:	drivers/scsi/ufs/

UNIVERSAL FLASH STORAGE HOST CONTROLLER DRIVER DWC HOOKS
M:	Joao Pinto <jpinto@synopsys.com>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/ufs/*dwc*

UNSORTED BLOCK IMAGES (UBI)
M:	Artem Bityutskiy <dedekind1@gmail.com>
M:	Richard Weinberger <richard@nod.at>
W:	http://www.linux-mtd.infradead.org/
L:	linux-mtd@lists.infradead.org
T:	git git://git.infradead.org/ubifs-2.6.git
S:	Supported
F:	drivers/mtd/ubi/
F:	include/linux/mtd/ubi.h
F:	include/uapi/mtd/ubi-user.h

USB "USBNET" DRIVER FRAMEWORK
M:	Oliver Neukum <oneukum@suse.com>
L:	netdev@vger.kernel.org
W:	http://www.linux-usb.org/usbnet
S:	Maintained
F:	drivers/net/usb/usbnet.c
F:	include/linux/usb/usbnet.h

USB ACM DRIVER
M:	Oliver Neukum <oneukum@suse.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/usb/acm.txt
F:	drivers/usb/class/cdc-acm.*

USB AR5523 WIRELESS DRIVER
M:	Pontus Fuchs <pontus.fuchs@gmail.com>
L:	linux-wireless@vger.kernel.org
S:	Maintained
F:	drivers/net/wireless/ath/ar5523/

USB ATTACHED SCSI
M:	Oliver Neukum <oneukum@suse.com>
L:	linux-usb@vger.kernel.org
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	drivers/usb/storage/uas.c

USB CDC ETHERNET DRIVER
M:	Oliver Neukum <oliver@neukum.org>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/net/usb/cdc_*.c
F:	include/uapi/linux/usb/cdc.h

USB CHAOSKEY DRIVER
M:	Keith Packard <keithp@keithp.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/misc/chaoskey.c

USB CYPRESS C67X00 DRIVER
M:	Peter Korsgaard <jacmet@sunsite.dk>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/c67x00/

USB DAVICOM DM9601 DRIVER
M:	Peter Korsgaard <jacmet@sunsite.dk>
L:	netdev@vger.kernel.org
W:	http://www.linux-usb.org/usbnet
S:	Maintained
F:	drivers/net/usb/dm9601.c

USB DIAMOND RIO500 DRIVER
M:	Cesar Miquel <miquel@df.uba.ar>
L:	rio500-users@lists.sourceforge.net
W:	http://rio500.sourceforge.net
S:	Maintained
F:	drivers/usb/misc/rio500*

USB EHCI DRIVER
M:	Alan Stern <stern@rowland.harvard.edu>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/usb/ehci.txt
F:	drivers/usb/host/ehci*

USB GADGET/PERIPHERAL SUBSYSTEM
M:	Felipe Balbi <balbi@kernel.org>
L:	linux-usb@vger.kernel.org
W:	http://www.linux-usb.org/gadget
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb.git
S:	Maintained
F:	drivers/usb/gadget/
F:	include/linux/usb/gadget*

USB HID/HIDBP DRIVERS (USB KEYBOARDS, MICE, REMOTE CONTROLS, ...)
M:	Jiri Kosina <jikos@kernel.org>
R:	Benjamin Tissoires <benjamin.tissoires@redhat.com>
L:	linux-usb@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid.git
S:	Maintained
F:	Documentation/hid/hiddev.txt
F:	drivers/hid/usbhid/

USB INTEL XHCI ROLE MUX DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/roles/intel-xhci-usb-role-switch.c

USB ISP116X DRIVER
M:	Olav Kongas <ok@artecdesign.ee>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/host/isp116x*
F:	include/linux/usb/isp116x.h

USB LAN78XX ETHERNET DRIVER
M:	Woojung Huh <woojung.huh@microchip.com>
M:	Microchip Linux Driver Support <UNGLinuxDriver@microchip.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/microchip,lan78xx.txt
F:	drivers/net/usb/lan78xx.*
F:	include/dt-bindings/net/microchip-lan78xx.h

USB MASS STORAGE DRIVER
M:	Alan Stern <stern@rowland.harvard.edu>
L:	linux-usb@vger.kernel.org
L:	usb-storage@lists.one-eyed-alien.net
S:	Maintained
W:	http://www.one-eyed-alien.net/~mdharm/linux-usb/
F:	drivers/usb/storage/

USB MIDI DRIVER
M:	Clemens Ladisch <clemens@ladisch.de>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
T:	git git://git.alsa-project.org/alsa-kernel.git
S:	Maintained
F:	sound/usb/midi.*

USB NETWORKING DRIVERS
L:	linux-usb@vger.kernel.org
S:	Odd Fixes
F:	drivers/net/usb/

USB OHCI DRIVER
M:	Alan Stern <stern@rowland.harvard.edu>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/usb/ohci.txt
F:	drivers/usb/host/ohci*

USB OTG FSM (Finite State Machine)
M:	Peter Chen <Peter.Chen@nxp.com>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/peter.chen/usb.git
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/common/usb-otg-fsm.c

USB OVER IP DRIVER
M:	Valentina Manea <valentina.manea.m@gmail.com>
M:	Shuah Khan <shuah@kernel.org>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/usb/usbip_protocol.txt
F:	drivers/usb/usbip/
F:	tools/usb/usbip/
F:	tools/testing/selftests/drivers/usb/usbip/

USB PEGASUS DRIVER
M:	Petko Manolov <petkan@nucleusys.com>
L:	linux-usb@vger.kernel.org
L:	netdev@vger.kernel.org
T:	git git://github.com/petkan/pegasus.git
W:	https://github.com/petkan/pegasus
S:	Maintained
F:	drivers/net/usb/pegasus.*

USB PHY LAYER
M:	Felipe Balbi <balbi@kernel.org>
L:	linux-usb@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb.git
S:	Maintained
F:	drivers/usb/phy/

USB PRINTER DRIVER (usblp)
M:	Pete Zaitcev <zaitcev@redhat.com>
L:	linux-usb@vger.kernel.org
S:	Supported
F:	drivers/usb/class/usblp.c

USB QMI WWAN NETWORK DRIVER
M:	Bjørn Mork <bjorn@mork.no>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-class-net-qmi
F:	drivers/net/usb/qmi_wwan.c

USB RTL8150 DRIVER
M:	Petko Manolov <petkan@nucleusys.com>
L:	linux-usb@vger.kernel.org
L:	netdev@vger.kernel.org
T:	git git://github.com/petkan/rtl8150.git
W:	https://github.com/petkan/rtl8150
S:	Maintained
F:	drivers/net/usb/rtl8150.c

USB SERIAL SUBSYSTEM
M:	Johan Hovold <johan@kernel.org>
L:	linux-usb@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/johan/usb-serial.git
S:	Maintained
F:	Documentation/usb/usb-serial.txt
F:	drivers/usb/serial/
F:	include/linux/usb/serial.h

USB SMSC75XX ETHERNET DRIVER
M:	Steve Glendinning <steve.glendinning@shawell.net>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/usb/smsc75xx.*

USB SMSC95XX ETHERNET DRIVER
M:	Steve Glendinning <steve.glendinning@shawell.net>
M:	Microchip Linux Driver Support <UNGLinuxDriver@microchip.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/usb/smsc95xx.*

USB SUBSYSTEM
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
L:	linux-usb@vger.kernel.org
W:	http://www.linux-usb.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb.git
S:	Supported
F:	Documentation/devicetree/bindings/usb/
F:	Documentation/usb/
F:	drivers/usb/
F:	include/linux/usb.h
F:	include/linux/usb/

USB TYPEC PI3USB30532 MUX DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/typec/mux/pi3usb30532.c

USB TYPEC SUBSYSTEM
M:	Heikki Krogerus <heikki.krogerus@linux.intel.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-class-typec
F:	Documentation/usb/typec.rst
F:	drivers/usb/typec/
F:	include/linux/usb/typec.h

USB UHCI DRIVER
M:	Alan Stern <stern@rowland.harvard.edu>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/host/uhci*

USB VIDEO CLASS
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-uvc-devel@lists.sourceforge.net (subscribers-only)
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	http://www.ideasonboard.org/uvc/
S:	Maintained
F:	drivers/media/usb/uvc/
F:	include/uapi/linux/uvcvideo.h

USB VISION DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Odd Fixes
F:	drivers/media/usb/usbvision/

USB WEBCAM GADGET
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/gadget/function/*uvc*
F:	drivers/usb/gadget/legacy/webcam.c

USB WIRELESS RNDIS DRIVER (rndis_wlan)
M:	Jussi Kivilinna <jussi.kivilinna@iki.fi>
L:	linux-wireless@vger.kernel.org
S:	Maintained
F:	drivers/net/wireless/rndis_wlan.c

USB XHCI DRIVER
M:	Mathias Nyman <mathias.nyman@intel.com>
L:	linux-usb@vger.kernel.org
S:	Supported
F:	drivers/usb/host/xhci*
F:	drivers/usb/host/pci-quirks*

USB ZD1201 DRIVER
L:	linux-wireless@vger.kernel.org
W:	http://linux-lc100020.sourceforge.net
S:	Orphan
F:	drivers/net/wireless/zydas/zd1201.*

USB ZR364XX DRIVER
M:	Antoine Jacquet <royale@zerezo.com>
L:	linux-usb@vger.kernel.org
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	http://royale.zerezo.com/zr364xx/
S:	Maintained
F:	Documentation/media/v4l-drivers/zr364xx*
F:	drivers/media/usb/zr364xx/

USER-MODE LINUX (UML)
M:	Jeff Dike <jdike@addtoit.com>
M:	Richard Weinberger <richard@nod.at>
L:	linux-um@lists.infradead.org
W:	http://user-mode-linux.sourceforge.net
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rw/uml.git
S:	Maintained
F:	Documentation/virtual/uml/
F:	arch/um/
F:	arch/x86/um/
F:	fs/hostfs/
F:	fs/hppfs/

USERSPACE I/O (UIO)
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc.git
F:	Documentation/driver-api/uio-howto.rst
F:	drivers/uio/
F:	include/linux/uio*.h

UTIL-LINUX PACKAGE
M:	Karel Zak <kzak@redhat.com>
L:	util-linux@vger.kernel.org
W:	http://en.wikipedia.org/wiki/Util-linux
T:	git git://git.kernel.org/pub/scm/utils/util-linux/util-linux.git
S:	Maintained

UUID HELPERS
M:	Christoph Hellwig <hch@lst.de>
R:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
L:	linux-kernel@vger.kernel.org
T:	git git://git.infradead.org/users/hch/uuid.git
F:	lib/uuid.c
F:	lib/test_uuid.c
F:	include/linux/uuid.h
F:	include/uapi/linux/uuid.h
S:	Maintained

UVESAFB DRIVER
M:	Michal Januszewski <spock@gentoo.org>
L:	linux-fbdev@vger.kernel.org
W:	http://dev.gentoo.org/~spock/projects/uvesafb/
S:	Maintained
F:	Documentation/fb/uvesafb.txt
F:	drivers/video/fbdev/uvesafb.*

VF610 NAND DRIVER
M:	Stefan Agner <stefan@agner.ch>
L:	linux-mtd@lists.infradead.org
S:	Supported
F:	drivers/mtd/nand/raw/vf610_nfc.c

VFAT/FAT/MSDOS FILESYSTEM
M:	OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
S:	Maintained
F:	Documentation/filesystems/vfat.txt
F:	fs/fat/

VFIO DRIVER
M:	Alex Williamson <alex.williamson@redhat.com>
L:	kvm@vger.kernel.org
T:	git git://github.com/awilliam/linux-vfio.git
S:	Maintained
F:	Documentation/vfio.txt
F:	drivers/vfio/
F:	include/linux/vfio.h
F:	include/uapi/linux/vfio.h

VFIO MEDIATED DEVICE DRIVERS
M:	Kirti Wankhede <kwankhede@nvidia.com>
L:	kvm@vger.kernel.org
S:	Maintained
F:	Documentation/vfio-mediated-device.txt
F:	drivers/vfio/mdev/
F:	include/linux/mdev.h
F:	samples/vfio-mdev/

VFIO PLATFORM DRIVER
M:	Eric Auger <eric.auger@redhat.com>
L:	kvm@vger.kernel.org
S:	Maintained
F:	drivers/vfio/platform/

VGA_SWITCHEROO
R:	Lukas Wunner <lukas@wunner.de>
S:	Maintained
F:	Documentation/gpu/vga-switcheroo.rst
F:	drivers/gpu/vga/vga_switcheroo.c
F:	include/linux/vga_switcheroo.h
T:	git git://anongit.freedesktop.org/drm/drm-misc

VIA RHINE NETWORK DRIVER
S:	Orphan
F:	drivers/net/ethernet/via/via-rhine.c

VIA SD/MMC CARD CONTROLLER DRIVER
M:	Bruce Chang <brucechang@via.com.tw>
M:	Harald Welte <HaraldWelte@viatech.com>
S:	Maintained
F:	drivers/mmc/host/via-sdmmc.c

VIA UNICHROME(PRO)/CHROME9 FRAMEBUFFER DRIVER
M:	Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
F:	include/linux/via-core.h
F:	include/linux/via-gpio.h
F:	include/linux/via_i2c.h
F:	drivers/video/fbdev/via/

VIA VELOCITY NETWORK DRIVER
M:	Francois Romieu <romieu@fr.zoreil.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/via/via-velocity.*

VIDEO MULTIPLEXER DRIVER
M:	Philipp Zabel <p.zabel@pengutronix.de>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/platform/video-mux.c

VIDEO I2C POLLING DRIVER
M:	Matt Ranostay <matt.ranostay@konsulko.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/video-i2c.c

VIDEOBUF2 FRAMEWORK
M:	Pawel Osciak <pawel@osciak.com>
M:	Marek Szyprowski <m.szyprowski@samsung.com>
M:	Kyungmin Park <kyungmin.park@samsung.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/v4l2-core/videobuf2-*
F:	include/media/videobuf2-*

VIMC VIRTUAL MEDIA CONTROLLER DRIVER
M:	Helen Koike <helen.koike@collabora.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/platform/vimc/*

VIRT LIB
M:	Alex Williamson <alex.williamson@redhat.com>
M:	Paolo Bonzini <pbonzini@redhat.com>
L:	kvm@vger.kernel.org
S:	Supported
F:	virt/lib/

VIRTIO AND VHOST VSOCK DRIVER
M:	Stefan Hajnoczi <stefanha@redhat.com>
L:	kvm@vger.kernel.org
L:	virtualization@lists.linux-foundation.org
L:	netdev@vger.kernel.org
S:	Maintained
F:	include/linux/virtio_vsock.h
F:	include/uapi/linux/virtio_vsock.h
F:	include/uapi/linux/vsockmon.h
F:	include/uapi/linux/vm_sockets_diag.h
F:	net/vmw_vsock/diag.c
F:	net/vmw_vsock/af_vsock_tap.c
F:	net/vmw_vsock/virtio_transport_common.c
F:	net/vmw_vsock/virtio_transport.c
F:	drivers/net/vsockmon.c
F:	drivers/vhost/vsock.c
F:	drivers/vhost/vsock.h
F:	tools/testing/vsock/

VIRTIO CONSOLE DRIVER
M:	Amit Shah <amit@kernel.org>
L:	virtualization@lists.linux-foundation.org
S:	Maintained
F:	drivers/char/virtio_console.c
F:	include/linux/virtio_console.h
F:	include/uapi/linux/virtio_console.h

VIRTIO CORE, NET AND BLOCK DRIVERS
M:	"Michael S. Tsirkin" <mst@redhat.com>
M:	Jason Wang <jasowang@redhat.com>
L:	virtualization@lists.linux-foundation.org
S:	Maintained
F:	Documentation/devicetree/bindings/virtio/
F:	drivers/virtio/
F:	tools/virtio/
F:	drivers/net/virtio_net.c
F:	drivers/block/virtio_blk.c
F:	include/linux/virtio*.h
F:	include/uapi/linux/virtio_*.h
F:	drivers/crypto/virtio/
F:	mm/balloon_compaction.c

VIRTIO CRYPTO DRIVER
M:	Gonglei <arei.gonglei@huawei.com>
L:	virtualization@lists.linux-foundation.org
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	drivers/crypto/virtio/
F:	include/uapi/linux/virtio_crypto.h

VIRTIO DRIVERS FOR S390
M:	Cornelia Huck <cohuck@redhat.com>
M:	Halil Pasic <pasic@linux.ibm.com>
L:	linux-s390@vger.kernel.org
L:	virtualization@lists.linux-foundation.org
L:	kvm@vger.kernel.org
S:	Supported
F:	drivers/s390/virtio/
F:	arch/s390/include/uapi/asm/virtio-ccw.h

VIRTIO GPU DRIVER
M:	David Airlie <airlied@linux.ie>
M:	Gerd Hoffmann <kraxel@redhat.com>
L:	dri-devel@lists.freedesktop.org
L:	virtualization@lists.linux-foundation.org
T:	git git://anongit.freedesktop.org/drm/drm-misc
S:	Maintained
F:	drivers/gpu/drm/virtio/
F:	include/uapi/linux/virtio_gpu.h

VIRTIO HOST (VHOST)
M:	"Michael S. Tsirkin" <mst@redhat.com>
M:	Jason Wang <jasowang@redhat.com>
L:	kvm@vger.kernel.org
L:	virtualization@lists.linux-foundation.org
L:	netdev@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost.git
S:	Maintained
F:	drivers/vhost/
F:	include/uapi/linux/vhost.h

VIRTIO INPUT DRIVER
M:	Gerd Hoffmann <kraxel@redhat.com>
S:	Maintained
F:	drivers/virtio/virtio_input.c
F:	include/uapi/linux/virtio_input.h

VIRTUAL BOX GUEST DEVICE DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
M:	Arnd Bergmann <arnd@arndb.de>
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
S:	Maintained
F:	include/linux/vbox_utils.h
F:	include/uapi/linux/vbox*.h
F:	drivers/virt/vboxguest/

VIRTUAL SERIO DEVICE DRIVER
M:	Stephen Chandler Paul <thatslyude@gmail.com>
S:	Maintained
F:	drivers/input/serio/userio.c
F:	include/uapi/linux/userio.h

VIVID VIRTUAL VIDEO DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
W:	https://linuxtv.org
S:	Maintained
F:	drivers/media/platform/vivid/*

VLYNQ BUS
M:	Florian Fainelli <f.fainelli@gmail.com>
L:	openwrt-devel@lists.openwrt.org (subscribers-only)
S:	Maintained
F:	drivers/vlynq/vlynq.c
F:	include/linux/vlynq.h

VME SUBSYSTEM
M:	Martyn Welch <martyn@welchs.me.uk>
M:	Manohar Vanga <manohar.vanga@gmail.com>
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
L:	devel@driverdev.osuosl.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc.git
F:	Documentation/driver-api/vme.rst
F:	drivers/staging/vme/
F:	drivers/vme/
F:	include/linux/vme*

VMWARE BALLOON DRIVER
M:	Xavier Deguillard <xdeguillard@vmware.com>
M:	Philip Moltmann <moltmann@vmware.com>
M:	"VMware, Inc." <pv-drivers@vmware.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/misc/vmw_balloon.c

VMWARE HYPERVISOR INTERFACE
M:	Alok Kataria <akataria@vmware.com>
L:	virtualization@lists.linux-foundation.org
S:	Supported
F:	arch/x86/kernel/cpu/vmware.c

VMWARE PVRDMA DRIVER
M:	Adit Ranadive <aditr@vmware.com>
M:	VMware PV-Drivers <pv-drivers@vmware.com>
L:	linux-rdma@vger.kernel.org
S:	Maintained
F:	drivers/infiniband/hw/vmw_pvrdma/

VMware PVSCSI driver
M:	Jim Gill <jgill@vmware.com>
M:	VMware PV-Drivers <pv-drivers@vmware.com>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	drivers/scsi/vmw_pvscsi.c
F:	drivers/scsi/vmw_pvscsi.h

VMWARE VMMOUSE SUBDRIVER
M:	"VMware Graphics" <linux-graphics-maintainer@vmware.com>
M:	"VMware, Inc." <pv-drivers@vmware.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/input/mouse/vmmouse.c
F:	drivers/input/mouse/vmmouse.h

VMWARE VMXNET3 ETHERNET DRIVER
M:	Ronak Doshi <doshir@vmware.com>
M:	"VMware, Inc." <pv-drivers@vmware.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/vmxnet3/

VOCORE VOCORE2 BOARD
M:	Harvey Hunt <harveyhuntnexus@gmail.com>
L:	linux-mips@linux-mips.org
S:	Maintained
F:	arch/mips/boot/dts/ralink/vocore2.dts

VOLTAGE AND CURRENT REGULATOR FRAMEWORK
M:	Liam Girdwood <lgirdwood@gmail.com>
M:	Mark Brown <broonie@kernel.org>
L:	linux-kernel@vger.kernel.org
W:	http://www.slimlogic.co.uk/?p=48
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regulator.git
S:	Supported
F:	Documentation/devicetree/bindings/regulator/
F:	Documentation/power/regulator/
F:	drivers/regulator/
F:	include/dt-bindings/regulator/
F:	include/linux/regulator/

VRF
M:	David Ahern <dsa@cumulusnetworks.com>
M:	Shrijeet Mukherjee <shm@cumulusnetworks.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/vrf.c
F:	Documentation/networking/vrf.txt

VT1211 HARDWARE MONITOR DRIVER
M:	Juerg Haefliger <juergh@gmail.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/vt1211
F:	drivers/hwmon/vt1211.c

VT8231 HARDWARE MONITOR DRIVER
M:	Roger Lucas <vt8231@hiddenengine.co.uk>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/vt8231.c

VUB300 USB to SDIO/SD/MMC bridge chip
M:	Tony Olech <tony.olech@elandigitalsystems.com>
L:	linux-mmc@vger.kernel.org
L:	linux-usb@vger.kernel.org
S:	Supported
F:	drivers/mmc/host/vub300.c

W1 DALLAS'S 1-WIRE BUS
M:	Evgeniy Polyakov <zbr@ioremap.net>
S:	Maintained
F:	Documentation/w1/
F:	drivers/w1/
F:	include/linux/w1.h

W83791D HARDWARE MONITORING DRIVER
M:	Marc Hulsman <m.hulsman@tudelft.nl>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/w83791d
F:	drivers/hwmon/w83791d.c

W83793 HARDWARE MONITORING DRIVER
M:	Rudolf Marek <r.marek@assembler.cz>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/w83793
F:	drivers/hwmon/w83793.c

W83795 HARDWARE MONITORING DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/w83795.c

W83L51xD SD/MMC CARD INTERFACE DRIVER
M:	Pierre Ossman <pierre@ossman.eu>
S:	Maintained
F:	drivers/mmc/host/wbsd.*

WACOM PROTOCOL 4 SERIAL TABLETS
M:	Julian Squires <julian@cipht.net>
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/input/tablet/wacom_serial4.c

WATCHDOG DEVICE DRIVERS
M:	Wim Van Sebroeck <wim@linux-watchdog.org>
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-watchdog@vger.kernel.org
W:	http://www.linux-watchdog.org/
T:	git git://www.linux-watchdog.org/linux-watchdog.git
S:	Maintained
F:	Documentation/devicetree/bindings/watchdog/
F:	Documentation/watchdog/
F:	drivers/watchdog/
F:	include/linux/watchdog.h
F:	include/uapi/linux/watchdog.h

WHISKEYCOVE PMIC GPIO DRIVER
M:	Kuppuswamy Sathyanarayanan <sathyanarayanan.kuppuswamy@linux.intel.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-wcove.c

WIIMOTE HID DRIVER
M:	David Herrmann <dh.herrmann@googlemail.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/hid/hid-wiimote*

WILOCITY WIL6210 WIRELESS DRIVER
M:	Maya Erez <merez@codeaurora.org>
L:	linux-wireless@vger.kernel.org
L:	wil6210@qti.qualcomm.com
S:	Supported
W:	http://wireless.kernel.org/en/users/Drivers/wil6210
F:	drivers/net/wireless/ath/wil6210/

WIMAX STACK
M:	Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
M:	linux-wimax@intel.com
L:	wimax@linuxwimax.org (subscribers-only)
S:	Supported
W:	http://linuxwimax.org
F:	Documentation/wimax/README.wimax
F:	include/linux/wimax/debug.h
F:	include/net/wimax.h
F:	include/uapi/linux/wimax.h
F:	net/wimax/

WINBOND CIR DRIVER
M:	David Härdeman <david@hardeman.nu>
S:	Maintained
F:	drivers/media/rc/winbond-cir.c

WINSYSTEMS EBC-C384 WATCHDOG DRIVER
M:	William Breathitt Gray <vilhelm.gray@gmail.com>
L:	linux-watchdog@vger.kernel.org
S:	Maintained
F:	drivers/watchdog/ebc-c384_wdt.c

WINSYSTEMS WS16C48 GPIO DRIVER
M:	William Breathitt Gray <vilhelm.gray@gmail.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-ws16c48.c

WISTRON LAPTOP BUTTON DRIVER
M:	Miloslav Trmac <mitr@volny.cz>
S:	Maintained
F:	drivers/input/misc/wistron_btns.c

WL3501 WIRELESS PCMCIA CARD DRIVER
L:	linux-wireless@vger.kernel.org
S:	Odd fixes
F:	drivers/net/wireless/wl3501*

WOLFSON MICROELECTRONICS DRIVERS
L:	patches@opensource.cirrus.com
T:	git https://github.com/CirrusLogic/linux-drivers.git
W:	https://github.com/CirrusLogic/linux-drivers/wiki
S:	Supported
F:	Documentation/hwmon/wm83??
F:	Documentation/devicetree/bindings/extcon/extcon-arizona.txt
F:	Documentation/devicetree/bindings/regulator/arizona-regulator.txt
F:	Documentation/devicetree/bindings/mfd/arizona.txt
F:	Documentation/devicetree/bindings/mfd/wm831x.txt
F:	Documentation/devicetree/bindings/sound/wlf,arizona.txt
F:	arch/arm/mach-s3c64xx/mach-crag6410*
F:	drivers/clk/clk-wm83*.c
F:	drivers/extcon/extcon-arizona.c
F:	drivers/leds/leds-wm83*.c
F:	drivers/gpio/gpio-*wm*.c
F:	drivers/gpio/gpio-arizona.c
F:	drivers/hwmon/wm83??-hwmon.c
F:	drivers/input/misc/wm831x-on.c
F:	drivers/input/touchscreen/wm831x-ts.c
F:	drivers/input/touchscreen/wm97*.c
F:	drivers/mfd/arizona*
F:	drivers/mfd/wm*.c
F:	drivers/mfd/cs47l24*
F:	drivers/power/supply/wm83*.c
F:	drivers/rtc/rtc-wm83*.c
F:	drivers/regulator/wm8*.c
F:	drivers/regulator/arizona*
F:	drivers/video/backlight/wm83*_bl.c
F:	drivers/watchdog/wm83*_wdt.c
F:	include/linux/mfd/arizona/
F:	include/linux/mfd/wm831x/
F:	include/linux/mfd/wm8350/
F:	include/linux/mfd/wm8400*
F:	include/linux/regulator/arizona*
F:	include/linux/wm97xx.h
F:	include/sound/wm????.h
F:	sound/soc/codecs/arizona.?
F:	sound/soc/codecs/wm*
F:	sound/soc/codecs/cs47l24*

WORKQUEUE
M:	Tejun Heo <tj@kernel.org>
R:	Lai Jiangshan <jiangshanlai@gmail.com>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq.git
S:	Maintained
F:	include/linux/workqueue.h
F:	kernel/workqueue.c
F:	Documentation/core-api/workqueue.rst

X-POWERS AXP288 PMIC DRIVERS
M:	Hans de Goede <hdegoede@redhat.com>
S:	Maintained
N:	axp288
F:	drivers/acpi/pmic/intel_pmic_xpower.c

X-POWERS MULTIFUNCTION PMIC DEVICE DRIVERS
M:	Chen-Yu Tsai <wens@csie.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
N:	axp[128]

X.25 NETWORK LAYER
M:	Andrew Hendry <andrew.hendry@gmail.com>
L:	linux-x25@vger.kernel.org
S:	Odd Fixes
F:	Documentation/networking/x25*
F:	include/net/x25*
F:	net/x25/

X86 ARCHITECTURE (32-BIT AND 64-BIT)
M:	Thomas Gleixner <tglx@linutronix.de>
M:	Ingo Molnar <mingo@redhat.com>
R:	"H. Peter Anvin" <hpa@zytor.com>
M:	x86@kernel.org
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git x86/core
S:	Maintained
F:	Documentation/x86/
F:	arch/x86/

X86 MCE INFRASTRUCTURE
M:	Tony Luck <tony.luck@intel.com>
M:	Borislav Petkov <bp@alien8.de>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	arch/x86/kernel/cpu/mcheck/*

X86 MICROCODE UPDATE SUPPORT
M:	Borislav Petkov <bp@alien8.de>
S:	Maintained
F:	arch/x86/kernel/cpu/microcode/*

X86 PLATFORM DRIVERS
M:	Darren Hart <dvhart@infradead.org>
M:	Andy Shevchenko <andy@infradead.org>
L:	platform-driver-x86@vger.kernel.org
T:	git git://git.infradead.org/linux-platform-drivers-x86.git
S:	Maintained
F:	drivers/platform/x86/
F:	drivers/platform/olpc/

X86 VDSO
M:	Andy Lutomirski <luto@amacapital.net>
L:	linux-kernel@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git x86/vdso
S:	Maintained
F:	arch/x86/entry/vdso/

XC2028/3028 TUNER DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
S:	Maintained
F:	drivers/media/tuners/tuner-xc2028.*

XDP SOCKETS (AF_XDP)
M:	Björn Töpel <bjorn.topel@intel.com>
M:	Magnus Karlsson <magnus.karlsson@intel.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	kernel/bpf/xskmap.c
F:	net/xdp/

XEN BLOCK SUBSYSTEM
M:	Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
M:	Roger Pau Monné <roger.pau@citrix.com>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
S:	Supported
F:	drivers/block/xen-blkback/*
F:	drivers/block/xen*

XEN HYPERVISOR ARM
M:	Stefano Stabellini <sstabellini@kernel.org>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/xen/
F:	arch/arm/include/asm/xen/

XEN HYPERVISOR ARM64
M:	Stefano Stabellini <sstabellini@kernel.org>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm64/xen/
F:	arch/arm64/include/asm/xen/

XEN HYPERVISOR INTERFACE
M:	Boris Ostrovsky <boris.ostrovsky@oracle.com>
M:	Juergen Gross <jgross@suse.com>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/xen/tip.git
S:	Supported
F:	arch/x86/xen/
F:	drivers/*/xen-*front.c
F:	drivers/xen/
F:	arch/x86/include/asm/xen/
F:	arch/x86/include/asm/pvclock-abi.h
F:	include/xen/
F:	include/uapi/xen/
F:	Documentation/ABI/stable/sysfs-hypervisor-xen
F:	Documentation/ABI/testing/sysfs-hypervisor-xen

XEN NETWORK BACKEND DRIVER
M:	Wei Liu <wei.liu2@citrix.com>
M:	Paul Durrant <paul.durrant@citrix.com>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/xen-netback/*

XEN PCI SUBSYSTEM
M:	Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
S:	Supported
F:	arch/x86/pci/*xen*
F:	drivers/pci/*xen*

XEN PVSCSI DRIVERS
M:	Juergen Gross <jgross@suse.com>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/xen-scsifront.c
F:	drivers/xen/xen-scsiback.c
F:	include/xen/interface/io/vscsiif.h

XEN SWIOTLB SUBSYSTEM
M:	Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
L:	iommu@lists.linux-foundation.org
S:	Supported
F:	arch/x86/xen/*swiotlb*
F:	drivers/xen/*swiotlb*

XEN SOUND FRONTEND DRIVER
M:	Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Supported
F:	sound/xen/*

XFS FILESYSTEM
M:	Darrick J. Wong <darrick.wong@oracle.com>
M:	linux-xfs@vger.kernel.org
L:	linux-xfs@vger.kernel.org
W:	http://xfs.org/
T:	git git://git.kernel.org/pub/scm/fs/xfs/xfs-linux.git
S:	Supported
F:	Documentation/filesystems/xfs.txt
F:	fs/xfs/

XILINX AXI ETHERNET DRIVER
M:	Anirudha Sarangi <anirudh@xilinx.com>
M:	John Linn <John.Linn@xilinx.com>
S:	Maintained
F:	drivers/net/ethernet/xilinx/xilinx_axienet*

XILINX UARTLITE SERIAL DRIVER
M:	Peter Korsgaard <jacmet@sunsite.dk>
L:	linux-serial@vger.kernel.org
S:	Maintained
F:	drivers/tty/serial/uartlite.c

XILINX VIDEO IP CORES
M:	Hyun Kwon <hyun.kwon@xilinx.com>
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-media@vger.kernel.org
T:	git git://linuxtv.org/media_tree.git
S:	Supported
F:	Documentation/devicetree/bindings/media/xilinx/
F:	drivers/media/platform/xilinx/
F:	include/uapi/linux/xilinx-v4l2-controls.h

XILLYBUS DRIVER
M:	Eli Billauer <eli.billauer@gmail.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	drivers/char/xillybus/

XLP9XX I2C DRIVER
M:	George Cherian <george.cherian@cavium.com>
M:	Jan Glauber <jglauber@cavium.com>
L:	linux-i2c@vger.kernel.org
W:	http://www.cavium.com
S:	Supported
F:	drivers/i2c/busses/i2c-xlp9xx.c

XRA1403 GPIO EXPANDER
M:	Nandor Han <nandor.han@ge.com>
M:	Semi Malinen <semi.malinen@ge.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-xra1403.c
F:	Documentation/devicetree/bindings/gpio/gpio-xra1403.txt

XTENSA XTFPGA PLATFORM SUPPORT
M:	Max Filippov <jcmvbkbc@gmail.com>
L:	linux-xtensa@linux-xtensa.org
S:	Maintained
F:	drivers/spi/spi-xtensa-xtfpga.c
F:	sound/soc/xtensa/xtfpga-i2s.c

YAM DRIVER FOR AX.25
M:	Jean-Paul Roubelat <jpr@f6fbb.org>
L:	linux-hams@vger.kernel.org
S:	Maintained
F:	drivers/net/hamradio/yam*
F:	include/linux/yam.h

YAMA SECURITY MODULE
M:	Kees Cook <keescook@chromium.org>
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git yama/tip
S:	Supported
F:	security/yama/
F:	Documentation/admin-guide/LSM/Yama.rst

YEALINK PHONE DRIVER
M:	Henk Vergonet <Henk.Vergonet@gmail.com>
L:	usbb2k-api-dev@nongnu.org
S:	Maintained
F:	Documentation/input/yealink.rst
F:	drivers/input/misc/yealink.*

Z8530 DRIVER FOR AX.25
M:	Joerg Reuter <jreuter@yaina.de>
W:	http://yaina.de/jreuter/
W:	http://www.qsl.net/dl1bke/
L:	linux-hams@vger.kernel.org
S:	Maintained
F:	Documentation/networking/z8530drv.txt
F:	drivers/net/hamradio/*scc.c
F:	drivers/net/hamradio/z8530.h

ZBUD COMPRESSED PAGE ALLOCATOR
M:	Seth Jennings <sjenning@redhat.com>
M:	Dan Streetman <ddstreet@ieee.org>
L:	linux-mm@kvack.org
S:	Maintained
F:	mm/zbud.c
F:	include/linux/zbud.h

ZD1211RW WIRELESS DRIVER
M:	Daniel Drake <dsd@gentoo.org>
M:	Ulrich Kunitz <kune@deine-taler.de>
W:	http://zd1211.ath.cx/wiki/DriverRewrite
L:	linux-wireless@vger.kernel.org
L:	zd1211-devs@lists.sourceforge.net (subscribers-only)
S:	Maintained
F:	drivers/net/wireless/zydas/zd1211rw/

ZD1301 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org/
W:	http://palosaari.fi/linux/
Q:	https://patchwork.linuxtv.org/project/linux-media/list/
S:	Maintained
F:	drivers/media/usb/dvb-usb-v2/zd1301*

ZD1301_DEMOD MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
W:	https://linuxtv.org/
W:	http://palosaari.fi/linux/
Q:	https://patchwork.linuxtv.org/project/linux-media/list/
S:	Maintained
F:	drivers/media/dvb-frontends/zd1301_demod*

ZPOOL COMPRESSED PAGE STORAGE API
M:	Dan Streetman <ddstreet@ieee.org>
L:	linux-mm@kvack.org
S:	Maintained
F:	mm/zpool.c
F:	include/linux/zpool.h

ZR36067 VIDEO FOR LINUX DRIVER
L:	mjpeg-users@lists.sourceforge.net
L:	linux-media@vger.kernel.org
W:	http://mjpeg.sourceforge.net/driver-zoran/
T:	hg https://linuxtv.org/hg/v4l-dvb
S:	Odd Fixes
F:	drivers/staging/media/zoran/

ZRAM COMPRESSED RAM BLOCK DEVICE DRVIER
M:	Minchan Kim <minchan@kernel.org>
M:	Nitin Gupta <ngupta@vflare.org>
R:	Sergey Senozhatsky <sergey.senozhatsky.work@gmail.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/block/zram/
F:	Documentation/blockdev/zram.txt

ZS DECSTATION Z85C30 SERIAL DRIVER
M:	"Maciej W. Rozycki" <macro@linux-mips.org>
S:	Maintained
F:	drivers/tty/serial/zs.*

ZSMALLOC COMPRESSED SLAB MEMORY ALLOCATOR
M:	Minchan Kim <minchan@kernel.org>
M:	Nitin Gupta <ngupta@vflare.org>
R:	Sergey Senozhatsky <sergey.senozhatsky.work@gmail.com>
L:	linux-mm@kvack.org
S:	Maintained
F:	mm/zsmalloc.c
F:	include/linux/zsmalloc.h
F:	Documentation/vm/zsmalloc.rst

ZSWAP COMPRESSED SWAP CACHING
M:	Seth Jennings <sjenning@redhat.com>
M:	Dan Streetman <ddstreet@ieee.org>
L:	linux-mm@kvack.org
S:	Maintained
F:	mm/zswap.c

THE REST
M:	Linus Torvalds <torvalds@linux-foundation.org>
L:	linux-kernel@vger.kernel.org
Q:	http://patchwork.kernel.org/project/LKML/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
S:	Buried alive in reporters
F:	*
F:	*/
